build.gradle

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

repositories {
    mavenCentral()
}

group = "org.embulk"
version = "0.5.1-SNAPSHOT"
description = "Embulk configuration processor for Embulk plugins"

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

    legacyTestImplementation {
        extendsFrom testImplementation
    }
}

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

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

    withJavadocJar()
    withSourcesJar()
}

sourceSets {
    legacyTest {
        java {
            srcDir "src/legacyTest/java"
        }
        resources {
            srcDir "src/legacyTest/resources"
        }
        compileClasspath += main.output
        runtimeClasspath += main.output
    }
}

dependencies {
    compileOnly libs.embulk.spi
    compileOnly libs.slf4j

    // Dependencies should be "api" so that their scope would be "compile" in "pom.xml".
    api libs.validation

    api platform(libs.jackson.bom)
    api libs.bundles.jackson

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

    testImplementation libs.embulk.spi

    testImplementation libs.bval
    testImplementation libs.joda
    testImplementation libs.logback

    testImplementation platform(testLibs.jackson.bom)
    testImplementation testLibs.bundles.jackson

    legacyTestImplementation libs.junit4

    legacyTestImplementation libs.embulk.core
    legacyTestImplementation libs.embulk.deps
    legacyTestImplementation libs.embulk.junit4
    legacyTestImplementation libs.logback

    legacyTestImplementation platform(testLibs.jackson.bom)
    legacyTestImplementation testLibs.bundles.jackson
}

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

    // "*NodeRebuilder" classes are unofficial and undocumented while ObjectNodeRebuilder is "public".
    exclude "org/embulk/util/config/rebuild/*.java"

    // "DataSourceImpl" is unofficial and undocumented while it is "public".
    exclude "org/embulk/util/config/DataSourceImpl.java"

    options {
        locale = "en_US"
        encoding = "UTF-8"
        links "https://docs.oracle.com/javase/8/docs/api/"
        links "https://docs.oracle.com/javaee/7/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/com.fasterxml.jackson.core/jackson-databind/${libs.versions.jackson.get()}/"
        links "https://javadoc.io/doc/com.fasterxml.jackson.datatype/jackson-datatype-jdk8/${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 = "Dai MIKURUBE"
                        email = "dmikurube@acm.org"
                    }
                }

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

                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 }
    }
    systemProperty "org.embulk.embulk_util_config.version", "${project.version}"
}

task legacyTest(type: Test, description: "Tests compatible with legacy Embulk DataSource.", group: "Verification") {
    classpath = sourceSets.legacyTest.runtimeClasspath
    testClassesDirs = sourceSets.legacyTest.output.classesDirs

    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 }
    }
}

check {
    dependsOn "legacyTest"
}

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

checkstyle {
    toolVersion "9.3"
    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  // https://github.com/gradle/gradle/issues/881
}