build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'ca.cutterslade.gradle:gradle-dependency-analyze:1.1.0'
    }
}

plugins {
    id "signing"
    id "io.github.gradle-nexus.publish-plugin" version "1.0.0"
}

apply plugin: 'java-library'
apply plugin: 'idea'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'io.github.gradle-nexus.publish-plugin'

ext.isPropertySet = { propName ->
    if (!project.hasProperty(propName)) {
        return false
    } else {
        def prop = project.getProperty(propName)
        return (prop != "unspecified" && (prop != "" || prop != null))
    }
}

ext.ensurePropertyIsSet = { propName -> 
    if (!isPropertySet(propName)) {
        throw new GradleException(
            "Expecting project property [${propName}] or env var [ORG_GRADLE_PROJECT_${propName}] to be set.")
    }
}

//if the project has a value for the passed property (i.e from the cmd line via -PpropName=xxx)
//use that, else use a default value
ext.getPropertyOrDefault = { propName, defaultValue ->
    def val;
    if (isPropertySet(propName)) {
        val = project.getProperty(propName)
        println "Getting property [$propName] with value [$val]"
    } else {
        val = defaultValue
        println "Property [$propName] has no value, using default value [$val]"
    }
    return val;
}

ext.versions = [
    stroomExpression: getPropertyOrDefault('version', 'SNAPSHOT').replaceFirst(/^v/, "")
]

ext.isReleaseBuild = !versions.stroomExpression.endsWith('SNAPSHOT')

ext.moduleName = 'stroom.expression'

if (isReleaseBuild) {
    println "This is a release build for maven version [${versions.stroomExpression}]"
    // Ensure the various props are set for signing and publishing to sonatype

    // The username for Sonatype OSSRH Jira account
    ensurePropertyIsSet("sonatypeUsername")
    // The password for Sonatype OSSRH Jira account
    ensurePropertyIsSet("sonatypePassword")
    // The GPG2 secret key in ascii armour format, base64 encoded
    ensurePropertyIsSet("signingKey")
    // The password for the GPG2 secret key
    ensurePropertyIsSet("signingPassword")
}

group = 'uk.gov.gchq.stroom.expression'
version = versions.stroomExpression

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    implementation 'org.slf4j:slf4j-api:1.7.25'

    testCompileOnly "org.junit.jupiter:junit-jupiter-api:5.3.2"
    testImplementation "org.assertj:assertj-core:3.10.0"
    testImplementation "com.caucho:hessian:4.0.51"

    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.3.2"
    testRuntimeOnly "org.slf4j:slf4j-nop:1.7.25"
}

String base64DecodeProjectProperty(String propName) {
    def encodedVal = project.findProperty(propName)
    return encodedVal == null
        ? null
        : new String(Base64.getDecoder().decode(encodedVal.toString())).trim()
}

void configureSigning(Project project) {

    // To create the GPG key do:
    //   gpg2 --gen-key 
    // To list it
    //   gpg2 --list-keys
    // To publish the public key on a keyserver
    //   gpg2 --keyserver hkp://keyserver.ubuntu.com --send-keys <your short key id>
    // To get the ascii-armour private key for use in travis env vars as base64 encoded
    //   gpg2 --armor --export-secret-keys <your short key id> | base64 -w0

    //project.signing.gnupg.keyName = project.findProperty("signingKeyId")

    project.signing {
        println "Configuring project to sign maven artifacts"
        required { project.gradle.taskGraph.hasTask("required") }
        def signingKeyId = project.findProperty("signingKeyId")
        def signingKey = base64DecodeProjectProperty("signingKey")
        def signingPassword = project.findProperty("signingPassword")

        //println "pword: [$signingPassword]"
        //println "key: [$signingKey]"
        //println "keyId: [$signingKeyId]"

        if (signingKeyId) {
            println "Using in memory pgp key with ID"
            useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
        } else if (signingKey) {
            println "Using in memory pgp key without ID"
            useInMemoryPgpKeys(signingKey, signingPassword)
        }
        //useGpgCmd()
        sign project.publishing.publications.mavenJava
    }
}

//for java plugin
//see https://docs.gradle.org/current/userguide/java_plugin.html
java {
    //package JavaDoc as part of publication
    withJavadocJar()
    //package Sources as part of publication
    withSourcesJar()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java

            pom {
                name = project['name']
                description = "Library of functions as used in Stroom dashboards"
                url = 'https://github.com/gchq/stroom-expression'
                licenses {
                    license {
                        name = 'The Apache License, Version 2.0'
                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    }
                }
                developers {
                    developer {
                        name = 'GCHQDevelopers'
                        organization = 'GCQH'
                        organizationUrl = 'https://github.com/gchq'
                    }
                }
                scm {
                    connection = 'scm:git:git@github.com:gchq/stroom-expression.git'
                    developerConnection = 'scm:git:git@github.com:gchq/stroom-expression.git'
                    url = 'https://github.com/gchq/stroom-expression'
                }
            }         
        }
    }
}

def hasSigningKey = project.hasProperty("signingkeyId") || project.findProperty("signingKey")
if(hasSigningKey) {
    configureSigning(project)
}

// See https://github.com/rwinch/gradle-publish-ossrh-sample
// Also https://github.com/kit-data-manager/nexus-publish-example
nexusPublishing {
    repositories {
        // Uses sonotypeUsername and sonotypePassword via ORG_GRADLE_PROJECT_sonatypeUsername
        // and ORG_GRADLE_PROJECT_sonatypePassword
        sonatype()
    }
    // these are not strictly required. The default timeouts are set to 1 minute. But Sonatype can be really slow.
    // If you get the error "java.net.SocketTimeoutException: timeout", these lines will help.
    connectTimeout = Duration.ofMinutes(3)
    clientTimeout = Duration.ofMinutes(3)
}

afterEvaluate {
    repositories {
        mavenCentral()
    }

//    compileJava {
//        inputs.property("moduleName", moduleName)
//        doFirst {
//            options.compilerArgs = [
//                    '--module-path', classpath.asPath,
//            ]
//            classpath = files()
//        }
//    }
//
//    compileTestJava {
//        inputs.property("moduleName", moduleName)
//        doFirst {
//            options.compilerArgs = [
//                    '--module-path', classpath.asPath,
//                    '--patch-module', "$moduleName=" + files(sourceSets.test.java.srcDirs).asPath,
//            ]
//            classpath = files()
//        }
//    }
//
//    test {
//        useJUnitPlatform()
//
//        inputs.property("moduleName", moduleName)
//        doFirst {
//            jvmArgs = [
//                    '--module-path', classpath.asPath,
//                    '--add-modules', 'ALL-MODULE-PATH',
//                    '--patch-module', "$moduleName=" + files(sourceSets.test.java.outputDir).asPath,
////                    '--add-opens', 'java.base/java.net=ALL-UNNAMED', // add the following VM parameters to the run configuration to avoid problems with the reflection restrictions in Java 9
////                    '--add-opens', 'stroom.expression/stroom.dashboard.expression.v1=org.junit.platform.commons',
//            ]
//            classpath = files()
//        }
//    }
//
//    javadoc {
//        options.addStringOption('-module-path', classpath.asPath)
//        options.addStringOption('Xdoclint:all,-missing', '-html5')
//    }

    jar {
        inputs.property("moduleName", moduleName)
        manifest {
            attributes(
                    "Automatic-Module-Name": moduleName,
            )
        }
    }
}