build.gradle

plugins {
    id 'java'
    id 'net.ltgt.errorprone' version '2.0.2'
}

ext {
    jsr308 = System.getenv('JSR308') ?: file(new File("..")).absolutePath
    cfPath = "${jsr308}/checker-framework"
    cfiPath = "${jsr308}/checker-framework-inference"
    afu = "${jsr308}/annotation-tools/annotation-file-utilities"
    universePath = "${jsr308}/universe"
    formatScripts = "${universePath}/scripts/.run-google-java-format"

    isJava8 = JavaVersion.current() == JavaVersion.VERSION_1_8
}

println '==================================='
println '         Universe Checker          '
println '==================================='
println ''
println '-------------------------------'
println 'Important Environment Variables'
println '-------------------------------'
println 'JSR308:   ' + jsr308
println 'CF:       ' + cfPath
println 'CFI:      ' + cfiPath
println 'UNIVERSE: ' + universePath

repositories {
    mavenCentral()
}

def framework_test_files = fileTree(dir: "${cfPath}/framework-test/build/libs", include: "framework-test-*.jar")
List<File> list_of_files = new ArrayList<>(framework_test_files.getFiles())
Collections.sort(list_of_files)
// pick the last element in the sorted list corresponding to the most recent framework-test-*.*.*.jar
def framework_test_jar = files(list_of_files[list_of_files.size()-1])

dependencies {
    implementation fileTree(dir: "${cfPath}/checker/dist", include: "checker.jar")
    implementation fileTree(dir: "${cfiPath}/dist", include: "checker-framework-inference.jar")
    implementation fileTree(dir: "${cfiPath}/dist", include: "inference-framework-test-lib.jar")
    implementation group: 'log4j', name: 'log4j', version: '1.2.17'
    implementation 'commons-logging:commons-logging:1.2'
    testImplementation framework_test_jar
    testImplementation 'junit:junit:4.13.2'

    errorprone 'com.google.errorprone:error_prone_core:2.10.0'
    errorproneJavac 'com.google.errorprone:javac:9+181-r4173-1'
}

sourceSets {
    main {
        java {
            srcDir "src/main/java"
        }

        resources {
            srcDir "src/main/java"
            exclude "**/*.java"
        }
    }

    test {
        java {
            srcDirs = ["src/test/java"]
        }
    }
}

// TODO: This doesn't work when nothing was built before
task cloneAndBuildDependencies(type: Exec) {
    description 'Clones (or updates) and builds all dependencies'
    executable './scripts/setup-deps.sh'
}

compileJava {
    options.compilerArgs = [
            '-implicit:class',
            '-Awarns',
            '-Xmaxwarns', '10000',
    ]
}

afterEvaluate {
    // Create a task for each JUnit test class whose name is the same as the JUnit class name.
    sourceSets.test.allJava.filter { it.path.contains("${universePath}/src/test/java") }.forEach { file ->
        String junitClassName = file.name.replaceAll(".java", "")
        String testName = junitClassName.replaceAll("Test", "")
        tasks.create(name: "${junitClassName}", type: Test) {
            description "Run ${testName} tests."
            include "**/${name}.class"
        }
    }

    // Configure JUnit tests
    tasks.withType(Test) {
        group 'Verification'

        systemProperties = [
                'path.afu.scripts' : "${afu}/scripts",
                'path.inference.script': "${cfiPath}/scripts/inference"
        ]

        environment "external_checker_classpath", "${universePath}/build/classes/java/main:${universePath}/build/libs/universe.jar"


        if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
            jvmArgs "-Xbootclasspath/p:${cfiPath}/dist/javac.jar"
        }

        testLogging {
            // Always run the tests
            outputs.upToDateWhen { false }
            // The following prints out each time a test is passed.
            events "passed", "skipped", "failed", "standardOut", "standardError"

            // Show the found unexpected diagnostics and expected diagnostics not found.
            exceptionFormat "full"
            showExceptions true
            showCauses true
            showStackTraces true
            showStandardStreams true
        }

        // After each test, print a summary.
        afterSuite { desc, result ->
            if (desc.getClassName() != null) {
                long mils = result.getEndTime() - result.getStartTime()
                double seconds = mils / 1000.0

                println "Testsuite: ${desc.getClassName()}\n" +
                        "Tests run: ${result.testCount}, " +
                        "Failures: ${result.failedTestCount}, " +
                        "Skipped: ${result.skippedTestCount}, " +
                        "Time elapsed: ${seconds} sec\n"
            }
        }
    }
}

tasks.clean {
    delete 'bin', 'dist', 'testTmp', 'testdata/tmp',
            fileTree('.') { include '**/*.jaif', '**/*.txt' },
            fileTree('tests') { include '**/*.class' }
}


task getCodeFormatScripts() {
    description 'Obtain or update the run-google-java-format scripts'
    if (file(formatScripts).exists()) {
        exec {
            workingDir formatScripts
            executable 'git'
            args = ['pull', '-q']
            ignoreExitValue = true
        }
    } else {
        exec {
            workingDir "${formatScripts}/../"
            executable 'git'
            args = ['clone', '-q', '--depth', '1', 'https://github.com/eisop-plume-lib/run-google-java-format.git', '.run-google-java-format']
        }
    }
}

task pythonIsInstalled(type: Exec) {
    description "Check that the python3 executable is installed."
    executable = "python3"
    args "--version"
}

/**
 * Returns a list of all the Java files that should be formatted for the given project.
 *
 * @return a list of all Java files that should be formatted for projectName
 */
List<String> getJavaFilesToFormat() {
    List<File> javaFiles = new ArrayList<>();
    sourceSets.forEach { set ->
        javaFiles.addAll(set.allSource.files)
    }
    List<String> args = new ArrayList<>();
    for (File f : javaFiles) {
        if (f.name.endsWith('java')) {
            args += f.absolutePath
        }
    }
    return args
}

task checkFormat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], group: 'Format') {
    description 'Check whether the source code is properly formatted'
    executable 'python3'
    doFirst {
        if (isJava8) {
            println 'The checkFormat task cannot be run on Java 8.  Please use Java 11+.'
            return
        }
        args += "${formatScripts}/check-google-java-format.py"
        args += "--aosp" // 4 space indentation
        args += getJavaFilesToFormat()
    }
    ignoreExitValue = true
    doLast {
        if (!executionResult.isPresent() || executionResult.get().exitValue != 0) {
            throw new RuntimeException('Found improper formatting, try running:  ./gradlew reformat"')
        }
    }
}

task reformat(type: Exec, dependsOn: [getCodeFormatScripts, pythonIsInstalled], group: 'Format') {
    description 'Format the Java source code'
    executable 'python3'
    doFirst {
        if (isJava8) {
            println 'The reformat task cannot be run on Java 8.  Please use Java 11+.'
            return
        }
        args += "${formatScripts}/run-google-java-format.py"
        args += "--aosp" // 4 space indentation
        args += getJavaFilesToFormat()
    }
}

tasks.test.dependsOn 'checkFormat'