lilJudd/build.gradle.kts

/*
 * lilJudd
 * Copyright (C) 2023 moonleay
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

import org.jetbrains.gradle.ext.ProjectSettings
import org.jetbrains.gradle.ext.TaskTriggersConfig
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.8.20"
    id("com.github.johnrengelman.shadow") version "7.1.2"
    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.6"
    `maven-publish`
}

//lilJudd version 2
val ownerID = 372703841151614976L
group = "net.moonleay.liljudd"
version = System.getenv("CI_COMMIT_TAG")?.let { "$it-${System.getenv("CI_COMMIT_SHORT_SHA")}-prod" }
    ?: System.getenv("CI_COMMIT_SHORT_SHA")?.let { "$it-dev" }
            ?: "2.5.0"

val kordver = "1.5.6"
val coroutinesver = "1.1.0"
val ktor_version = "2.3.0"
val exposedver = "0.40.1"
val postgresver = "42.3.8"
val krontabver = "2.1.2"

val mavenArtifact = "lilJudd"
project.base.archivesName.set(mavenArtifact)

repositories {
    mavenCentral()
    maven {
        name = "Gitlab"
        val projectId = System.getenv("CI_PROJECT_ID")
        val apiV4 = System.getenv("CI_API_V4_URL")
        url = uri("https://$apiV4/projects/$projectId/packages/maven")
        authentication {
            create("header", HttpHeaderAuthentication::class.java) {
                if (System.getenv("CI_JOB_TOKEN") != null) {
                    credentials(HttpHeaderCredentials::class) {
                        name = "Job-Token"
                        value = System.getenv("CI_JOB_TOKEN")
                    }
                } else if (project.hasProperty("myGitlabToken")) {
                    credentials(HttpHeaderCredentials::class) {
                        name = "Private-Token"
                        value = project.ext["myGitlabToken"] as String
                    }
                } else {
                    credentials(HttpHeaderCredentials::class) {
                        name = "none"
                        value = ""
                    }
                }
            }
        }
    }
}

val shadow by configurations.getting
val implementation by configurations.getting
implementation.extendsFrom(shadow)

dependencies {
    //Discord
    shadow("com.kotlindiscord.kord.extensions:kord-extensions:$kordver")
    shadow("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesver")

    //Logging
    shadow("org.slf4j:slf4j-api:2.0.3")
    shadow("org.slf4j:slf4j-simple:2.0.3")

    //Database
    shadow("org.jetbrains.exposed:exposed-core:$exposedver")
    shadow("org.jetbrains.exposed:exposed-dao:$exposedver")
    shadow("org.jetbrains.exposed:exposed-jdbc:$exposedver")
    shadow("org.postgresql:postgresql:$postgresver")

    //Korntab
    shadow("dev.inmo:krontab:$krontabver")
    "shadow"("io.ktor:ktor-client-core-jvm:2.3.1")
    "shadow"("io.ktor:ktor-client-cio-jvm:2.3.1")
}


val targetJavaVersion = 17
val templateSrc = project.rootDir.resolve("src/main/templates")
val templateDest = project.buildDir.resolve("generated/templates")
val templateProps = mapOf(
    "version" to project.version as String,
    "ownerID" to ownerID,
    "kordversion" to kordver,
    "coroutinesversion" to coroutinesver,
    "ktorversion" to ktor_version,
    "exposedversion" to exposedver,
    "postgresversion" to postgresver,
    "krontabversion" to krontabver
)



tasks {
    create<Copy>("generateTemplates") {
        filteringCharset = "UTF-8"

        inputs.properties(templateProps)
        from(templateSrc)
        expand(templateProps)
        into(templateDest)
    }

    withType<Jar> {
        manifest {
            attributes["Main-Class"] = "net.moonleay.lilJudd.MainKt"
        }
        // To add all of the dependencies
        from(sourceSets.main.get().output)

        dependsOn(configurations.runtimeClasspath)
        from({
            configurations.runtimeClasspath.get().filter { it.name.endsWith("jar") }.map { zipTree(it) }
        })
        duplicatesStrategy = DuplicatesStrategy.INCLUDE
        dependsOn("generateTemplates", "processResources")
    }


    withType<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar> {
        configurations = listOf(shadow)
        dependsOn("generateTemplates", "processResources")
    }

    withType<JavaCompile> {
        // ensure that the encoding is set to UTF-8, no matter what the system default is
        // this fixes some edge cases with special characters not displaying correctly
        // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
        // If Javadoc is generated, this must be specified in that task too.
        options.encoding = "UTF-8"
        if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible) {
            options.release.set(targetJavaVersion)
        }

        dependsOn("generateTemplates", "processResources")
    }

    withType<KotlinCompile> {
        kotlinOptions.jvmTarget = targetJavaVersion.toString()

        dependsOn("generateTemplates", "processResources")
    }

    withType<Jar> {
        from("LICENSE") {
            rename { "${it}_${project.base.archivesName.get()}" }
        }

        archiveBaseName.set(mavenArtifact)

        dependsOn("generateTemplates", "processResources")
    }
}


java {
    val javaVersion = JavaVersion.toVersion(targetJavaVersion)
    if (JavaVersion.current() < javaVersion) {
        toolchain.languageVersion.set(JavaLanguageVersion.of(targetJavaVersion))
    }

    withSourcesJar()
}

sourceSets {
    main {
        java {
            srcDir(templateDest)
        }
    }
}

publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            version = project.version as String
            artifactId = mavenArtifact
            from(components["java"])
        }
    }

    repositories {
        if (System.getenv("CI_JOB_TOKEN") != null) {
            maven {
                name = "GitLab"
                val projectId = System.getenv("CI_PROJECT_ID")
                val apiV4 = System.getenv("CI_API_V4_URL")
                url = uri("$apiV4/projects/$projectId/packages/maven")
                authentication {
                    create("token", HttpHeaderAuthentication::class.java) {
                        credentials(HttpHeaderCredentials::class.java) {
                            name = "Job-Token"
                            value = System.getenv("CI_JOB_TOKEN")
                        }
                    }
                }
            }
        }
    }
}

rootProject.idea.project {
    this as ExtensionAware
    configure<ProjectSettings> {
        this as ExtensionAware
        configure<TaskTriggersConfig> {
            afterSync(tasks["generateTemplates"], tasks["processResources"])
        }
    }
}

//rootProject.eclipse.synchronizationTasks("generateTemplates", "processResources")
//Fuck eclipse users amirite?