build.gradle

plugins {
    id "eclipse"
    id "idea"
    id "io.sdkman.vendors"              version "2.0.0"     apply false
    id "com.jfrog.bintray"              version "1.8.5"     apply false
    id "com.github.kt3k.coveralls"      version "2.10.2"    apply false
    id "org.sonarqube"                  version "3.1.1"     apply false
    id 'com.github.ben-manes.versions'  version '0.38.0'
    id "nebula.optional-base"           version "5.0.3"     apply false
}

// common variables
ext {
    isTravis = (System.getenv("TRAVIS") == "true")
    isTravisPullRequest = (System.getenv("TRAVIS_PULL_REQUEST")) != "false"
    pullRequestId = System.getenv("TRAVIS_PULL_REQUEST")
    pullRequestBranch = System.getenv("TRAVIS_PULL_REQUEST_BRANCH")
    hasGithub = System.getenv("GITHUBTOKEN") && System.getenv("GITHUBREPO")
    hasSonar = System.getenv("SONARORG") && System.getenv("SONARLOGIN")
    sonarDefaultURL = "https://sonarcloud.io"
    sonarDefaultProjectKey = "org.jbake:jbake-base:jbake-core"
    sonarURL = System.getenv("SONARHOST") ?: sonarDefaultURL
    sonarProjectKey = System.getenv("SONARPROJECTKEY") ?: sonarDefaultProjectKey
}

/**
 * Apply coveralls to the root project as we just need it here to send the
 * aggregated coverage execution data from the jacocoRootReport task
 */
apply plugin: 'com.github.kt3k.coveralls'

/**
 * Apply jacoco plugin to all projects and add jcenter as default repository
 */
allprojects {
    apply plugin: 'jacoco'

    if ( JavaVersion.current().isJava8Compatible() ) {

        apply plugin: 'checkstyle'

        tasks.withType(Checkstyle) {
            reports {
                xml.enabled false
                html.enabled true
            }
        }

    }

    repositories {
        jcenter()
    }

    jacoco {
        toolVersion = jacocoVersion
    }

}

/**
 * Common setup for all subprojects
 */
subprojects {

    apply plugin: 'java'
    apply plugin: 'nebula.optional-base'

    // We do not publish any jars from the jbake-dist project
    if ( project.name != "jbake-dist" ) {
      apply from: "$rootDir/gradle/maven-publishing.gradle"
      apply from: "$rootDir/gradle/signing.gradle"
      apply from: "$rootDir/gradle/publishing.gradle"
    }

    // add source and target compatibility for all JavaCompile tasks
    tasks.withType(JavaCompile) {
        sourceCompatibility = 1.8
        targetCompatibility = 1.8
    }

    test {
        useJUnitPlatform()

        testLogging {
            events "passed", "skipped", "failed"
            exceptionFormat "full"
        }
    }

    dependencies {
        implementation "org.slf4j:slf4j-api:$slf4jVersion"
        implementation "org.slf4j:jul-to-slf4j:$slf4jVersion"
        implementation "org.slf4j:jcl-over-slf4j:$slf4jVersion"
        implementation "ch.qos.logback:logback-classic:$logbackVersion", optional
        implementation "ch.qos.logback:logback-core:$logbackVersion", optional

        testImplementation "org.junit-pioneer:junit-pioneer:$junitPioneer"
        testImplementation "org.junit.jupiter:junit-jupiter-api:$junit5Version"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit5Version"
        // compatibility for Junit 4 test
        testCompileOnly "junit:junit:$junit4Version"
        testRuntimeOnly "org.junit.vintage:junit-vintage-engine:$junit5Version"

        testImplementation "org.assertj:assertj-core:$assertjCoreVersion"
        testImplementation "org.mockito:mockito-core:$mockitoVersion"
        testImplementation "org.mockito:mockito-junit-jupiter:$mockitoVersion"
        testImplementation 'org.itsallcode:junit5-system-extensions:1.1.0'
    }

    dependencyUpdates.resolutionStrategy {
        componentSelection { rules ->
            rules.all { ComponentSelection selection ->
                boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm'].any { qualifier ->
                    selection.candidate.version ==~ /(?i).*[.-]?${qualifier}[.\d-]*/
                }
                if (rejected) {
                    selection.reject('Release candidate')
                }
            }
        }
    }

    //set jvm for all Test tasks (like test and smokeTest)
    tasks.withType(Test) {

        def args = ['-Xms512m', '-Xmx3g', '-Dorientdb.installCustomFormatter=false=false','-Djna.nosys=true']

        /**
         * jdk9 build is unable to determine the amount of MaxDirectMemorySize
         * See https://pastebin.com/ECvQeHx0
         */
        if ( JavaVersion.current().java9Compatible ) {
            args << '-XX:MaxDirectMemorySize=2g'
        }
        jvmArgs args
    }

    jacocoTestReport {
        reports {
            xml.enabled = true // coveralls plugin depends on xml format report
            html.enabled = true
        }
    }

    jacocoTestReport.dependsOn test
}

task jacocoMerge(type: JacocoMerge) {
    description 'Merge all testreport execution data from subprojects excluding jbake-dist'
    dependsOn subprojects.test
    executionData subprojects.findAll{it.name!="jbake-dist"}.jacocoTestReport.executionData
}

task jacocoRootReport(type: JacocoReport, group: 'Coverage reports') {
    description = 'Generates an aggregate report from all subprojects'
    dependsOn jacocoMerge

    sourceDirectories.from files(subprojects.sourceSets.main.allSource.srcDirs)
    classDirectories.from files(subprojects.sourceSets.main.output)
    executionData.from jacocoMerge.executionData

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

task testReport(type: TestReport) {
    description "Generate an aggregated Testreport for all projects"

    destinationDir = file("$buildDir/reports/allTests")
    // Include the results from the `test` task in all subprojects
    reportOn subprojects*.test
}

coveralls {
    jacocoReportPath = "${buildDir}/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
}

tasks.coveralls {
    group = 'Coverage reports'
    description = 'Uploads the aggregated coverage report to Coveralls'

    dependsOn jacocoRootReport
    // Skip Task if not run on CI Server
    onlyIf { System.env.'CI' }
}