build.gradle

apply plugin: 'java-library'
apply plugin: 'idea'
apply plugin: 'signing'
apply plugin: 'jacoco'
apply plugin: 'maven-publish'
apply from: 'dependencies.gradle'

version='2.2.0-SNAPSHOT'
group='de.otto.edison'

project.ext.set("debugUpload", false)

repositories {
    mavenCentral()
}

dependencies {
    api libraries.jackson
    implementation libraries.uritemplates
    implementation libraries.loggingApi

    testImplementation libraries.test
    testImplementation libraries.loggingImpl
}

compileJava {
    options.encoding = 'UTF-8'
    options.compilerArgs << "-Xlint:all,-serial"
}

compileTestJava {
    options.encoding = 'UTF-8'
    options.compilerArgs << "-Xlint:all,-serial"
}

test {
    println()
    afterSuite { desc, result ->
        if (!desc.parent) { // will match the outermost suite
            println "Test Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
        }
    }
}

jacocoTestReport {
    reports {
        xml.required = true
    }
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    archiveClassifier = 'javadoc'
    from 'build/docs/javadoc'
}

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

artifacts {
    archives jar
    archives sourcesJar
    archives javadocJar
}

signing {
    sign configurations.archives
}

task askForVersionNumber {
    doLast {
        def console = System.console()
        def enteredVersion
        if (console) {
            version = trimSnapshot(version)
            enteredVersion = console.readLine('\n\u001B[92m\u001B[1mWhich version do you want to release?\u001B[0m \u001B[2m[' + version + ']\u001B[0m ')
            if (!enteredVersion.isEmpty()) {
                version = enteredVersion
            }
            bumpVersionInGradleFile(version)
        } else {
            logger.error "Cannot get console."
        }
    }
}

def bumpVersionInGradleFile(String theVersion) {
    def myFile = new File('build.gradle')
    def output = ""
    myFile.eachLine { line ->
        output += line.replaceAll('^version\\s*=\\s*.*$', "version='" + theVersion + "'")
        output += "\n"
    }
    def outFile = new File("build.gradle")
    outFile.write(output)
}

def incrementVersion(String theVersion) {
    def versionArray = theVersion.split("\\.")
    def major = versionArray[0].toInteger()
    def minor = versionArray[1].toInteger() + 1
    def patch = 0

    return major + "." + minor + "." + patch;
}

def trimSnapshot(String theVersion) {
    if (theVersion.endsWith("-SNAPSHOT")) {
        return theVersion.substring(0, theVersion.length()-9)
    } else {
        return theVersion;
    }
}


task commitNewVersion {
    doLast {
        println(["git", "add", "build.gradle"].execute().text.trim())
        println(["git", "commit", "-m", "bump version to " + version].execute().text.trim())
        bumpVersionInGradleFile(incrementVersion(version) + "-SNAPSHOT")
        println(["git", "add", "build.gradle"].execute().text.trim())
        println(["git", "commit", "-m", "bump version to next snapshot"].execute().text.trim())
    }
}

task doRelease {
    dependsOn askForVersionNumber, publish, commitNewVersion
}

doRelease {
    doLast {
    }
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifactId = 'edison-hal'
            from components.java
            artifact sourcesJar
            artifact javadocJar
            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }
            pom {
                name = 'edison-hal'
                description = 'A library to parse and render application/hal+json documents in Java.'
                url = 'https://github.com/otto-de/edison-hal'
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        id = 'gsteinacker'
                        name = 'Guido Steinacker'
                    }
                }
                scm {
                    connection = 'scm:git@github.com:otto-de/edison-hal.git'
                    developerConnection = 'scm:git@github.com:otto-de/edison-hal.git'
                    url = 'https://github.com/otto-de/edison-hal'
                }
            }
        }
    }
    repositories {
        maven {
            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
            if (project.debugUpload) {
                releasesRepoUrl = "$buildDir/repos/releases"
                snapshotsRepoUrl = "$buildDir/repos/snapshots"
            } else {
                credentials {
                    username = sonatypeUsername
                    password = sonatypePassword
                }
            }
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
        }
    }
}

signing {
    sign publishing.publications.mavenJava
}

commitNewVersion.shouldRunAfter publish

allprojects {
    tasks.withType(Test).configureEach {
        maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
        if (!project.hasProperty("createReports")) {
            reports.html.required = false
            reports.junitXml.required = false
        }
    }

    targetCompatibility = JavaVersion.VERSION_17
    sourceCompatibility = JavaVersion.VERSION_17
}

// This function converts 1.8 -> 8
static String compat(String src) {
    if (src.contains('.')) {
        src.substring(src.lastIndexOf('.')+1)
    } else {
        src
    }
}

project.afterEvaluate {
    tasks.withType(JavaCompile) {
        def version = compat(sourceCompatibility)
        project.logger.info("Configuring $name to use --release $version")
        println("Configuring $name to use --release $version")
        options.compilerArgs.addAll(['--release', version])
    }
}