build.gradle

import org.gradle.internal.os.OperatingSystem

buildscript {
    repositories {
        mavenCentral()
    }
}

plugins {
    id "java-library"
    id 'maven-publish'
    id 'signing'
    id 'jacoco'
    id 'application'
    id 'com.palantir.git-version' version '0.5.1'
    id 'com.github.johnrengelman.shadow' version '8.1.1'
    id "com.github.kt3k.coveralls" version '2.6.3'
    id "org.ajoberstar.grgit" version "5.2.0"
    id "org.ajoberstar.git-publish" version "2.1.1"
}

application {
    mainClass = "picard.cmdline.PicardCommandLine"
}

repositories {
    mavenCentral()
    maven {
        url "https://broadinstitute.jfrog.io/broadinstitute/libs-snapshot/" //for htsjdk snapshots
    }
    mavenLocal()
}

final buildPrerequisitesMessage = "See https://github.com/broadinstitute/picard/blob/master/README.md#building-picard for information on how to build picard."

// Check that we're in a folder which git recognizes as a git repository.
// This works for either a standard git clone or one created with `git worktree add`
def looksLikeWereInAGitRepository(){
    file(".git").isDirectory() || (file(".git").exists() && file(".git").text.startsWith("gitdir"))
}

// Ensure that we have a clone of the git repository, and resolve any required git-lfs
// resource files that are needed to run the build but are still lfs stub files.
def ensureBuildPrerequisites(buildPrerequisitesMessage) {
    if (!JavaVersion.current().equals(JavaVersion.VERSION_17)) {
        println("Warning: using Java ${JavaVersion.current()} but only Java 17 has been tested.")
    }
    if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
        throw new GradleException(
                "A Java 17 compatible (Java 17 or later) version is required to build GATK, but ${JavaVersion.current()} was found. "
                        + "$buildPrerequisitesMessage")
    }
    if (!looksLikeWereInAGitRepository()) {
        throw new GradleException("This doesn't appear to be a git folder. " +
                "The Picard Github repository must be cloned using \"git clone\" to run the build. " +
                "\n$buildPrerequisitesMessage")
    }
}

ensureBuildPrerequisites(buildPrerequisitesMessage)

final htsjdkVersion = System.getProperty('htsjdk.version', '4.1.3')
final log4jVersion = System.getProperty('log4j.version', '2.20.0')

dependencies {
    api 'com.github.samtools:htsjdk:' + htsjdkVersion
    api 'org.broadinstitute:barclay:5.0.0'

    //gkl and associated native bindings
    implementation('com.intel.gkl:gkl:0.8.11'){
        exclude module: 'htsjdk'
    }
    implementation 'org.broadinstitute:gatk-native-bindings:1.0.0' //this should be redundant when GKL is updated past 0.8.11

    //needed for execuing javascript in filter
    implementation 'org.openjdk.nashorn:nashorn-core:15.4'

    implementation 'com.google.guava:guava:32.1.1-jre'
    implementation 'org.apache.commons:commons-math3:3.6.1'
    implementation 'org.apache.commons:commons-collections4:4.4'
    implementation 'org.apache.commons:commons-lang3:3.12.0'
    implementation 'commons-io:commons-io:2.11.0'

    //nio plugin providers for google cloud and http(s)
    implementation 'com.google.cloud:google-cloud-nio:0.127.0'
    implementation 'org.broadinstitute:http-nio:1.1.1'

    testImplementation 'org.testng:testng:7.7.0'

    constraints {
        //log4j api and core, specify these so we don't transitively get old vulnerable versions
        implementation 'org.apache.logging.log4j:log4j-api:' +log4jVersion
        implementation 'org.apache.logging.log4j:log4j-core:' + log4jVersion
    }
}

configurations.configureEach {
    resolutionStrategy {
        // force the htsjdk version so we don't get a different one transitively
        force 'com.github.samtools:htsjdk:' + htsjdkVersion
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
    withJavadocJar()
    withSourcesJar()
}

final isRelease = Boolean.getBoolean("release")
final gitVersion = gitVersion().replaceAll(".dirty", "")
version = isRelease ? gitVersion : gitVersion + "-SNAPSHOT"

logger.info("build for version:" + version)
group = 'com.github.broadinstitute'

defaultTasks 'all'

tasks.register('all') { dependsOn 'jar', 'distZip', 'javadoc', 'shadowJar', 'currentJar', 'picardDoc' }

tasks.withType(Jar).configureEach {
    manifest {
        attributes 'Main-Class': 'picard.cmdline.PicardCommandLine',
                'Implementation-Title': 'Picard',
                'Implementation-Vendor': 'Broad Institute',
                'htsjdk-Version': htsjdkVersion,
                'Implementation-Version': version,
                'Multi-Release': 'true'
    }
}

tasks.withType(Javadoc).configureEach {
    // do this for all javadoc tasks, including gatkDoc
    options.addStringOption('Xdoclint:none')
}

javadoc {
    options.addStringOption('Xdoclint:none', '-quiet')
}

// Generate Picard Online Doc
tasks.register('picardDoc', Javadoc) {
    dependsOn 'cleanPicardDoc', classes
    final File picardDocDir = file("build/docs/picarddoc")
    doFirst {
        // make sure the output folder exists or we can create it
        if (!picardDocDir.exists() && !picardDocDir.mkdirs()) {
            throw new GradleException(String.format("Failure creating folder (%s) for picardDocDir doc output in task (%s)",
                    picardDocDir.getAbsolutePath(),
                    it.name));
        }
        copy {
            from('src/main/resources/picard/helpTemplates')
            include 'picardDoc.css'
            into picardDocDir
        }
    }
    source = sourceSets.main.allJava

    // The picardDoc process instantiates any documented feature classes, so to run it we need the entire
    // runtime classpath. The compileClasspath is required in order for the picardDoc doclet process to
    // resolve the googleNio classes, which are compile-time only.
    classpath = sourceSets.main.compileClasspath + sourceSets.main.runtimeClasspath
    options.docletpath = classpath.asType(List)
    options.doclet = "picard.util.help.PicardHelpDoclet"

    outputs.dir(picardDocDir)
    options.destinationDirectory(picardDocDir)

    options.addStringOption("settings-dir", "src/main/resources/picard/helpTemplates/");
    options.addStringOption("output-file-extension", "html")
    options.addStringOption("absolute-version", getVersion())
    options.addStringOption("build-timestamp", new Date().format("dd-mm-yyyy hh:mm:ss"))
    options.addStringOption("verbose")
    // Avoid 'javadoc: error - invalid flag: -notimestamp'. See:
    //   - https://github.com/gradle/gradle/issues/11898
    //   - https://github.com/gradle/gradle/issues/11898#issuecomment-993789034
    options.noTimestamp(false)
}

tasks.register('currentJar', Copy) {
    from shadowJar
    into file("$buildDir/libs")
    rename { string -> "picard.jar" }
}

shadowJar {
    finalizedBy currentJar
}

// Run the tests using the legacy parser only. Assumes that test code is written using
// legacy command line parser syntax.
tasks.register('legacyTest', Test) {
    systemProperty 'picard.useLegacyParser', 'true'
}

// Run the tests using the Barclay command line parser (useLegacyParser=false), which requires
// conversion of test command lines from Picard-style command line syntax to Barclay-style syntax.
tasks.register('barclayTest', Test) {
    systemProperty 'picard.convertCommandLine', 'true'
}

// Run tests using both the legacy and barclay command line parsers.
test {
    dependsOn barclayTest
}

tasks.withType(Test).configureEach {
    outputs.upToDateWhen { false } // tests will always rerun
    description = "Runs the unit tests"

    jvmArgs += [
            // required for MergeBamAlignmentTest
            '--add-opens', 'java.base/java.io=ALL-UNNAMED'
    ]

    useTestNG {
        List excludes = ["slow", "broken"]
        if (!OperatingSystem.current().isUnix()) {
            excludes << "unix"
        }
        String TEST_TYPE = "$System.env.TEST_TYPE"
        if (TEST_TYPE == "cloud") {
            // run only the cloud tests
            includeGroups "cloud", "bucket"
            excludeGroups(*excludes)
        } else if (TEST_TYPE == "all") {
            //include everything
            excludeGroups(*excludes)
        } else {
            excludes.addAll("cloud", "bucket")
            excludeGroups(*excludes);
        }
    }

    // set heap size for the test JVM(s)
    minHeapSize = "1G"
    maxHeapSize = "2G"
    if (System.env.CI == "true") {  //if running under a CI output less into the logs
        int count = 0

        beforeTest { descriptor ->
            count++
            if (count % 100 == 0) {
                logger.lifecycle("Finished " + Integer.toString(count++) + " tests")
            }
        }
    } else {
        // show standard out and standard error of the test JVM(s) on the console
        testLogging.showStandardStreams = true
        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)
        }
    }

    testLogging {
        testLogging {
            events "skipped", "failed"
            exceptionFormat = "full"
        }
        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                println "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
            }
        }
    }
}

jacocoTestReport {
    dependsOn legacyTest
    group = "Reporting"
    description = "Generate Jacoco coverage reports after running tests."
    getAdditionalSourceDirs().from(sourceSets.main.allJava.srcDirs)

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

wrapper {
    gradleVersion = '8.5'
}

/**
 * Sign non-snapshot releases with our secret key.  This should never need to be invoked directly.
 */
signing {
    required { isRelease && gradle.taskGraph.hasTask("publish") }
    sign publishing.publications
}

/**
 * Upload a release to sonatype.  You must be an authorized uploader and have your sonatype
 * username and password information in your gradle properties file.  See the readme for more info.
 *
 * For releasing to your local maven repo, use gradle install
 */
publishing {
    publications {
        picard(MavenPublication) {
            from components.java

            pom {
                name = 'Picard'
                packaging = 'jar'
                description = 'A set of command line tools (in Java) for manipulating high-throughput sequencing (HTS) data and formats such as SAM/BAM/CRAM and VCF.'
                url = 'http://broadinstitute.github.io/picard/'

                scm {
                    url = 'git@github.com:broadinstitute/picard.git'
                    connection = 'scm:git:git@github.com:broadinstitute/picard.git'
                }

                licenses {
                    license {
                        name = 'MIT License'
                        url = 'http://opensource.org/licenses/MIT'
                        distribution = 'repo'
                    }
                }

                developers {
                    developer {
                        id = 'picard'
                        name = 'Picard Team'
                        url = 'http://broadinstitute.github.io/picard'
                    }
                }
            }
        }
    }
    repositories {
        maven {
            credentials {
                username = isRelease ? project.findProperty("sonatypeUsername") : System.env.ARTIFACTORY_USERNAME
                password = isRelease ? project.findProperty("sonatypePassword") : System.env.ARTIFACTORY_PASSWORD
            }
            def release = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
            def snapshot = "https://broadinstitute.jfrog.io/broadinstitute/libs-snapshot-local/"
            url = isRelease ? release : snapshot
        }
    }
}

publish {
    doFirst {
        System.out.println("Uploading version $version")
    }
}

ext.htmlDir = file("build/docs/html")

//update static web docs
tasks.register('copyJavadoc', Copy) {
    dependsOn 'javadoc', 'picardDoc'
    from 'build/docs/javadoc'
    into "$htmlDir/javadoc"
}

tasks.register('copyPicardDoc', Copy) {
    dependsOn 'picardDoc'
    from 'build/docs/picarddoc'
    into "$htmlDir/picarddoc"
}

tasks.register('updateGhPages') {
    dependsOn 'copyJavadoc', 'copyPicardDoc'
    outputs.dir htmlDir
}

updateGhPages.finalizedBy gitPublishPush

gitPublish {
    repoUri = 'git@github.com:broadinstitute/picard.git'
    branch = 'gh-pages'
    preserve { include '**/*' }
    contents { 
        from('build/docs/html') { 
            into 'newdocs' 
        } 
    }
}

gitPublishCopy {
    dependsOn 'updateGhPages', 'copyJavadoc', 'copyPicardDoc'
}

// For Gradle 8 explicitly add 'currentJar' as a dependency of the following tasks.
// For more information, please refer to
// https://docs.gradle.org/8.2.1/userguide/validation_problems.html#implicit_dependency in the Gradle documentation.
['distZip', 'distTar', 'startScripts', 'startShadowScripts', 'generateMetadataFileForPicardPublication'].each {
    tasks.named(it).configure {
        dependsOn 'currentJar'
    }
}