build.gradle

// -*- java -*-

import com.github.spotbugs.snom.SpotBugsTask

import org.apache.tools.ant.filters.FixCrLfFilter;

buildscript {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
    dependencies {
      // needs to use old plugin mechanism otherwise I can't set the extra properties   
      classpath(group: "com.cinnober.gradle", name: "semver-git", version: "3.0.0")
    }
    configurations.classpath {
      exclude(group: "com.google.guava", module: "guava")
    }
}    

plugins {
    id "java"
    id "distribution"
    id "com.dorongold.task-tree" version "3.0.0" // gradle <task> taskTree
    id "org.unbroken-dome.test-sets" version "4.1.0"
    id "eclipse"
    id "org.kordamp.gradle.markdown" version "2.2.0" // markdownToHtml        
    id "com.github.spotbugs" version "6.0.12"
    id "de.aaschmid.cpd" version "3.3"
    id "edu.sc.seis.launch4j" version "3.0.5"
    id "com.github.ben-manes.versions" version "0.51.0" // adds dependencyUpdates task
    id "de.undercouch.download" version "5.6.0" // file download
    id "checkstyle"
        
    // Checker Framework pluggable type-checking
    id "org.checkerframework" version "0.6.37"
    
    // code coverage
    id "jacoco"
}

// needs to use old plugin mechanism otherwise I can't set nextVersion and snapshotSuffix
ext.nextVersion = "patch"
ext.snapshotSuffix = "beta.<count>+g<sha>"
// optionally: ext.dirtyMarker = "-dirty" (default) replaces <dirty> in snapshotSuffix
// optionally: ext.gitDescribeArgs = '--match *[0-9].[0-9]*.[0-9]*' (default) or other arguments for git describe.
apply plugin: "com.cinnober.gradle.semver-git"

repositories {
    mavenCentral()
    maven {
      url "https://repo.mtu.net/releases"
    }
}

configurations {
    jspc
}

eclipse {
    classpath {
        file {
            downloadJavadoc = true
            downloadSources = true
        
            withXml {
                def node = it.asNode()
                // add web as resource entry
                node.appendNode( "classpathentry", [ kind: "src", path: "src/main/web", output: "bin/web"]) 
            }
                                                                                                                                    
            // remove entries added due to issue with testsets                                                                      
            // https://github.com/unbroken-dome/gradle-testsets-plugin/issues/77                                                    
            whenMerged {                                                                                                            
                entries.removeAll{it.kind == "lib" && (it.path.endsWith("build/classes/java/test") || it.path.endsWith("build/resources/test"))}
            }                                                                                                                       
        }
    }
}

dependencies {
  jspc("org.apache.ant:ant:1.10.14")
}

testSets {
    integrationTest
}

// don't depend on check so that users can skip these on a basic check. check.dependsOn integrationTest
integrationTest.mustRunAfter test

test {
    useJUnitPlatform()
    ignoreFailures = Boolean.getBoolean("test.ignoreFailures") 
    
    jvmArgs = [
    //"-Dlog4j2.debug=true",
    
    // Add the JAVA 9 specific start-up parameters required by Tomcat
    "--add-opens=java.base/java.lang=ALL-UNNAMED",
    "--add-opens=java.base/java.io=ALL-UNNAMED",
    "--add-opens=java.base/java.util=ALL-UNNAMED",
    "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
    "--add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED"
    ]
    
}

integrationTest {
    useJUnitPlatform()
    ignoreFailures = Boolean.getBoolean("test.ignoreFailures") 
    // have selenium log through log4j
    systemProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager")
    
    // debug log4j configuration
    //systemProperty("log4j2.debug", "true")
    forkEvery = 1
    
        jvmArgs = [
    //"-Dlog4j2.debug=true",
    
    // Add the JAVA 9 specific start-up parameters required by Tomcat
    "--add-opens=java.base/java.lang=ALL-UNNAMED",
    "--add-opens=java.base/java.io=ALL-UNNAMED",
    "--add-opens=java.base/java.util=ALL-UNNAMED",
    "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
    "--add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED"
    ]    
}

ext {
    jackson_version = "2.17.0"
    slf4j_version = "2.0.13"
    tomcat_version = "10.1.20"
    junit_version = "5.11.3"
    log4j_version = "2.23.1"
    spotbugs_version = "4.8.4"
    checker_framework_version = "3.42.0"

    web_build_dir = new File(project.buildDir, "web")
    documentation_build_dir = new File(project.buildDir, "gen-documentation")    
    
    jspSrc = "src/main/web"
    jspJavaSrc = new File(project.buildDir, "jsp-java-source")
    jspPackage = "fll.jsp"
    jspJavaClasses = new File(project.buildDir, "jsp-java-classes")

    mainClassName = "fll.Launcher"
    
    // java download urls
    java_download_base = project.buildDir.toPath().resolve("bundled-java")
    
    java_windows_url = "https://download.java.net/java/GA/jdk21.0.2/f2283984656d49d69e91c558476027ac/13/GPL/openjdk-21.0.2_windows-x64_bin.zip"
    java_windows_checksum = "b6c17e747ae78cdd6de4d7532b3164b277daee97c007d3eaa2b39cca99882664"
    
    java_mac_url = "https://download.java.net/java/GA/jdk21.0.2/f2283984656d49d69e91c558476027ac/13/GPL/openjdk-21.0.2_macos-x64_bin.tar.gz"
    java_mac_checksum = "8fd09e15dc406387a0aba70bf5d99692874e999bf9cd9208b452b5d76ac922d3"
    
    java_linux_url = "https://download.java.net/java/GA/jdk21.0.2/f2283984656d49d69e91c558476027ac/13/GPL/openjdk-21.0.2_linux-x64_bin.tar.gz"
    java_linux_checksum = "a2def047a73941e01a73739f92755f86b895811afb1f91243db214cff5bdac3f"
}


group = "fll"

java {
    // set version of Java that the source confirms to. 
    // The bytecode will be for this version of Java as well, unless targetCompatibility is specified.
    sourceCompatibility = JavaVersion.VERSION_21
}

configurations {
    all*.exclude(group: "xml-apis", module: "xmlParserAPIs")
    all*.exclude(group: "xml-apis", module: "xml-apis")
}

dependencies {
  implementation(group: "org.apache.tomcat.embed", name: "tomcat-embed-core", version: project.tomcat_version)
  implementation(group: "org.apache.tomcat.embed", name: "tomcat-embed-jasper", version: project.tomcat_version)
  implementation(group: "org.apache.tomcat.embed", name: "tomcat-embed-websocket", version: project.tomcat_version)
  implementation(group: "org.apache.tomcat", name: "tomcat-jasper", version: project.tomcat_version)
  implementation(group: "org.apache.tomcat", name: "tomcat-jasper-el", version: project.tomcat_version)
  implementation(group: "org.apache.tomcat", name: "tomcat-jsp-api", version: project.tomcat_version)
  
  // use explicit reference to servlet api to ensure that all libraries that depend on it are up to the current version
  implementation(group: "jakarta.servlet", name: "jakarta.servlet-api", version: "6.0.0")
  
  implementation(group: "jakarta.servlet.jsp.jstl", name: "jakarta.servlet.jsp.jstl-api", version: "3.0.0")
  implementation(group: "org.glassfish.web", name: "jakarta.servlet.jsp.jstl", version: "3.0.1")
  
  // JSP tags for formatting java.time objects
  implementation(group: "net.sargue", name: "java-time-jsptags", version: "2.0.2")

  implementation(group: "org.apache.commons", name: "commons-lang3", version: "3.14.0")
  implementation(group: "commons-cli", name: "commons-cli", version: "1.6.0")
  implementation(group: "org.hsqldb", name: "hsqldb", version: "2.7.2")
  implementation(group: "org.apache.commons", name: "commons-collections4", version: "4.4")
    
  runtimeOnly(group: "org.apache.logging.log4j", name: "log4j-slf4j2-impl", version: project.log4j_version)
  runtimeOnly(group: "org.apache.logging.log4j", name: "log4j-jcl", version: project.log4j_version)
  implementation(group: "org.apache.logging.log4j", name: "log4j-api", version: project.log4j_version)
  implementation(group: "org.apache.logging.log4j", name: "log4j-core", version: project.log4j_version)
  implementation(group: "org.apache.logging.log4j", name: "log4j-web", version: project.log4j_version)
    
  implementation(group: "org.slf4j", name: "slf4j-api", version: project.slf4j_version)
    
  implementation(group: "org.apache.poi", name: "poi-ooxml", version: "5.2.5") {
    // xml APIs are part of the JDK
    exclude(group: "xml-apis", module: "xml-apis")
    exclude(group: "xml-apis", module: "xml-apis-ext")
  }
    
  implementation(group: "com.github.spotbugs", name: "spotbugs-annotations", version: project.spotbugs_version)
  compileOnly(group: "com.google.code.findbugs", name: "jsr305", version: "3.0.2")
    
  implementation(group: "com.fasterxml.jackson.core", name: "jackson-databind", version: project.jackson_version)
  implementation(group: "com.fasterxml.jackson.core", name: "jackson-annotations", version: project.jackson_version)
  implementation(group: "com.fasterxml.jackson.datatype", name: "jackson-datatype-jdk8", version: project.jackson_version)
  implementation(group: "com.fasterxml.jackson.datatype", name: "jackson-datatype-jsr310", version: project.jackson_version)

  implementation(group: "net.sourceforge.schemaspy", name: "schemaspy", version: "5.0.0")
            
  implementation(group: "dnsjava", name: "dnsjava", version: "3.5.3")
       
  implementation(group: "org.apache.tika", name: "tika-core", version: "2.9.2")
    
  implementation(group: "com.diffplug.durian", name: "durian-core", version: "1.2.0")
        
  implementation(group: "it.sauronsoftware", name: "junique", version: "1.0.5")
            
  implementation(group: "com.googlecode.log4jdbc", name: "log4jdbc", version: "1.2")
    
  implementation(group: "net.java.linoleum", name: "jlfgr", version: "1_0")
        
  implementation(group: "com.opencsv", name: "opencsv", version: "5.9")
    
  implementation(group: "net.mtu.eggplant", name: "JonsInfra", version: "3.2.0"   )
    
  implementation(group: "com.google.guava", name: "guava", version: "31.1-jre")
    
  implementation(group: "org.apache.xmlgraphics", name: "fop", version: "2.9") {
    // only needed for BMP and TIFF formats
    exclude(group: "com.sun.media", module: "jai-codec")
    
    // references old version of the servlet API
    exclude(group: "javax.servlet", module: "servlet-api")
    exclude(group: "jakarta.servlet", module: "jakarta.servlet-api")
    
    // xml APIs are part of the JDK
    exclude(group: "xml-apis", module: "xml-apis")
    // needed for org.w3c.dom.svg.SVGDocument with FOP 2.9 and JDK 17 exclude(group: "xml-apis", module: "xml-apis-ext")    
  }
  
  implementation(group: "org.checkerframework", name: "checker-qual", version: project.checker_framework_version)
  implementation(group: "org.checkerframework", name: "checker-util", version: project.checker_framework_version)
  checkerFramework(group: "org.checkerframework", name: "checker", version: project.checker_framework_version)
    
  implementation(group: "org.apache.pdfbox", name: "pdfbox", version: "3.0.2")
  
  // for templating reports
  implementation(group: "org.apache.velocity", name: "velocity-engine-core", version: "2.3")
  
  testImplementation(group: "org.junit.jupiter", name: "junit-jupiter-api", version: project.junit_version)
  testImplementation(group: "org.junit.jupiter", name: "junit-jupiter-params", version: project.junit_version)
  testRuntimeOnly(group: "org.junit.jupiter", name: "junit-jupiter-engine", version: project.junit_version)
    
  testImplementation(group: "org.hamcrest", name: "hamcrest", version: "2.2")
    
  // allow integration tests to reference code in the test directory
  integrationTestImplementation(sourceSets.test.output)
        
  integrationTestImplementation(group: "org.easytesting", name: "fest-swing", version: "1.2.1")
  integrationTestImplementation(group: "net.sourceforge.htmlunit", name: "htmlunit", version: "2.70.0") {
      
    // xml APIs are part of the JDK
    exclude(group: "xml-apis", module: "xml-apis")
  }
  integrationTestImplementation(group: "org.seleniumhq.selenium", name: "selenium-java", version: "4.26.0")
  integrationTestImplementation(group: "io.github.bonigarcia", name: "webdrivermanager", version: "5.9.2")
  
  // make selenium log to log4j
  integrationTestImplementation(group: "org.apache.logging.log4j", name: "log4j-jul", version: project.log4j_version)
      
}

tasks.withType(Tar){
    compression = Compression.GZIP
    archiveExtension = "tar.gz"
}

javadoc {
    failOnError = false
    options.addStringOption("Xmaxwarns", "10000")
    // turn off warnings about missing javadoc comments because javadoc complains about private variables on serializable classes. Let checkstyle catch these.
    // Using addBooleanOption due to bug https://github.com/gradle/gradle/issues/2354
    options.addBooleanOption("Xdoclint:all,-missing", true)
}

compileJava {
    options.compilerArgs << "-Xmaxwarns" << "10000"
}

tasks.register("distributionDependencies") {
    doFirst {
      println("Distribution dependencies")
    }
}
distTar.dependsOn(distributionDependencies)
distZip.dependsOn(distributionDependencies)
installDist.dependsOn(distributionDependencies)

// copy webapp files
tasks.register("copyWeb", Copy) {
  from("src/main/web")
  into(project.web_build_dir)
}
distributionDependencies.dependsOn(copyWeb)
integrationTest.dependsOn(copyWeb)

// Configure the distribution plugin instead of using the application plugin so that
// the web application classes stay outside of a jar file and Tomcat will properly
// process the annotations. For some reason Tomcat won't process the annotations
// inside of a jar file.
def baseDistribution = copySpec {
    from("src/main/root-docs/")
    
    from(sourceSets.main.output) {
        into "classes"
    }
    from(configurations.runtimeClasspath) {
        into "lib"
    }
        
    // web elements
    from(project.web_build_dir) {
        into "web"
        exclude "**/WEB-INF/flldb*"
    }
    
    // documentation
    from(project.documentation_build_dir) {
        into "web/documentation"
    }
    from(javadoc) {
        into "web/documentation/api"
    }
    from("$buildDir/reports/tests/") {
        into "web/documentation/reports"
    }
    from("$buildDir/reports/spotbugs/") {
    //from(spotbugsIntegrationTestHtmlReport.outputFile) {
        into "web/documentation/reports/spotbugs"
    }
    from("$buildDir/reports/checkstyle/") {
        into "web/documentation/reports/checkstyle"
    }
    from("$buildDir/reports/jacoco/test/html") {
        into "web/documentation/reports/coverage"
    }
}
// make sure that the launch script has Unix line endings
def launchScriptDist = copySpec {
    from("src/main/launch-script/")
    filter(FixCrLfFilter.class, eol:FixCrLfFilter.CrLf.newInstance("lf"))
}

distributions {
    main {
        contents {            
            with(baseDistribution)
            with(launchScriptDist)
            from(createExe.dest)
        }
    }
}

// create run task since we aren't using the application plugin
tasks.register("run", JavaExec) {
    dependsOn(copyWeb)
    dependsOn(classes)
    
    classpath = sourceSets.main.runtimeClasspath
        
    mainClass = project.mainClassName
    
    jvmArgs = [
        // Add the JAVA 9 specific start-up parameters required by Tomcat
        "--add-opens=java.base/java.lang=ALL-UNNAMED",
        "--add-opens=java.base/java.io=ALL-UNNAMED",
        "--add-opens=java.base/java.util=ALL-UNNAMED",
        "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
        "--add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED"
    ]
    
}


// convert markdown documentation and copy non-markdown documentation
markdownToHtml {
        sourceDir = file("src/main/documentation")
        outputDir = project.documentation_build_dir
        autoLinks = true
        fencedCodeBlocks = true
        definitionLists = true
        tables = true   
}
distributionDependencies.dependsOn(markdownToHtml)


// write log4j config for JspC
tasks.register("writeJspcProperties", WriteProperties) {
    destinationFile = new File(project.buildDir, "log4j.jspc.properties")
    property("log4j.rootLogger", "WARN, jspout")
    property("log4j.logger.org.apache", "INFO, jspout")
    property("log4j.appender.jspout", "org.apache.log4j.ConsoleAppender")
    property("log4j.appender.jspout.target", "System.out")
    property("log4j.appender.jspout.layout", "org.apache.log4j.PatternLayout")
    property("log4j.appender.jspout.layout.ConversionPattern", "%d [%C] %m%n")
}

// call JspC to test compile the JSP files
// the output isn't used other than to check if there are errors in the build
tasks.register("jspToJava", JavaExec) {
    dependsOn(compileJava)
    dependsOn(writeJspcProperties)

    group = "Build"
    description = "Convert JSP files to Java"

    inputs.dir(jspSrc)
    outputs.dir(jspJavaSrc)

    File xmlPartial = file("$jspJavaSrc/WEB-INF/web.xml.partial")

    doFirst {
        // Create the target WEB-INF folder so the JspC can create the web.xml.partial
        File webInfFolder = xmlPartial.getParentFile()
        if (!webInfFolder.exists()) {
            webInfFolder.mkdirs()
        }
    }

    classpath = configurations.jspc + sourceSets.main.runtimeClasspath
    mainClass = "org.apache.jasper.JspC"
    jvmArgs = ["-Dlog4j2.configurationFile=$buildDir/log4j.jspc.properties"] //, "-Dlog4j.debug"] 

    args "-webapp", jspSrc,
            "-d", jspJavaSrc,
            "-p", jspPackage,
            "-webxmlencoding", "UTF-8",
            "-webinc", xmlPartial.absolutePath

    doLast {
        // Merge the partial XML with the original
        String originalXML = file("$jspSrc/WEB-INF/web.xml").text
        String xmlToMerge = xmlPartial.text
        String mergedXML = originalXML.replaceFirst("(?s)(<web-app.*?>)", "\$1" + xmlToMerge)
        file("$jspJavaSrc/WEB-INF/web.xml").text = mergedXML
    }
}

tasks.register("jspToClasses", JavaCompile) {
    dependsOn(jspToJava)
    
    group = "Build"
    description = "Test compile JSP files"

    source(jspJavaSrc)
    destinationDirectory = jspJavaClasses

    classpath = configurations.jspc + sourceSets.main.runtimeClasspath
    
    checkerFramework {
      skipCheckerFramework = true
    }
}
check.dependsOn(jspToClasses)
run.dependsOn(jspToClasses)
assemble.dependsOn(jspToClasses)


cpdCheck {
    // allow the build to continue, catch this in CI as warnings
    ignoreFailures = true

    // default of 50 seems low and is finding sections that don't make sense to collapse
    minimumTokenCount = 100
}

tasks.register("sloccount", Exec) {
    group = "Documentation"
    description = "Count number of lines of code"

    commandLine("cloc", 
    "--by-file",
    "--exclude-dir", "extlib", 
    "--xml", 
    "--out", "$buildDir/reports/sloccount/cloc.xml", 
    "src")
}

tasks.register("renderWorkflows") {
    dependsOn(markdownToHtml)

    group = "Documentation"
    description = "Render workflows as PDFs"

    def inputFiles = []
    def outputFiles = []
    def ioMap = [:]

    fileTree("src/main/documentation/workflows").matching{include "**/*.dot"}.visit{FileVisitDetails details ->
        if(!details.directory) {
            def inFile = details.file.path
            def outFile = project.documentation_build_dir.path + "/workflows/" + details.file.name + ".pdf"
            inputFiles << inFile
            outputFiles << outFile
            ioMap.put(inFile, outFile)
        }
    }
    
    inputs.files(inputFiles)
    outputs.files(outputFiles)
    
    doLast {
      ioMap.each{ inFile, outFile ->
                        exec{
          commandLine("dot", "-Tpdf", "-o", outFile, inFile)
                        }
      }
    }
}
distributionDependencies.dependsOn(renderWorkflows)

tasks.register("createDatabaseDiagram", JavaExec) {
    dependsOn(markdownToHtml)
    
    group = "Documentation"
    description = "Creates a diagram of the database"
    
    classpath = sourceSets.main.runtimeClasspath
    
    mainClass = "fll.db.GenerateDatabaseDiagram"
    args (new File(project.documentation_build_dir, "database-diagram").absolutePath)
}
distributionDependencies.dependsOn(createDatabaseDiagram)

createExe {
    mainClassName = project.mainClassName
    icon = "${projectDir}/src/main/resources/fll/resources/fll-sw.ico"
    
    dontWrapJar = true
    errTitle = "FLL-SW"
    classpath = ["%EXEDIR%/classes", "%EXEDIR%/lib/*.jar"]
    
    maxHeapPercent = 75        
    
    fileDescription = "FIRST Lego League Scoring Software"
    productName = "FLL-SW"
    copyright = "GPL"
    
    bundledJrePath = "jdk"
    requires64Bit = true

    // for debugging classpath information        
    //headerType = "console"
    jvmOptions = [
    //"-Dlog4j2.debug=true",
    
    // Add the JAVA 9 specific start-up parameters required by Tomcat
    "--add-opens=java.base/java.lang=ALL-UNNAMED",
    "--add-opens=java.base/java.io=ALL-UNNAMED",
    "--add-opens=java.base/java.util=ALL-UNNAMED",
    "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
    "--add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED"
    ]
}
distributionDependencies.dependsOn(createExe)


configurations {
    spotbugsStylesheets { transitive = false }
}

dependencies {
  spotbugsStylesheets("com.github.spotbugs:spotbugs:$project.spotbugs_version")
}

spotbugs {
    toolVersion = project.spotbugs_version
    
    // allow the build to continue, catch this in CI as warnings
    ignoreFailures = true
    effort = com.github.spotbugs.snom.Effort.valueOf("MAX")
    reportLevel = com.github.spotbugs.snom.Confidence.valueOf("LOW")
    excludeFilter = file("spotbugs-filters.xml")
}

tasks.withType(com.github.spotbugs.snom.SpotBugsTask) {
  reports {
    xml {
      enabled = true
    }
    html {
      enabled = true
    }
  }
}

tasks.register("writeVersion", WriteProperties) {
    destinationFile = file("${buildDir}/resources/main/fll/resources/git.properties")
    property("git.build.version", project.version)

    def gitBranchName
    if(System.getenv("JOB_NAME")) {
        // Jenkins
        if(!gitBranchName) {
            gitBranchName = System.getenv("GIT_LOCAL_BRANCH")
        }
        if(!gitBranchName) {
            gitBranchName = System.getenv("GIT_BRANCH")
        }
        if(!gitBranchName) {
            gitBranchName = System.getenv("BRANCH_NAME")
        }
    }

    if(!gitBranchName){
        // use command if needed
        def gitVersion = providers.exec {
            commandLine("git", "rev-parse", "--abbrev-ref", "HEAD")
        }.standardOutput.asText.get().trim()
        gitBranchName = gitVersion
    }
    
    property("git.branch", gitBranchName)
}
classes.dependsOn(writeVersion)

tasks.register("writeLaunchJar", Jar) {
    destinationDirectory = project.buildDir
    archiveFileName = "fll-sw.jar"
    manifest {
        attributes(
        "Implementation-Title": project.name,
        "Implementation-Version": archiveVersion,
        "Main-Class": project.mainClassName,
        "Class-Path": "classes/\n " + configurations.runtimeClasspath.collect { "lib/" + it.getName() }.join(" \n "))
    }
}
distributionDependencies.dependsOn(writeLaunchJar)

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


// start Windows distribution tasks   
distributions {
    windows {
        contents {
            with(baseDistribution)
            from("$buildDir/bundled-java/windows/")
            from(createExe.dest)
        }        
    }
}

tasks.register("windowsDistributionDependencies") {
    doLast {
      println("Windows distribution dependencies")
    }
}
windowsDistributionDependencies.dependsOn(distributionDependencies)
windowsDistTar.dependsOn(windowsDistributionDependencies)
windowsDistZip.dependsOn(windowsDistributionDependencies)
  installWindowsDist.dependsOn(windowsDistributionDependencies)

tasks.register("downloadJavaWindows", Download) {
    src(project.java_windows_url)
    dest(project.java_download_base.resolve("windows-java.zip").toFile())
    overwrite(false)
}
tasks.register("verifyJavaWindows", Verify) {
    dependsOn(downloadJavaWindows)

    src(downloadJavaWindows.dest)
    algorithm("SHA-256")
    checksum(project.java_windows_checksum)
}
tasks.register("uncompressJavaWindows", Copy) {
    def basePath = project.java_download_base.resolve("windows")

    dependsOn(verifyJavaWindows)    
    from(zipTree(downloadJavaWindows.dest))
    into(basePath)
    
    doLast {
        // there is always 1 directory at the top
        def toMove = java.nio.file.Files.newDirectoryStream(basePath).iterator().next()
        java.nio.file.Files.move(toMove, basePath.resolve("jdk"))
    }        
} 
uncompressJavaWindows.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree(project.java_download_base.resolve("windows")) {
        include "**/bin/server/classes.jsa"
          })
}
windowsDistributionDependencies.dependsOn(uncompressJavaWindows)


installWindowsDist.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree("$buildDir/install/windows") {
        include "**/bin/server/classes.jsa"
          })
}
// end Windows distribution tasks

// start Linux distribution tasks
distributions {
    linux {
        contents {
            with(baseDistribution)
            with(launchScriptDist)
            from("$buildDir/bundled-java/linux/")
            from(createExe.dest)
        }        
    }
}

tasks.register("linuxDistributionDependencies") {
    doFirst {
        println("Linux distribution dependencies")
    }
}
linuxDistributionDependencies.dependsOn(distributionDependencies)
linuxDistTar.dependsOn(linuxDistributionDependencies)
linuxDistZip.dependsOn(linuxDistributionDependencies)
installLinuxDist.dependsOn(linuxDistributionDependencies)

tasks.register("downloadJavaLinux", Download) {
    src(project.java_linux_url)
    dest(project.java_download_base.resolve("linux-java.tar.gz").toFile())
    overwrite(false)
}
tasks.register("verifyJavaLinux", Verify) {
    dependsOn(downloadJavaLinux)
    src(downloadJavaLinux.dest)
    algorithm("SHA-256")
    checksum(project.java_linux_checksum)
}
tasks.register("uncompressJavaLinux", Copy) {
    def basePath = project.java_download_base.resolve("linux")
    dependsOn(verifyJavaLinux)    
    from(tarTree(downloadJavaLinux.dest))
    into(basePath)
    
    doLast {
        // there is always 1 directory at the top
        def toMove = java.nio.file.Files.newDirectoryStream(basePath).iterator().next()
        java.nio.file.Files.move(toMove, basePath.resolve("jdk"))
    }    
} 
uncompressJavaLinux.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree(project.java_download_base.resolve("linux")) {
        include "**/lib/server/classes.jsa"
        include "**/legal/**"
          })
}
linuxDistributionDependencies.dependsOn(uncompressJavaLinux)


installLinuxDist.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree("$buildDir/install/linux") {
        include "**/lib/server/classes.jsa"
        include "**/legal/**"
          })
}
// end Linux distribution tasks


// start Mac distribution tasks
distributions {
    mac {
        contents {
            with(baseDistribution)
            with(launchScriptDist)
            from("$buildDir/bundled-java/mac/")
            from(createExe.dest)
        }        
    }
}

tasks.register("macDistributionDependencies") {
    doFirst {
      println("Mac distribution dependencies")
    }
}
macDistributionDependencies.dependsOn(distributionDependencies)
macDistTar.dependsOn(macDistributionDependencies)
macDistZip.dependsOn(macDistributionDependencies)
installMacDist.dependsOn(macDistributionDependencies)

tasks.register("downloadJavaMac", Download) {
    src(project.java_mac_url)
    dest(project.java_download_base.resolve("mac-java.tar.gz").toFile())
    overwrite(false)
}
tasks.register("verifyJavaMac", Verify) {
    dependsOn(downloadJavaMac)
    src(downloadJavaMac.dest)
    algorithm("SHA-256")
    checksum(project.java_mac_checksum)
}
tasks.register("uncompressJavaMac", Copy) {
    def basePath = project.java_download_base.resolve("mac") 
    dependsOn(verifyJavaMac)      
    from(tarTree(downloadJavaMac.dest))
    into(basePath)
    
    doLast {
        // there is always 1 directory at the top
        def toMove = java.nio.file.Files.newDirectoryStream(basePath).iterator().next()
        java.nio.file.Files.move(toMove, basePath.resolve("jdk"))
    }
} 
uncompressJavaMac.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree(project.java_download_base.resolve("mac")) {
        include "**/lib/server/classes.jsa"
        include "**/legal/**"
          })
}
macDistributionDependencies.dependsOn(uncompressJavaMac)


installMacDist.doFirst {
    // Need to remove read-only file from JDK release
  delete(fileTree("$buildDir/install/mac") {
        include "**/lib/server/classes.jsa"
        include "**/legal/**"
          })
}
// end Mac distribution tasks


checkstyle {
    configDirectory = file("$projectDir")
    configFile = file("checkstyle.xml")
    showViolations = true
    ignoreFailures = true
    toolVersion = "10.3.1"
}

checkerFramework {
    checkers = [
        "org.checkerframework.checker.nullness.NullnessChecker"
    ]
    extraJavacArgs = [
        //"-AonlyDefs=^fll\\.(db|documents|flltools|scheduler|subjective|tomcat|util|web|xml)",
        //"-Awarns",  
        "-Xmaxwarns", "10000",
        "-Xmaxerrs", "10000",
        "-AstubWarnIfNotFound",
        "-Astubs=$projectDir/stubs"
        //,"-AstubDebug"
    ]
    
    excludeTests = true
}

def checker_dir = file("./checker/checker-framework")
if (checker_dir.exists()) {
    println("Using development version of checker in: " + checker_dir)
    
    dependencies {
        compileOnly(files(file(checker_dir.toPath().resolve("checker/dist/checker-qual.jar"))))
        compileOnly(files(file(checker_dir.toPath().resolve("checker/dist/checker-util.jar"))))
        checkerFramework(files(file(checker_dir.toPath().resolve("checker/dist/checker.jar"))))
    }
}



jacocoTestReport {
    // make sure to get both test and integrationt test
    executionData tasks.withType(Test)

    reports {
        xml.required=true
    }
}