build.gradle.kts

import org.jreleaser.model.Active

plugins {
    id("java-library")
    id("checkstyle")
    id("maven-publish")
    alias(libs.plugins.jreleaser)
}

group = "org.komamitsu"
version = "3.0.0"
description = "Jackson 3.x extension that adds support for MessagePack"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
    withJavadocJar()
    withSourcesJar()
}

repositories {
    mavenCentral()
}

dependencies {
    api(libs.jackson.databind)
    testImplementation(libs.msgpack.core)

    testImplementation(libs.junit.jupiter)
    testImplementation(libs.hamcrest)
    testImplementation(libs.commons.math3)
    testRuntimeOnly(libs.junit.platform.launcher)
}

// PackageVersion.java carries the coordinates and version Jackson reports via Versioned.
// Generate it from the Gradle project so it cannot drift from the published POM.
val packageDir = "org/komamitsu/jackson/dataformat/msgpack"
val generatePackageVersion = tasks.register("generatePackageVersion") {
    val outputDir = layout.buildDirectory.dir("generated/sources/packageVersion/java/main")
    val projectVersion = project.version.toString()
    val projectGroup = project.group.toString()
    val projectName = project.name
    inputs.property("version", projectVersion)
    outputs.dir(outputDir)
    doLast {
        val (major, minor, patch, snapshot) = Regex("""(\d+)\.(\d+)\.(\d+)(?:-(.+))?""")
            .matchEntire(projectVersion)!!.destructured
        val snapshotInfo = if (snapshot.isEmpty()) "null" else "\"$snapshot\""
        val file = outputDir.get().file("$packageDir/PackageVersion.java").asFile
        file.parentFile.mkdirs()
        file.writeText(
            """
            |package ${packageDir.replace('/', '.')};
            |
            |import tools.jackson.core.Version;
            |import tools.jackson.core.Versioned;
            |
            |// Generated by the Gradle build from the project version. Do not edit.
            |public class PackageVersion
            |        implements Versioned
            |{
            |    public static final Version VERSION = new Version($major, $minor, $patch, $snapshotInfo, "$projectGroup", "$projectName");
            |
            |    @Override
            |    public Version version()
            |    {
            |        return VERSION;
            |    }
            |}
            |""".trimMargin()
        )
    }
}

sourceSets.main {
    java.srcDir(generatePackageVersion)
}

tasks.withType<JavaCompile>().configureEach {
    options.encoding = "UTF-8"
    options.compilerArgs.addAll(listOf("-Xlint:unchecked", "-Xlint:deprecation"))
}

tasks.withType<Javadoc>().configureEach {
    (options as StandardJavadocDocletOptions).addBooleanOption("Xdoclint:none", true)
}

// Compilation is pinned to 17 above; tests can run on a newer JDK with -PtestJavaVersion=21.
val testJavaVersion = providers.gradleProperty("testJavaVersion").map(JavaLanguageVersion::of)

tasks.test {
    useJUnitPlatform {
        excludeTags("soak")
    }
    // A non-UTF-8 default charset, so that any conversion that forgets to name a charset
    // corrupts non-ASCII text in the tests instead of only on users' Windows machines.
    jvmArgs("-ea", "-Dfile.encoding=windows-1252")
    if (testJavaVersion.isPresent) {
        javaLauncher = javaToolchains.launcherFor { languageVersion = testJavaVersion }
    }
    testLogging {
        events("failed")
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
    }
}

// Long-running checks that the normal build skips. ./gradlew soakTest -Psoak.seconds=120
tasks.register<Test>("soakTest") {
    group = "verification"
    description = "Runs the soak tests (memory growth under sustained load)."
    testClassesDirs = sourceSets["test"].output.classesDirs
    classpath = sourceSets["test"].runtimeClasspath
    useJUnitPlatform {
        includeTags("soak")
    }
    val soakSeconds = providers.gradleProperty("soak.seconds").orElse("30")
    jvmArgs("-ea", "-Xmx256m", "-Dsoak.seconds=${soakSeconds.get()}")
    if (testJavaVersion.isPresent) {
        javaLauncher = javaToolchains.launcherFor { languageVersion = testJavaVersion }
    }
    testLogging {
        events("passed", "failed")
        showStandardStreams = true
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
    }
    outputs.upToDateWhen { false }
}

checkstyle {
    toolVersion = "10.21.1"
    configFile = file("config/checkstyle/checkstyle.xml")
    maxWarnings = 0
}

// Publications are staged locally; JReleaser signs them and uploads them to the Central Portal.
val stagingDir = layout.buildDirectory.dir("staging-deploy")

publishing {
    publications {
        create<MavenPublication>("maven") {
            from(components["java"])

            pom {
                name = project.name
                description = project.description
                url = "https://github.com/komamitsu/jackson-dataformat-msgpack"
                licenses {
                    license {
                        name = "Apache-2.0"
                        url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
                    }
                }
                developers {
                    developer {
                        id = "komamitsu"
                        name = "Mitsunori Komatsu"
                        email = "komamitsu@gmail.com"
                        url = "https://github.com/komamitsu"
                    }
                }
                scm {
                    url = "https://github.com/komamitsu/jackson-dataformat-msgpack"
                    connection = "scm:git:git://github.com/komamitsu/jackson-dataformat-msgpack.git"
                    developerConnection = "scm:git:ssh://git@github.com/komamitsu/jackson-dataformat-msgpack.git"
                }
            }
        }
    }
    repositories {
        maven {
            name = "staging"
            url = uri(stagingDir)
        }
    }
}

jreleaser {
    signing {
        pgp {
            active = Active.ALWAYS
            armored = true
        }
    }
    deploy {
        maven {
            mavenCentral.create("sonatype") {
                active = Active.ALWAYS
                url = "https://central.sonatype.com/api/v1/publisher"
                applyMavenCentralRules = true
                stagingRepository(stagingDir.get().asFile.path)
            }
        }
    }
}