build.gradle

import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
import net.ltgt.gradle.errorprone.CheckSeverity
import java.text.SimpleDateFormat

plugins {
    id 'java'
    id 'java-library'
    id 'jvm-test-suite'
    id 'maven-publish'
    id 'signing'
    id 'groovy'
    id 'biz.aQute.bnd.builder' version '6.2.0'
    id 'io.github.gradle-nexus.publish-plugin' version '2.0.0'
    id 'com.github.ben-manes.versions' version '0.53.0'
    id "me.champeau.jmh" version "0.7.3"
    id "net.ltgt.errorprone" version '4.3.0'

    // Kotlin just for tests - not production code
    id 'org.jetbrains.kotlin.jvm' version '2.2.20'
}

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

kotlin {
    compilerOptions {
        apiVersion = KotlinVersion.KOTLIN_2_0
        languageVersion = KotlinVersion.KOTLIN_2_0
        jvmTarget = JvmTarget.JVM_11
        javaParameters = true
        freeCompilerArgs = [
                '-Xemit-jvm-type-annotations',
                '-Xjspecify-annotations=strict',
        ]
    }
}

def getDevelopmentVersion() {
    def output = new StringBuilder()
    def error = new StringBuilder()
    def gitShortHash = ["git", "-C", projectDir.toString(), "rev-parse", "--short", "HEAD"].execute()
    gitShortHash.waitForProcessOutput(output, error)
    def gitHash = output.toString().trim()
    if (gitHash.isEmpty()) {
        println "git hash is empty: error: ${error.toString()}"
        throw new IllegalStateException("git hash could not be determined")
    }
    def version = "0.0.0-" + new SimpleDateFormat('yyyy-MM-dd\'T\'HH-mm-ss').format(new Date()) + "-" + gitHash
    println "created development version: $version"
    version
}

def releaseVersion = System.env.RELEASE_VERSION
version = releaseVersion ? releaseVersion : getDevelopmentVersion()
group = 'com.graphql-java'
description = 'A pure Java 11 port of Facebook Dataloader'

gradle.buildFinished { buildResult ->
    println "*******************************"
    println "*"
    if (buildResult.failure != null) {
        println "* FAILURE - ${buildResult.failure}"
    } else {
        println "* SUCCESS"
    }
    println "* Version: $version"
    println "*"
    println "*******************************"
}

repositories {
    mavenCentral()
    mavenLocal()
}

jar {
    manifest {
        attributes('Automatic-Module-Name': 'org.dataloader',
                '-exportcontents': 'org.dataloader.*',
                '-removeheaders': 'Private-Package')
    }
    bnd('''
Import-Package: org.jspecify.annotations;resolution:=optional,*
''')
}

dependencies {
    api "org.reactivestreams:reactive-streams:$reactive_streams_version"
    api "org.jspecify:jspecify:1.0.0"

    // this is needed for the idea jmh plugin to work correctly
    jmh 'org.openjdk.jmh:jmh-core:1.37'
    jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'

    errorprone 'com.uber.nullaway:nullaway:0.12.10'
    errorprone 'com.google.errorprone:error_prone_core:2.42.0'

    // just tests
    testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
}

tasks.withType(JavaCompile) {
    options.release = 11
    options.errorprone {
        disableAllChecks = true
        check("NullAway", CheckSeverity.ERROR)
        //
        // end state has us with this config turned on - eg all classes
        //
        //option("NullAway:AnnotatedPackages", "org.dataloader")
        option("NullAway:OnlyNullMarked", "true")
        option("NullAway:JSpecifyMode", "true")
    }
    // Include to disable NullAway on test code
    if (name.toLowerCase().contains("test")) {
        options.errorprone {
            disable("NullAway")
        }
    }
}


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

javadoc {
    options.encoding = 'UTF-8'
}

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

artifacts {
    archives sourcesJar
    archives javadocJar
}

testing {
    suites {
        test {
            useJUnitJupiter(junit_version)
            dependencies {
                // Testing dependencies
                implementation platform("org.junit:junit-bom:$junit_version")
                implementation 'org.junit.jupiter:junit-jupiter-api'
                implementation 'org.junit.jupiter:junit-jupiter-params'
                implementation 'org.junit.jupiter:junit-jupiter-engine'
                implementation "org.awaitility:awaitility:$awaitility_version"
                implementation "org.hamcrest:hamcrest:$hamcrest_version"
                implementation "io.projectreactor:reactor-core:$reactor_core_version"
                implementation "com.github.ben-manes.caffeine:caffeine:$caffeine_version"
            }

            targets.configureEach {
                testTask.configure {
                    testLogging {
                        exceptionFormat = 'full'
                    }
                }
            }
        }
    }
}

publishing {
    publications {
        graphqlJava(MavenPublication) {
            from components.java
            groupId 'com.graphql-java'
            artifactId 'java-dataloader'
            version project.version

            artifact sourcesJar
            artifact javadocJar

            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST
                    name 'java-dataloader'
                    description 'A pure Java 11 port of Facebook Dataloader'
                    url 'https://github.com/graphql-java/java-dataloader'
                    inceptionYear '2017'

                    scm {
                        url 'https://github.com/graphql-java/java-dataloader'
                        connection 'scm:git@github.com:graphql-java/java-dataloader.git'
                        developerConnection 'scm:git@github.com:graphql-java/java-dataloader.git'
                    }

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

                    developers {
                        developer {
                            id 'bbakerman'
                            name 'Brad Baker'
                            email 'bbakerman@gmail.com'
                        }
                        developer {
                            id 'aschrijver'
                            name 'Arnold Schrijver'
                        }
                    }
                }
            }
        }
    }
}

nexusPublishing {
    repositories {
        sonatype {
            username = System.env.MAVEN_CENTRAL_USER_NEW
            password = System.env.MAVEN_CENTRAL_PASSWORD_NEW
            // https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#configuration
            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
            // GraphQL Java does not publish snapshots, but adding this URL for completeness
            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))        }
    }
}

signing {
    required { !project.hasProperty('publishToMavenLocal') }
    def signingKey = System.env.MAVEN_CENTRAL_PGP_KEY
    useInMemoryPgpKeys(signingKey, "")
    sign publishing.publications
}


// all publish tasks depend on the build task
tasks.withType(PublishToMavenRepository) {
    dependsOn build
}

def isNonStable = { String version ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) }
    def regex = /^[0-9,.v-]+(-r)?$/
    return !stableKeyword && !(version ==~ regex)
}

// https://github.com/ben-manes/gradle-versions-plugin
tasks.named("dependencyUpdates").configure {
    rejectVersionIf {
        isNonStable(it.candidate.version)
    }
}