build.gradle

import org.apache.tools.ant.filters.ReplaceTokens
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

plugins {
    id 'com.github.johnrengelman.shadow' version '7.1.2'
    id 'com.github.kt3k.coveralls' version '2.12.2'
    id 'com.marklogic.ml-gradle' version '4.6.0'
    id 'io.github.ddimtirov.codacy' version '0.1.0'
    id 'org.sonarqube' version '4.0.0.2929'
    id 'eclipse'
    id 'idea'
    id 'jacoco'
    id 'java'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
}

ext {
    // we don't need a REST server, only an XCC server
    mlAppDeployer.getCommands().remove(mlAppDeployer.getCommand('DeployRestApiServersCommand'))
    mlAppConfig {
        name = project.name
        customTokens.put('%%XDBC_PORT%%', '8223')
        createTriggersDatabase = false
    }
}

sourceCompatibility = '1.8'
targetCompatibility = '1.8'

repositories {
    mavenCentral()
    flatDir {
        dirs 'src/test/resources/'
    }
}

sourceSets {
    test {
        // adding main resources from build dir, in order to load HTML with tokens replaced
        resources.srcDir sourceSets.main.output.resourcesDir
    }
    integrationTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/test/java')
        }
        resources.srcDir file('src/test/resources')
    }
    performanceTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/test/java')
        }
        resources.srcDir file('src/test/resources')
    }
}

configurations {
    shadow {
        extendsFrom api //will ensure that XCC is listed as a dependency
    }

    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly

    performanceTestImplementation.extendsFrom testImplementation
    performanceTestRuntimeOnly.extendsFrom testRuntimeOnly

    // encountered issues publishing since upgrading to Gradle 6:
    /* What went wrong:
    Execution failed for task ':publishMainJavaPublicationToMavenLocal'.
    > Failed to publish publication 'mainJava' to repository 'mavenLocal'
       > Artifact marklogic-corb-2.5.1.jar wasn't produced by this build.
     */
    // Suggested workaround: https://docs.gradle.org/current/userguide/upgrading_version_6.html#publishing_spring_boot_applications
    [apiElements, runtimeElements].each {
        it.outgoing.artifacts.removeIf { it.buildDependencies.getDependencies(null).contains(jar) }
    }
}

dependencies {
    api 'com.marklogic:marklogic-xcc:11.1.0'
    // JavaScript libraries are  bundled in a fat jar for the UI
    implementation "org.webjars:angularjs:$angularVersion"
    shadow "org.webjars:angularjs:$angularVersion"
    implementation "org.webjars:bootstrap:$bootstrapVersion"
    shadow "org.webjars:bootstrap:$bootstrapVersion"
    implementation "org.webjars:jquery:$jqueryVersion"
    shadow "org.webjars:jquery:$jqueryVersion"
    // externalsortinginjava classes with the corb distro in a fat jar
    implementation "com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"
    shadow "com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"
    testImplementation group: 'junit', name: 'junit', version: '4.13.2'
    testImplementation 'org.jasypt:jasypt:1.9.3'
    testImplementation 'com.github.stefanbirkner:system-rules:1.19.0' //facilitates tests for methods that invoke System.exit
    testImplementation 'org.mockito:mockito-all:1.10.19'
}

test {
    //we will run Integration and Performance tests in separate tasks
    exclude '**/*IT.class'
    exclude '**/*PT.class'
}

// perform token replacement in HTML for JavaScript library version paths
processResources {
    with copySpec {
        duplicatesStrategy = 'include'
        from ('src/main/resources/web') {
            include '*.html'
        }
        into ('web')
        filter(ReplaceTokens, tokens: [ANGULAR_VERSION: angularVersion, BOOTSTRAP_VERSION: bootstrapVersion, JQUERY_VERSION: jqueryVersion])
    }
}
processTestResources.dependsOn processResources

//disabling, because we want to incorporate externalsortingjava and UI resources in uber jar and use as the artifact
jar {
    enabled = false
    dependsOn(shadowJar { classifier = null })
}
shadowJar {

    //project.configurations.implementation.canBeResolved = true
    configurations = [project.configurations.shadow]
    dependencies {
        include(dependency("com.google.code.externalsortinginjava:externalsortinginjava:$externalsortinginjavaVersion"))
        include(dependency('org.webjars:.*'))
    }
    //generate same name as the jar task would
    //archiveFileName = "${archiveBaseName}-${archiveVersion}.${archiveExtension}"
    archiveFileName = "${baseName}-${version}.${extension}"
    manifest {
        attributes 'Application-Version': project.version
        attributes 'Build-date' : new Date()
        attributes 'Main-Class' : 'com.marklogic.developer.corb.Manager'

        attributes 'Name': 'com/marklogic/developer/corb/'
        attributes 'Specification-Title' : 'corb'
        attributes 'Specification-Version' : project.version
        attributes 'Implementation-Title' : project.name
        //Manager class reads the version for usage messages
        attributes 'Implementation-Version' : project.version
    }
}

sonarqube {
    properties {
        property "sonar.projectKey", "corb2"
        property "sonar.organization", "marklogic-community"
        property "sonar.host.url", "https://sonarcloud.io"
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    description = "Create a JAR of source files; required for publishing"
    classifier 'sources'
    from sourceSets.main.allJava
}

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

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

task integrationTest(type: Test, dependsOn: test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    filter {
        //include all integration tests
        includeTestsMatching "*IT"
    }
    //If you want to ensure that integration tests are run every time when you invoke
    //this task, uncomment the following line.
    //outputs.upToDateWhen { false }
    jacoco {
        destinationFile = file("$buildDir/jacoco/test.exec")
    }
    //generate the Jacoco report
    finalizedBy { tasks.integrationTestReport }
}

task integrationTestReport(type: JacocoReport) {
    sourceSets sourceSets.main
    executionData integrationTest
}

task performanceTest(type: Test) {
    testClassesDirs = sourceSets.performanceTest.output.classesDirs
    classpath = sourceSets.performanceTest.runtimeClasspath
    filter {
        //include all performance tests
        includeTestsMatching "*PT"
    }

    //If you want to ensure that performance tests are run every time when you invoke
    //this task, uncomment the following line.
    outputs.upToDateWhen { false }
}

check.dependsOn jacocoTestReport
//Ensure that the check task fails the build if there are failing integration tests.
check.dependsOn integrationTest
//Ensure that our unit tests are run before our integration tests
integrationTest.mustRunAfter test
integrationTest.onlyIf { !project.hasProperty('skipIntegrationTest') }
//Ensure that the check task fails the build if there are failing performance tests.
//check.dependsOn performanceTest
//Ensure that our unit tests are run before our performance tests
performanceTest.mustRunAfter integrationTest
performanceTest.onlyIf { !project.hasProperty('skipPerformanceTest') }

tasks.withType(Test) {
    reports.html.destination = file("${reporting.baseDir}/${name}")
    testLogging {
        // set options for log level LIFECYCLE
        events TestLogEvent.FAILED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_OUT
        showExceptions true
        exceptionFormat TestExceptionFormat.SHORT
        showCauses true
        showStackTraces true

        // set options for log level DEBUG and INFO
        debug {
            events TestLogEvent.FAILED,
                   TestLogEvent.SKIPPED,
                   TestLogEvent.STANDARD_OUT,
                   TestLogEvent.STANDARD_ERROR
            exceptionFormat TestExceptionFormat.FULL
        }
        info.events = debug.events
        info.exceptionFormat = debug.exceptionFormat

        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
                def startItem = '|  ', endItem = '  |'
                def repeatLength = startItem.length() + output.length() + endItem.length()
                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
            }
        }
    }
}

tasks.coveralls {
    dependsOn 'check'
}

// Having both runtimeElements and shadowRuntimeElements variants makes it harder to resolve CoRB as a dependency and is confusing.
// We just want the fat jar listed and seen as the only option.
components.java.withVariantsFromConfiguration(configurations.getByName("runtimeElements")) {
    skip()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifact sourcesJar
            artifact javadocJar
            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST
                    name "corb"
                    url project.websiteUrl
                    scm {
                        url project.vcsUrl
                    }
                    issueManagement {
                        system "GitHub Issues"
                        url project.issueTrackerUrl
                    }
                    licenses {
                        license {
                            name "The Apache Software License, Version 2.0"
                            url "http://www.apache.org/licenses/LICENSE-2.0.txt"
                            distribution "repo"
                        }
                    }
                    description 'CoRB is a Java tool designed for bulk content-reprocessing of documents stored in MarkLogic.'
                    developers {
                        developer {
                            name "Bhagat Bandlamudi"
                            email "bhagat.bandlamudi@marklogic.com"
                            organization "MarkLogic"
                        }
                        developer {
                            name "Mads Hansen"
                            email "mads.hansen@marklogic.com"
                            organization "MarkLogic"
                        }
                    }
                }
            }
        }
    }
    repositories {
        maven {
            url ossURL
            credentials {
                username ossUsername
                password ossPassword
            }
        }
    }
}

signing {
    sign publishing.publications.mavenJava
}