build.gradle

buildscript { repositories { mavenCentral() } }

ext {
    // skipping cnf since it is a not a java project
    javaProjects = subprojects.findAll { it.name != "cnf" && it.plugins.hasPlugin('biz.aQute.bnd') }

    // used to aggregate test coverage reports
    testableProjects = javaProjects.findAll{ it.hasProperty('test') }

    // directory to gather artifacts
    distributionDir = rootProject.file("dist")

    // some SpotBugs finding can be ignored / excluded
    spotbugsExcludeFilterFile = rootProject.file('gradle/spotbugs/excludeFilter.xml')

    // will hold configurations files for invidual formatters
    spotlessDir = "$rootDir/gradle/spotless/"

    // points to our maven dependencies (stored as GAV)
    mavenGAV = "$rootDir/cnf/ext/maven/central.mvn"
}

allprojects {
    repositories { mavenCentral() }

    apply plugin: com.diffplug.gradle.spotless.SpotlessPlugin
    spotless {
        format 'bnd', {
            target '**/*.bnd', '**/*.bndrun'
            indentWithSpaces(4)
            endWithNewline()
        }
        format 'markdown', {
            target '**/*.md'
            indentWithSpaces(2)
            endWithNewline()
        }
        groovyGradle {
            target '*.gradle'
            greclipse().configFile(rootProject.file("gradle/spotless/org.kromo.gradleformat.properties"))
            indentWithSpaces(4)
            endWithNewline()
            // helps debugging formatting issues
            paddedCell()
        }
    }
}

// required as jacocoRootReport belongs to root project
apply plugin: 'jacoco'
jacoco { toolVersion = jacoco_version }

apply plugin: "com.dorongold.task-tree"

configure(javaProjects) { project ->
    // using bnd as source of truth regarding version (actually defined in "cnf/build.bnd")
    version = project.bnd.get("base.version")

    // using bnd to get project description from bundle name
    description = project.bnd.get("Bundle-Name")

    // bnd release also includes Javadoc which has to be built beforehand
    release { dependsOn javadoc }

    task releaseClean(type: Delete) {
        doLast {
            // failOnError needed if 'distributionDir' directory does not exist
            ant.delete(includeEmptyDirs: 'true', failOnError: 'false') {
                // delete only files of _this_ project from distributionDir
                fileset(dir: distributionDir, includes: "**/${project.name}/**")
            }
        }
    }
    clean { dependsOn releaseClean }

    apply plugin: 'jacoco'
    jacoco { toolVersion = jacoco_version }

    // configure tests to use JUnit5
    tasks.withType(Test) {

        // use specific version
        dependencies { testImplementation('org.junit.jupiter:junit-jupiter:' + junit_version) }

        // required to run JUnit5 tests
        useJUnitPlatform()

        // log only this specific events for tests
        testLogging {
            events "skipped", "failed"

            // enable stacktraces for tests

            showExceptions              true
            showStackTraces             true
            showCauses                  true
            showStandardStreams         true

            exceptionFormat             org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
            stackTraceFilters           org.gradle.api.tasks.testing.logging.TestStackTraceFilter.ENTRY_POINT
        }

        jacocoTestReport {
            // requires performed tests if called directly
            dependsOn test

            additionalSourceDirs.from   = files(sourceSets.main.allSource.srcDirs)
            sourceDirectories.from      = files(sourceSets.main.allSource.srcDirs)
            classDirectories.from       = files(sourceSets.main.output)

            reports {
                html.enabled = true
                xml.enabled = true
                csv.enabled = false
            }
        }

        // report is always generated after tests ran
        finalizedBy jacocoTestReport
    }

    apply plugin: 'com.github.spotbugs'
    spotbugs {
        ignoreFailures = true
        effort = 'max'
        reportLevel = 'low'
        excludeFilter = spotbugsExcludeFilterFile
    }

    spotbugsMain {
        // activate SpotBugs only if there are sources
        onlyIf { isNotEmpty(sourceSets.main.java) }
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    spotbugsTest {
        // activate SpotBugs only if there are sources
        onlyIf { isNotEmpty(sourceSets.test.java) }
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    apply plugin: 'net.ltgt.errorprone'
    dependencies { errorproneJavac("com.google.errorprone:error_prone_core:${errorprone_version}") }

    spotless {
        java {
            trimTrailingWhitespace()
            removeUnusedImports()
            eclipse("${eclipse_version}").configFile    rootProject.file(spotlessDir + "org.kromo.eclipseformat.xml")
            importOrderFile                             rootProject.file(spotlessDir + "org.kromo.importorder")
            licenseHeaderFile                           rootProject.file(spotlessDir + "license.txt")
            // helps debugging formatting issues
            paddedCell()
        }
    }

    javadoc {
        title = "${project.description} - v${version}"
        source = sourceSets.main.allJava
        classpath = configurations.compileClasspath

        options { setMemberLevel JavadocMemberLevel.PROTECTED }
    }

    task javadocCheck(type: Javadoc) {
        source = sourceSets.main.allJava
        source += sourceSets.test.allJava
        classpath = sourceSets.main.compileClasspath
        classpath += sourceSets.test.compileClasspath
        // use a non-default destinationDir to avoid interfering with regular javadoc
        destinationDir = file("${buildDir}/tmp/checks/javadoc")

        // copy most options from regular javadoc task
        options { setMemberLevel JavadocMemberLevel.PRIVATE }
    }
    // the Javadoc check should be included when doing final checks
    check { dependsOn javadocCheck }
    // before creating Javadoc we want to check all of it
    // the dependency must be declared after the declaration of "javadocCheck", so that the task is already "known"
    javadoc { dependsOn javadocCheck }

    // common configuration for all Javadoc tasks
    tasks.withType(Javadoc) {
        options {
            author = true
            charSet = 'UTF-8'
            encoding = 'UTF-8'
            docEncoding = 'UTF-8'
            use = true
            splitIndex = true
            noIndex = false
            noNavBar = false
            noTree = false

            links "https://docs.oracle.com/javase/8/docs/api/"
        }
    }
}

def isNotEmpty(SourceDirectorySet sourceDirectorySet) {
    return null != sourceDirectorySet && (0 < sourceDirectorySet.size())
}

task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
    description = 'Generates an aggregate report from all (testable) subprojects'

    dependsOn testableProjects.test

    additionalSourceDirs.from   = files(testableProjects.sourceSets.main.allSource.srcDirs)
    sourceDirectories.from      = files(testableProjects.sourceSets.main.allSource.srcDirs)
    classDirectories.from       = files(testableProjects.sourceSets.main.output)

    // ensure we care only about projects which have execution data
    executionData.from          = files(testableProjects.jacocoTestReport.executionData).filter { f -> f.exists() }

    reports {
        html.enabled = true
        xml.enabled = false
        csv.enabled = false
    }
}

task buildPom {
    description 'Compiles GAV depndecies into a root level pom.xml which can be parsed by bnd-agnostic tools'
    dependsOn javaProjects.classes

    File gavFile = new File(mavenGAV)
    inputs.file gavFile

    def pomFile = rootProject.file("pom.xml")
    outputs.file pomFile

    StringBuilder sb = new StringBuilder()

    sb.append("<?xml version='1.0' encoding='UTF-8'?>")
    sb.append("\n<project")
    sb.append("\n        xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'")
    sb.append("\n        xmlns='http://maven.apache.org/POM/4.0.0'")
    sb.append("\n        xsi:schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd'>")
    sb.append("\n    <modelVersion>4.0.0</modelVersion>")
    sb.append("\n")
    sb.append("\n    <groupId>${rootProject.name}</groupId>")
    sb.append("\n    <artifactId>dependecies</artifactId>")
    sb.append("\n    <version>1.0.0</version>")
    sb.append("\n    <name>${rootProject.name} depedencies</name>")
    sb.append("\n")
    sb.append("\n    <dependencies>")

    addGAVFileAsMavenDependencies(sb, gavFile, "compile")

    sb.append("\n    </dependencies>")
    sb.append("\n")
    sb.append("\n    <build>")
    sb.append("\n        <plugins>")
    sb.append("\n            <plugin>")
    sb.append("\n                <groupId>org.codehaus.mojo</groupId>")
    sb.append("\n                <artifactId>versions-maven-plugin</artifactId>")
    sb.append("\n                <version>${versions_maven_plugin_version}</version>")
    sb.append("\n                <configuration>")
    sb.append("\n                    <!-- Using rules to exclude alpha/beta/milestone/RC versions -->")
    // using single quotes since the variable is to be expanded by Maven and NOT Gradle
    sb.append('\n                    <rulesUri>file:///${project.basedir}/version-rules.xml</rulesUri>')
    sb.append("\n                </configuration>")
    sb.append("\n            </plugin>")
    sb.append("\n        </plugins>")
    sb.append("\n")
    sb.append("\n        <defaultGoal>versions:display-dependency-updates</defaultGoal>")
    sb.append("\n    </build>")
    sb.append("\n")
    sb.append("\n</project>\n")

    pomFile.write sb.toString()
}
// execute task after we were able to compile projects
task classes {
    dependsOn javaProjects.classes
    finalizedBy buildPom
}

def addGAVFileAsMavenDependencies(StringBuilder sb, File gavFile, String scope) {
    String[] gavFileLines = gavFile
    int line = 0
    StringBuilder errors = new StringBuilder()
    for(String gavFileLine in gavFileLines) {
        line++
        String gavLine = gavFileLine.split("#", 2)[0].trim()
        if (!gavLine.isEmpty()) {
            if (gavLine.indexOf(":") == -1) {
                def msg = "Invalid GAV '${gavLine}', line: ${line}. No colon found! File: ${gavFile}"
                errors.append("\n  ").append(msg)
                continue
            }

            final String[] gav = gavLine.split(":", -1)
            if (gav.length != 3) {
                def msg = "Invalid GAV '${gavLine}', line: ${line}. Needs 3 parts, found: " + gav.length + " File: ${gavFile}"
                errors.append("\n  ").append(msg)
                continue
            }

            String groupId = gav[0].trim()
            String artifactId = gav[1].trim()
            String version = gav[2].trim()

            sb.append("\n        <dependency>")
            sb.append("\n            <groupId>${groupId}</groupId>")
            sb.append("\n            <artifactId>${artifactId}</artifactId>")
            sb.append("\n            <version>${version}</version>")
            sb.append("\n            <scope>${scope}</scope>")
            sb.append("\n        </dependency>")
        }
    }

    if (0 < errors.length()) {
        errors.insert(0, "Failed to parse Maven GAV coordinates, file: ${fileName}")
        throw new IllegalArgumentException(errors.toString())
    }
}

tasks.named('build') { dependsOn javaProjects.build, jacocoRootReport }

task release {
    dependsOn javaProjects.release, jacocoRootReport

    doLast {
        copy {
            from buildDir
            include "reports/jacoco/**"
            exclude "**/*.xml"
            into distributionDir
        }
    }
}

task releaseClean(type: Delete) {
    dependsOn javaProjects.releaseClean

    doLast {
        // failOnError needed if 'distributionDir' directory does not exist
        ant.delete(includeEmptyDirs: 'true', failOnError: 'false') {
            fileset(dir: distributionDir, includes: "**/**")
        }
    }
}

tasks.named('clean') { dependsOn releaseClean }