build.gradle

plugins {
    id("application")
    id("java-library")
    id("maven-publish")
    id("signing")
    id("com.diffplug.spotless").version("6.25.0")
    id("org.checkerframework").version("0.6.49")
    id("net.ltgt.errorprone").version("4.1.0")
    id("com.adarshr.test-logger").version("4.0.0")
}

repositories {
    // Use Maven Central for resolving dependencies.
    mavenCentral()
    mavenLocal()
}

application {
    mainClass = "org.checkerframework.specimin.SpeciminRunner"
}

dependencies {

    implementation("com.github.javaparser:javaparser-symbol-solver-core:3.27.1")

    implementation("net.sf.jopt-simple:jopt-simple:5.0.4")

    implementation("org.vineflower:vineflower:1.11.0")

    implementation("commons-io:commons-io:2.21.0")

    // Use JUnit test framework.
    testImplementation("junit:junit:4.13.2")

    errorprone("com.google.errorprone:error_prone_core:2.35.1")
}

// Use require-javadoc. From https://github.com/plume-lib/require-javadoc.
configurations {
    requireJavadoc
}
dependencies {
    requireJavadoc("org.plumelib:require-javadoc:2.0.0")
}
tasks.register("requireJavadoc", JavaExec) {
    group = "Documentation"
    description = "Ensures that Javadoc documentation exists."
    mainClass = "org.plumelib.javadoc.RequireJavadoc"
    classpath = configurations.requireJavadoc
    args("src/main/java")
    jvmArgs += [
            '--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED',
            '--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
            '--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
            '--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
    ]
}

tasks.register("expectedTestOutputsMustCompile", Exec) {
    if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
        commandLine("cmd", "/c", "typecheck_test_outputs.bat")
    } else {
        commandLine("sh", "typecheck_test_outputs.sh")
    }
}

// run via e.g.: ./gradlew checkExpectedOutputCompilesFor -PtestName="onefilesimple"
tasks.register("checkExpectedOutputCompilesFor", Exec) {
    if (project.hasProperty("testName")) {
        workingDir("src/test/resources")
        if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
            // Avoid("..") is not a command error
            def scriptPath = file("typecheck_one_test.bat").absolutePath
            commandLine("cmd", "/c", scriptPath, project.property("testName"))
        } else {
            commandLine("sh", "../../../typecheck_one_test.sh", project.property("testName"))
        }
    }
}

tasks.compileJava {
    // uncomment for testing
    // options.errorprone.enabled = false
    options.errorprone.disable(
            // JavaParser's visitor design requires us to regularly violate this rule
            "VoidUsed",
            // Specimin should compile with Java 11, but this suggestion assumes Java 17
            "PatternMatchingInstanceof")
}

tasks.compileTestJava {
    options.errorprone.enabled = false
}

checkerFramework {
    // uncomment for testing
    // skipCheckerFramework = true
    checkers = [
            "org.checkerframework.checker.nullness.NullnessChecker",
            "org.checkerframework.checker.resourceleak.ResourceLeakChecker",
            "org.checkerframework.checker.interning.InterningChecker",
            "org.checkerframework.checker.signature.SignatureChecker"
    ]
    excludeTests = true

    extraJavacArgs = [
            "-Astubs=${projectDir}/JavaParser.astub"
    ]
}

spotless {
    // optional: limit format enforcement to just the files changed by this feature branch
    ratchetFrom("origin/main")

    format "misc", {
        // define the files to apply `misc` to
        target("*.gradle", "*.md", ".gitignore")

        // define the steps to apply to those files
        trimTrailingWhitespace()
        indentWithSpaces()
        endWithNewline()
    }
    java {
        googleJavaFormat().reflowLongStrings()
        formatAnnotations()
    }
}

compileJava {
    options.compilerArgs += ["-Werror"]
}

jar {
    manifest {
        attributes "Main-Class": "org.checkerframework.specimin.SpeciminRunner"
    }
    duplicatesStrategy = "exclude"
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
}

compileJava.dependsOn("spotlessApply")
check.dependsOn(requireJavadoc)

java {
    withJavadocJar()
    withSourcesJar()
}

// Run `./gradlew publishToMavenLocal` to publish Specimin to your local Maven repository.
publishing {
    publications {
        maven(MavenPublication) {
            groupId = "edu.njit.jerse"
            artifactId = "specimin"
            version = "0.1"

            from(components.java)
        }
    }
}

javadoc {
    if(JavaVersion.current().isJava9Compatible()) {
        options.addBooleanOption("html5", true)
    }
}

tasks.withType(Test).configureEach {
    // Creates half as many forks as there are CPU cores.
    maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
}

test {
    testLogging {
        showStandardStreams = true
    }
}

// Avoids "symbol not found" errors in builds immediately after cleaning.
// Not 100% sure why. One theory: test data would otherwise be treated as
// code by Gradle?
sourceSets {
    test {
        java.srcDirs = ["src/main/java/", "src/test/java/"]
    }
}