build.gradle.kts

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import org.gradle.api.tasks.testing.logging.TestExceptionFormat.*
import org.gradle.api.tasks.testing.logging.TestLogEvent.*

group = "net.dzikoysk"
version = "1.2.2"
description = "Exposed Upsert | Exposed extension for upsert operations"

plugins {
    kotlin("jvm") version "1.8.0"
    `java-library`
    application
    jacoco
    signing
    `maven-publish`
    id("io.github.gradle-nexus.publish-plugin") version "1.3.0"
}

publishing {
    repositories {
        maven {
            name = "reposilite-repository"
            url = uri("https://maven.reposilite.com/${if (version.toString().endsWith("-SNAPSHOT")) "snapshots" else "releases"}")

            credentials {
                username = getEnvOrProperty("MAVEN_NAME", "mavenUser")
                password = getEnvOrProperty("MAVEN_TOKEN", "mavenPassword")
            }
        }
    }
    publishing {
        publications {
            create<MavenPublication>("library") {
                pom {
                    name.set(project.name)
                    description.set(project.description)
                    url.set("https://github.com/reposilite-playground/exposed-upsert")

                    licenses {
                        license {
                            name.set("The Apache License, Version 2.0")
                            url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
                        }
                    }
                    developers {
                        developer {
                            id.set("dzikoysk")
                            name.set("dzikoysk")
                            email.set("dzikoysk@dzikoysk.net")
                        }
                    }
                    scm {
                        connection.set("scm:git:git://github.com/reposilite-playground/exposed-upsert.git")
                        developerConnection.set("scm:git:ssh://github.com/reposilite-playground/exposed-upsert.git")
                        url.set("https://github.com/reposilite-playground/exposed-upsert.git")
                    }
                }

                from(components.getByName("java"))
            }
        }
    }

    if (findProperty("signing.keyId").takeIf { it?.toString()?.trim()?.isNotEmpty() == true } != null) {
        signing {
            sign(publishing.publications.getByName("library"))
        }
    }
}

tasks.register("release") {
    dependsOn(
        "clean", "build",
        "publishAllPublicationsToReposilite-repositoryRepository",
        "publishAllPublicationsToSonatypeRepository",
        "closeAndReleaseSonatypeStagingRepository"
    )
}

nexusPublishing {
    repositories.sonatype {
        nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
        username.set(getEnvOrProperty("SONATYPE_USER", "sonatypeUser"))
        password.set(getEnvOrProperty("SONATYPE_PASSWORD", "sonatypePassword"))
    }
}

jacoco {
    toolVersion = "0.8.11"
}

repositories {
    mavenCentral()
}

dependencies {
    val exposed = "0.44.1"
    implementation("org.jetbrains.exposed:exposed-core:$exposed")
    implementation("org.jetbrains.exposed:exposed-jdbc:$exposed")

    testImplementation("com.h2database:h2:2.2.224")
    testImplementation("org.xerial:sqlite-jdbc:3.43.2.2")
    testImplementation("mysql:mysql-connector-java:8.0.33")
    testImplementation("org.mariadb.jdbc:mariadb-java-client:3.2.0")
    testImplementation("org.postgresql:postgresql:42.6.0")

    val testcontainers = "1.19.1"
    testImplementation("org.testcontainers:postgresql:$testcontainers")
    testImplementation("org.testcontainers:oracle-xe:$testcontainers")
    testImplementation("org.testcontainers:mariadb:$testcontainers")
    testImplementation("org.testcontainers:mysql:$testcontainers")
    testImplementation("org.testcontainers:testcontainers:$testcontainers")
    testImplementation("org.testcontainers:junit-jupiter:$testcontainers")

    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5:1.8.0")
    testImplementation("org.junit.jupiter:junit-jupiter-api:5.10.0")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.0")

    val logback = "1.4.11"
    testImplementation("ch.qos.logback:logback-core:$logback")
    testImplementation("ch.qos.logback:logback-classic:$logback")
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    withJavadocJar()
    withSourcesJar()
}

tasks.withType<KotlinCompile> {
    kotlinOptions.jvmTarget = "1.8"
}

tasks.withType<Test> {
    testLogging {
        events(STARTED, PASSED, FAILED, SKIPPED)
        exceptionFormat = FULL
        showExceptions = true
        showCauses = true
        showStackTraces = true
    }
    useJUnitPlatform()
}

tasks.test {
    extensions.configure(JacocoTaskExtension::class) {
        setDestinationFile(file("$buildDir/jacoco/jacoco.exec"))
    }

    finalizedBy("jacocoTestReport")
}

tasks.jacocoTestReport {
    reports {
        html.required.set(false)
        csv.required.set(false)
        xml.required.set(true)
        xml.outputLocation.set(file("$buildDir/reports/jacoco/report.xml"))
    }

    onlyIf {
        true
    }

    finalizedBy("jacocoTestCoverageVerification")
}

tasks.jacocoTestCoverageVerification {
    violationRules {
        rule {
            limit {
                minimum = "0.10".toBigDecimal()
            }
        }
        rule {
            enabled = true
            element = "CLASS"
            limit {
                counter = "BRANCH"
                value = "COVEREDRATIO"
                minimum = "0.0".toBigDecimal()
            }
            limit {
                counter = "LINE"
                value = "COVEREDRATIO"
                minimum = "0.0".toBigDecimal()
            }
            excludes = listOf()
        }
    }
}

val testCoverage by tasks.registering {
    group = "verification"
    description = "Runs the unit tests with coverage"

    dependsOn(":test",
        ":jacocoTestReport",
        ":jacocoTestCoverageVerification")

    tasks["jacocoTestReport"].mustRunAfter(tasks["test"])
    tasks["jacocoTestCoverageVerification"].mustRunAfter(tasks["jacocoTestReport"])
}

fun getEnvOrProperty(env: String, property: String): String? =
    System.getenv(env) ?: findProperty(property)?.toString()