build.gradle

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

plugins {
    id "me.champeau.jmh" version "0.6.6" apply false
    id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
    id 'io.freefair.lombok' version '8.2.2' apply false
}

subprojects {
    // We can't use plugins {} syntax in subprojects as of Gradle 6.x
    apply plugin: 'idea'
    apply plugin: 'java-library'
    apply plugin: 'java-test-fixtures'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    // !!!Do not reverse order of these two plugins (jmh and shadow) loading!!!
    // jmh plugin changes its behavior by whether the shadow plugin is loaded or not, and with shadow plugin
    // it does not work well by failing to generate an jmh JAR to be executed.
    // https://github.com/melix/jmh-gradle-plugin/blob/c17c89c8fed6d655678aac16ecd5b683ea7fc8b5/src/main/groovy/me/champeau/jmh/JMHPlugin.groovy#L77
    apply plugin: 'me.champeau.jmh'
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: 'io.freefair.lombok'

    group = "com.linecorp.decaton"
    version = "${version}" + (snapshot.toBoolean() ? "-SNAPSHOT" : "")

    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    repositories {
        mavenCentral()
    }

    ext {
        // Freezing this to 1.X until https://github.com/spring-projects/spring-boot/issues/12649 is resolved
        slf4jVersion = "1.7.36"
        protobufVersion = "3.22.3"
        kafkaVersion = "3.2.3"
        micrometerVersion = "1.12.4"
        micrometerTracingVersion = "1.2.4"
        lombokVersion = "1.18.30"
        junitVersion = "5.10.0"
        hamcrestVersion = "2.2"

        isReleaseVersion = !version.endsWith('-SNAPSHOT')

        shadeAllDependencies = false // Whether this project should results uber jar or not
        noPublish = false // Whether to publish this artifact to maven or not
        publishOnlyLocal = false // Whether to publish this artifact to local maven only (no effect if noPublish = true)
        relocatePb = true // Whether to relocate package name of protocol buffers classes
    }

    // need override because gradle-lombok plugin brings outdated lombok version
    lombok {
        version = "$lombokVersion"
    }

    gradle.projectsEvaluated {
        tasks.withType(JavaCompile) {
            options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
        }
    }

    configurations {
        shade
        api.extendsFrom(shade)
        itImplementation.extendsFrom(implementation)
    }

    dependencies {
        compileOnly "org.projectlombok:lombok:$lombokVersion"
        annotationProcessor "org.projectlombok:lombok:$lombokVersion"

        // Likely be used for most modules
        testImplementation "org.junit.jupiter:junit-jupiter:$junitVersion"
        testImplementation "org.mockito:mockito-core:4.11.0"
        testImplementation "org.mockito:mockito-junit-jupiter:4.11.0"
        itImplementation "org.junit.jupiter:junit-jupiter:$junitVersion"
    }

    sourceSets.create('it') {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        compileClasspath += sourceSets.testFixtures.output
        runtimeClasspath += sourceSets.testFixtures.output
    }

    task integrationTest(type: Test) {
        testClassesDirs = sourceSets.it.output.classesDirs
        classpath = sourceSets.it.runtimeClasspath
    }

    tasks.withType(Test) {
        useJUnitPlatform()
        testLogging {
            // set options for log level LIFECYCLE
            events TestLogEvent.FAILED,
                    TestLogEvent.PASSED,
                    TestLogEvent.SKIPPED,
                    TestLogEvent.STANDARD_OUT
            exceptionFormat TestExceptionFormat.FULL
            showExceptions true
            showCauses true
            showStackTraces true
            showStandardStreams false
        }
        def testJavaVersion = findProperty("test.java.major.version")
        if (testJavaVersion != null) {
            // https://docs.gradle.org/8.5/userguide/toolchains.html#toolchains_for_tasks
            javaLauncher = javaToolchains.launcherFor {
                languageVersion = JavaLanguageVersion.of(testJavaVersion)
            }
        }
    }

    afterEvaluate {
        if (!noPublish) {
            publishing {
                repositories {
                    maven {
                        if (isReleaseVersion) {
                            url("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
                        } else {
                            url("https://oss.sonatype.org/content/repositories/snapshots/")
                        }
                        credentials {
                            username findProperty("sonatypeUsername")
                            password findProperty("sonatypePassword")
                        }
                    }
                }
                publications {
                    mavenJava(MavenPublication) {
                        artifactId = rootProject.name + '-' + project.name

                        // Create a custom publication that ships shadow jar (along with few other jars) with
                        // maven pom which properly declares necessary dependencies.
                        // We can't simply do `from components.java`.
                        // The java component contains non-shaded jar, so its jar doesn't contain relocated
                        // protobuf-java.
                        // We can't modify `artifacts` of java component either because it is prevented by
                        // gradle: https://github.com/gradle/gradle/blob/8d6c7361264fdfbe75feb113501758c0deeca5f4/subprojects/maven/src/main/java/org/gradle/api/publish/maven/internal/publication/DefaultMavenPublication.java#L815
                        // The shadow plugin provides `shadow` configuration, but all these dependencies are
                        // mapped to "runtime" scope so just `components.shadow` doesn't work either.
                        // Apparently there's no API for obtaining dependency list from one component and
                        // bring it to another component, so customizing maven pom directly is the only option.
                        artifacts = [artifact(source: shadowJar, classifier: null),
                                     artifact(source: sourcesJar),
                                     artifact(source: javadocJar)]
                        afterEvaluate {
                            pom.withXml {
                                def rootNode = asNode()
                                def depListNode = null
                                if (rootNode.dependencies) {
                                    depListNode = rootNode.dependencies.get(0)
                                } else {
                                    depListNode = new Node(rootNode, 'dependencies')
                                }

                                if (!shadeAllDependencies) {
                                    def excludeDeps = new HashSet<>(project.configurations.shade.allDependencies)
                                    for (config in [["api", "compile"], ["implementation", "runtime"]]) {
                                        project.configurations.getByName(config[0]).allDependencies.each { dep ->
                                            if (!excludeDeps.add(dep)) {
                                                return;
                                            }
                                            def depNode = new Node(depListNode, 'dependency')
                                            depNode.appendNode('groupId', dep.group)
                                            def prefix = dep.group == 'com.linecorp.decaton' && !dep.name.startsWith('decaton-') ? 'decaton-' : ''
                                            depNode.appendNode('artifactId', prefix + dep.name)
                                            depNode.appendNode('version', dep.version)
                                            depNode.appendNode('scope', config[1])
                                        }
                                    }
                                }
                            }
                        }
                        pom {
                            name = 'Decaton'
                            description = 'High throughput asynchronous task processing on Apache Kafka'
                            url = 'https://github.com/line/decaton'

                            scm {
                                url = 'git@github.com:line/decaton.git'
                                connection = 'scm:git:git@github.com:line/decaton.git'
                                developerConnection = 'scm:git:git@github.com:line/decaton.git'
                            }

                            licenses {
                                license {
                                    name = 'The Apache License, Version 2.0'
                                    url = 'https://www.apache.org/licenses/LICENSE-2.0'
                                }
                            }

                            developers {
                                developer {
                                    name = 'Decaton developers'
                                    email = 'dl_oss_dev@linecorp.com'
                                }
                            }
                        }
                    }
                }
            }
            signing {
                required { isReleaseVersion && gradle.taskGraph.hasTask("publish") }
                sign publishing.publications.mavenJava
            }
        }
    }

    shadowJar {
        archiveClassifier.set('shadow')
        afterEvaluate {
            if (!shadeAllDependencies) {
                // Shade only dependencies which are declared to be shaded explicitly.
                // By this line, all dependencies declared with `api` or `implementation` will be added as
                // external dependencies and their classes aren't be merged into resulting shadow jar.
                configurations = [project.configurations.shade]
            }
            if (relocatePb) {
                // Relocate protobuf package prefixing unique identifier `com.linecorp.decaton`
                relocate "com.google.protobuf.", "com.linecorp.decaton.com.google.protobuf."
            }
        }
    }

    tasks.withType(PublishToMavenRepository) {
        onlyIf {
            !publishOnlyLocal
        }
    }

    task sourcesJar(type: Jar, dependsOn: classes) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
    }

    javadoc {
        source = delombok
        options.encoding = 'UTF-8'
        options.locale = 'en_US'
    }

    task javadocJar(type: Jar) {
        archiveClassifier.set('javadoc')
        from javadoc
    }
    build.dependsOn(javadoc)
}