build.gradle

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }
}

plugins {
    id "org.sonarqube" version "3.4.0.2513"
    id 'com.github.kt3k.coveralls' version '2.12.0'
    id 'groovy'
    id 'jacoco'
    id 'maven-publish'
    id 'signing'
}

if(JavaVersion.current() != JavaVersion.VERSION_17 && JavaVersion.current() != JavaVersion.VERSION_21) {
    throw new GradleException("This project requires Java 17 or Java 21, but it's running on "+JavaVersion.current())
}

/*
   Groovy 2.4.21 supports bytecode Java 1.8 and lower.  Do not use higher
   bytecode values else it will default to Java 1.5.  Jenkins would need to
   upgrade core version of Groovy before higher bytecode versions are
   available.

   https://github.com/groovy/GMavenPlus/issues/256
*/
compileJava {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

compileGroovy {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

group = 'net.gleske'
archivesBaseName = 'jervis'
version = "${version}"

ext.groovyVersion = System.getenv('GROOVY_VERSION')?: '2.4.21'
ext.ossrhUsername = hasProperty('ossrhUsername')?project['ossrhUsername']:''
ext.ossrhPassword = hasProperty('ossrhPassword')?project['ossrhPassword']:''
ext.snakeYamlVersion = '2.2'
ext.bouncyCastleVersion = '1.75'
ext.codeNarcVersion = '3.2.0'

//if(JavaVersion.current() == JavaVersion.VERSION_17 && Integer.parseInt(ext.groovyVersion.tokenize('.').first()) < 3) {
//    throw new GradleException("When using Java 17 you must use Groovy 3 or higher.  Found Groovy " + ext.groovyVersion)
//}

if(Integer.parseInt(ext.groovyVersion.tokenize('.').first()) > 3) {
    // Groovy 4 and higher
    ext.groovyPackage = 'org.apache.groovy'
} else {
    ext.groovyPackage = 'org.codehaus.groovy'
}

apply from: 'file:gradle/groovydoc.gradle'
apply from: 'file:gradle/jervis.gradle'

println "Using Groovy ${groovyVersion}"
println "Using Java ${org.gradle.internal.jvm.Jvm.current()}"
println "Building ${archivesBaseName}-${version}"

repositories {
    mavenCentral()
}

// Address security vulnerability identified by DependencyTrack located as a
// transitive dependency within groovy-ant.
/*configurations.all {
    resolutionStrategy {
        dependencySubstitution {
            substitute module('org.apache.ant:ant:1.9.15') with module('org.apache.ant:ant:1.9.16')
            substitute module('org.apache.ant:ant-antlr:1.9.15') with module('org.apache.ant:ant-antlr:1.9.16')
            substitute module('org.apache.ant:ant-junit:1.9.15') with module('org.apache.ant:ant-junit:1.9.16')
        }
    }
}*/

dependencies {
    //implementation "${groovyPackage}:groovy-all:${groovyVersion}"
    implementation "${groovyPackage}:groovy-ant:${groovyVersion}"
    implementation "${groovyPackage}:groovy-groovydoc:${groovyVersion}"
    implementation "${groovyPackage}:groovy-json:${groovyVersion}"
    implementation "${groovyPackage}:groovy-templates:${groovyVersion}"
    implementation "${groovyPackage}:groovy:${groovyVersion}"
    implementation "org.bouncycastle:bcpkix-jdk18on:${bouncyCastleVersion}"
    implementation "org.yaml:snakeyaml:${snakeYamlVersion}"

    testImplementation 'junit:junit:4.13.2'
    testImplementation "${groovyPackage}:groovy-test:${groovyVersion}"
    testImplementation "${groovyPackage}:groovy-console:${groovyVersion}"
    if(groovyVersion.tokenize('.').first() == '4') {
        testImplementation "org.codenarc:CodeNarc:${codeNarcVersion}-groovy-4.0"
    } else {
        testImplementation "org.codenarc:CodeNarc:${codeNarcVersion}"
    }
    // CodeNarc throws stderr messages about SLF4J so this dependency makes the
    // stderr go away.
    testImplementation 'org.slf4j:slf4j-nop:2.0.5'
}

test {
    // show standard out and standard error of the test JVM(s) on the console
    testLogging.showStandardStreams = true

    // set heap size for the test JVM(s)
    minHeapSize = '128m'
    maxHeapSize = '512m'

    // listen to events in the test execution lifecycle
    beforeTest { descriptor ->
        logger.lifecycle('Running test: ' + descriptor)
    }

    // listen to standard out and standard error of the test JVM(s)
    onOutput { descriptor, event ->
        logger.lifecycle('Test: ' + descriptor + ' produced standard out/err: ' + event.message )
    }
}

//https://github.com/s992/gatsby-blog/blob/master/src/content/posts/2014-07-17-running-the-groovy-console-from-gradle/index.md
task( console, dependsOn: "classes", type: JavaExec ) {
    mainClass = "groovy.ui.Console"
    classpath = sourceSets.main.runtimeClasspath + sourceSets.test.runtimeClasspath
}

task( update_vscode, dependsOn: "classes" ) {
    doLast {
        String classpath = (sourceSets.main.runtimeClasspath + sourceSets.test.runtimeClasspath).asPath
        Map launch = (new groovy.json.JsonSlurper()).parseText(new File('.vscode/launch.json').text)
        launch.configurations[0].classPaths = classpath.tokenize(':')

        new File('.vscode/launch.json').withWriter('UTF-8') { writer ->
            writer << groovy.json.JsonOutput.prettyPrint((launch as groovy.json.JsonBuilder).toString())
        }
    }
}

//Maven Central uploads
task javadocJar(type: Jar, dependsOn: groovydoc) {
    archiveClassifier = 'javadoc'
    from groovydoc.destinationDir
}

task testJar(type: Jar, dependsOn: testClasses) {
    archiveClassifier = 'tests'
    includes = ['net/gleske/**/*.class']
    excludes = ['*.json', 'mocks/**/*', '**/*Test$_*.class', '**/*Test.class']
    from sourceSets.test.output
}

task testSourcesJar(type: Jar) {
    archiveClassifier = 'tests-sources'
    includes = ['net/gleske/**/*.groovy']
    excludes = ['**/*Test.groovy']
    from sourceSets.test.allSource
}

artifacts {
    archives javadocJar, testJar, testSourcesJar
}

jar {
    manifest {
        attributes 'Library-Name': rootProject.name,
                   'Library-Version': version,
                   'Library-Source': 'https://github.com/samrocketman/jervis',
                   'Library-Git-Hash': ['git', 'rev-parse', 'HEAD'].execute()?.text?.trim()
    }
}

publishing {
    repositories {
        maven {
            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
            credentials {
                username = ossrhUsername
                password = ossrhPassword
            }
        }
    }
    publications {
        binary(MavenPublication) {
            from components.java
        }
        binaryAndSources(MavenPublication) {
            from components.java
            artifact javadocJar
            artifact testJar
            artifact testSourcesJar
            pom {
                name = 'Jervis'
                packaging = 'jar'
                // optionally artifactId can be defined here
                description = 'Self service Jenkins job generation using Jenkins Job DSL plugin groovy scripts. Reads .jervis.yml and generates a job in Jenkins.'
                url = 'https://github.com/samrocketman/jervis'

                licenses {
                    license {
                        name = 'Apache License, Version 2.0'
                        url  = 'https://raw.githubusercontent.com/samrocketman/jervis/main/LICENSE'
                    }
                }

                developers {
                    developer {
                        id = 'sag47'
                        name = 'Sam Gleske'
                        email = 'sam.mxracer@gmail.com'
                    }
                }

                scm {
                    connection = 'https://github.com/samrocketman/jervis.git'
                    developerConnection = 'git@github.com:samrocketman/jervis.git'
                    url = 'https://github.com/samrocketman/jervis'
                }
            }
        }
    }
}

// ./gradlew publish
tasks.withType(PublishToMavenRepository) {
    onlyIf("publishing to maven central") {
        publication == publishing.publications.binaryAndSources
    }
}

// ./gradlew publishToMavenLocal
tasks.withType(PublishToMavenLocal) {
    onlyIf("publishing only jar") {
        publication == publishing.publications.binary
    }
}

// signing must go after publishing block
signing {
    required { gradle.taskGraph.hasTask("uploadArchives") && !gradle.taskGraph.hasTask("uploadArchives") }
    def signingKey = findProperty("signingKey")
    def signingPassword = findProperty("signingPassword")
    useInMemoryPgpKeys(signingKey, signingPassword)
    //sign configurations.archives
    sign publishing.publications.binaryAndSources
}

// disable Gradle metadata in maven publishing
tasks.withType(GenerateModuleMetadata) {
    enabled = false
}

//dependencies for building a jar
jar.dependsOn tasks.findAll { task -> task.name.endsWith('Jar') }

//disable optimizations for accurate branch coverage
//https://pbetkier.github.io/2014/08/07/groovy-code-coverage-issues.html
gradle.taskGraph.whenReady { graph ->
    if(graph.hasTask(':test')) {
        compileTestGroovy.groovyOptions.configurationScript = file('gradle/groovyTestCompilerConfig.groovy')
    }
    if(graph.hasTask(':jacocoTestReport')) {
        compileGroovy.groovyOptions.optimizationOptions.all = false
    }
    if(graph.hasTask(':publish')) {
        if(!(System.getenv('ORG_GRADLE_PROJECT_signingKey') && System.getenv('ORG_GRADLE_PROJECT_signingPassword'))) {
            throw new GradleException("ERROR: Attempting to release without signing key and password.  See RELEASE.md for details.")
        }
    }
}

jacocoTestReport {
    reports {
        csv.required = false
        xml {
            required = true
            outputLocation = file("${buildDir}/test-results/jacoco.xml")
        }
        html.outputLocation = file("${buildDir}/reports/jacoco")
    }
    if(!findProperty('betaCoverage')) {
        afterEvaluate {
            classDirectories.from = files(classDirectories.files.collect {
                fileTree(dir: it, exclude: '**/beta/**')
            })
        }
    }
}

coveralls {
    jacocoReportPath 'build/test-results/jacoco.xml'
}

// sonarqube integration
sonarqube {
    properties {
        //property "sonar.projectKey", "jervis"
        //property "sonar.projectName", "jervis"
        property "sonar.coverage.jacoco.xmlReportPaths", "${buildDir}/test-results/jacoco.xml"
        if(!findProperty('betaCoverage')) {
            property "sonar.coverage.exclusions", "**/beta/**"
        }
    }
}
project.tasks["jacocoTestReport"].dependsOn "check"
project.tasks["sonarqube"].dependsOn "jacocoTestReport"
project.tasks["coveralls"].dependsOn "jacocoTestReport"

//http://www.gradle.org/docs/current/userguide/gradle_wrapper.html
//generate gradlew with: ./gradlew wrapper --gradle-version 7.6