build.gradle

plugins {
    id "java"
    id "java-library"
    id "maven-publish"
    id "signing"
    id "checkstyle"
}

repositories {
    mavenCentral()
}

group = "org.embulk"
version = "0.5.0-SNAPSHOT"
description = "Embulk JSON processor for Embulk plugins"

configurations {
    compileClasspath.resolutionStrategy.activateDependencyLocking()
    runtimeClasspath.resolutionStrategy.activateDependencyLocking()
}

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

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(8)
    }

    withJavadocJar()
    withSourcesJar()
}

dependencies {
    compileOnly libs.embulk.spi
    compileOnly libs.msgpack

    // Dependencies should be "api" so that their scope would be "compile" in "pom.xml".
    api platform(libs.jackson.bom)
    api libs.jackson.core

    testImplementation libs.embulk.spi
    testImplementation libs.msgpack

    testImplementation platform(libs.junit5.bom)
    testImplementation libs.bundles.junit5.implementation
    testRuntimeOnly libs.bundles.junit5.runtime

    testImplementation platform(testLibs.jackson.bom)
    testImplementation testLibs.jackson.core
}

javadoc {
    title = "${project.name} v${project.version}"

    options {
        locale = "en_US"
        encoding = "UTF-8"
        links "https://docs.oracle.com/javase/8/docs/api/"
        links "https://dev.embulk.org/embulk-spi/${libs.versions.embulk.spi.get()}/javadoc/"
        links "https://javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/${libs.versions.jackson.get()}/"
        links "https://javadoc.io/doc/org.msgpack/msgpack-core/${libs.versions.jackson.get()}/"
    }
}

jar {
    metaInf {
        from rootProject.file("LICENSE")
    }
}

sourcesJar {
    metaInf {
        from rootProject.file("LICENSE")
    }
}

javadocJar {
    metaInf {
        from rootProject.file("LICENSE")
    }
}

// A safer and strict alternative to: "dependencies" (and "dependencies --write-locks")
//
// This task fails explicitly when the specified dependency is not available.
// In contrast, "dependencies (--write-locks)" does not fail even when a part the dependencies are unavailable.
//
// https://docs.gradle.org/7.6.1/userguide/dependency_locking.html#generating_and_updating_dependency_locks
task checkDependencies {
    notCompatibleWithConfigurationCache("The task \"checkDependencies\" filters configurations at execution time.")
    doLast {
        configurations.findAll { it.canBeResolved }.each { it.resolve() }
    }
}

// It should not publish a `.module` file in Maven Central.
// https://docs.gradle.org/current/userguide/publishing_gradle_module_metadata.html#sub:disabling-gmm-publication
tasks.withType(GenerateModuleMetadata) {
    enabled = false
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = project.group
            artifactId = project.name

            from components.java
            // javadocJar and sourcesJar are added by java.withJavadocJar() and java.withSourcesJar() above.
            // See: https://docs.gradle.org/current/javadoc/org/gradle/api/plugins/JavaPluginExtension.html

            pom {  // https://central.sonatype.org/pages/requirements.html
                packaging "jar"

                name = project.name
                description = project.description
                url = "https://www.embulk.org/"

                licenses {
                    license {
                        // http://central.sonatype.org/pages/requirements.html#license-information
                        name = "The Apache License, Version 2.0"
                        url = "https://www.apache.org/licenses/LICENSE-2.0.txt"
                        distribution = "repo"
                    }
                }

                developers {
                    developer {
                        name = "Sadayuki Furuhashi"
                        email = "frsyuki@gmail.com"
                    }
                    developer {
                        name = "Muga Nishizawa"
                        email = "muga.nishizawa@gmail.com"
                    }
                    developer {
                        name = "Dai MIKURUBE"
                        email = "dmikurube@acm.org"
                    }
                    developer {
                        name = "Shinichi Ishimura"
                        email = "shiketaudonko41@gmail.com"
                    }
                }

                scm {
                    connection = "scm:git:git://github.com/embulk/embulk-util-json.git"
                    developerConnection = "scm:git:git@github.com:embulk/embulk-util-json.git"
                    url = "https://github.com/embulk/embulk-util-json"
                }

                withXml {
                    project.configurations.compileOnly.allDependencies.each { dependency ->
                        asNode().dependencies[0].appendNode("dependency").with {
                            it.appendNode("groupId", dependency.group)
                            it.appendNode("artifactId", dependency.name)
                            it.appendNode("version", dependency.version)
                            it.appendNode("scope", "provided")
                        }
                    }
                }
            }
        }
    }

    repositories {
        maven {  // publishMavenPublicationToMavenCentralRepository
            name = "mavenCentral"
            if (project.version.endsWith("-SNAPSHOT")) {
                url "https://oss.sonatype.org/content/repositories/snapshots"
            } else {
                url "https://oss.sonatype.org/service/local/staging/deploy/maven2"
            }

            credentials {
                username = project.hasProperty("ossrhUsername") ? ossrhUsername : ""
                password = project.hasProperty("ossrhPassword") ? ossrhPassword : ""
            }
        }
    }
}

signing {
    if (project.hasProperty("signingKey") && project.hasProperty("signingPassword")) {
        logger.lifecycle("Signing with an in-memory key.")
        useInMemoryPgpKeys(signingKey, signingPassword)
    }
    sign publishing.publications.maven
}

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "skipped", "failed", "standardOut", "standardError"
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
        showCauses = true
        showExceptions = true
        showStackTraces = true
        showStandardStreams = true
        outputs.upToDateWhen { false }
    }
}

tasks.withType(Checkstyle) {
    reports {
        // Not to skip up-to-date checkstyles.
        outputs.upToDateWhen { false }
    }
}

checkstyle {
    toolVersion = libs.versions.checkstyle.get()
    configFile = file("${rootProject.projectDir}/config/checkstyle/checkstyle.xml")
    configProperties = [
        "org.checkstyle.google.suppressionfilter.config": file("${rootProject.projectDir}/config/checkstyle/checkstyle-suppressions.xml"),
    ]
    ignoreFailures = false
    maxWarnings = 0
}