build.gradle

plugins {
  id("java")
  id("application")

  // To create a fat jar build/libs/...-all.jar, run: ./gradlew shadowJar
  alias(libs.plugins.com.gradleup.shadow)

  // Code formatting; defines targets "spotlessApply" and "spotlessCheck"
  alias(libs.plugins.com.diffplug.spotless)

  // Error Prone linter
  alias(libs.plugins.net.ltgt.errorprone) apply false

  // PMD linter
  id("pmd")

  // code coverage
  id("jacoco")

  // Checker Framework pluggable type-checking
  alias(libs.plugins.org.checkerframework)
}

repositories {
  mavenLocal()
  mavenCentral()
  maven { url = "https://central.sonatype.com/repository/maven-snapshots/" }
  gradlePluginPortal()
}

dependencies {
  implementation(libs.tagsoup)
  implementation(libs.xom)

  testImplementation(libs.junit.jupiter)
  testRuntimeOnly(libs.junit.platform.launcher)
}

application {
  mainClass = "org.plumelib.htmlprettyprint.HtmlPrettyPrint"
}

java {
  toolchain {
    // Always compile using Java 21, but test using various Java versions.
    languageVersion = JavaLanguageVersion.of(21)
  }
}
tasks.withType(JavaCompile).configureEach {
  // Set the language level and byte code to 17.
  options.release = 17
}

test {
  useJUnitPlatform {
    includeEngines("junit-jupiter")
    excludeEngines("junit-vintage")
  }

  testLogging {
    outputs.upToDateWhen{false}
    showStandardStreams = true
    events("failed")
    exceptionFormat = "full"
  }
}

jacocoTestReport {
  reports {
    xml.required = false
    csv.required = true // Output is written to build/reports/jacoco/test/jacocoTestReport.csv
    html.required = true // Output is written to build/reports/jacoco/test/html/index.html
  }
}
// Two possible configurations:
// Configuration A: report is always generated after tests run.
test.finalizedBy(jacocoTestReport)
// Configuration B: user must run `jacocoTestReport` explicitly.
// jacocoTestReport.dependsOn(test)

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

    // define the steps to apply to those files
    trimTrailingWhitespace()
    leadingTabsToSpaces(2)
    endWithNewline()
  }
  java {
    targetExclude("**/WeakIdentityHashMap.java")
    googleJavaFormat()
    formatAnnotations()
  }
  groovyGradle {
    target("**/*.gradle")
    greclipse()  // which formatter Spotless should use to format .gradle files.
    leadingTabsToSpaces(2)
    trimTrailingWhitespace()
    // endWithNewline() // Don't want to end empty files with a newline
  }
}

// Error Prone linter

tasks.withType(JavaCompile).configureEach {
  options.forkOptions.jvmArgs += "-Xmx6g"
  options.compilerArgs << "-Werror"
  // "-processing" avoids javac warning "No processor claimed any of these annotations".
  options.compilerArgs << "-Xlint:all,-processing"
}
apply plugin: "net.ltgt.errorprone"
dependencies {
  errorprone(libs.error.prone.core)
}
tasks.withType(JavaCompile).configureEach {
  options.errorprone {
    disable("AnnotateFormatMethod") // Error Prone doesn't know about Checker Framework @FormatMethod.
    disable("DoNotCallSuggester") // Suggests use of an Error Prone annotation.
    disable("EffectivelyPrivate") // Loses information about the abstraction.
    disable("ExtendsObject")  // Incorrect when using the Checker Framework.
    disable("InlineMeSuggester") // Using `@InlineMe` requires clients to declare a dependency on error_prone_annotations.
    disable("ReferenceEquality") // Use Interning Checker instead.
  }
}


// PMD linter

pmd {
  toolVersion = "7.23.0"
  ruleSetFiles = files("${rootDir}/.pmd-ruleset.xml")
  consoleOutput = true
  ignoreFailures = false
  incrementalAnalysis = true
}
pmdTest.enabled = false


// Checker Framework pluggable type-checking

apply plugin: "org.checkerframework"

checkerFramework {
  version = libs.checker.framework.get().version
  checkers = [
    // No need to run CalledMethodsChecker, because ResourceLeakChecker does so.
    // "org.checkerframework.checker.calledmethods.CalledMethodsChecker",
    "org.checkerframework.checker.formatter.FormatterChecker",
    "org.checkerframework.checker.index.IndexChecker",
    "org.checkerframework.checker.interning.InterningChecker",
    "org.checkerframework.checker.lock.LockChecker",
    "org.checkerframework.checker.nullness.NullnessChecker",
    "org.checkerframework.checker.regex.RegexChecker",
    "org.checkerframework.checker.resourceleak.ResourceLeakChecker",
    "org.checkerframework.checker.signature.SignatureChecker",
    "org.checkerframework.checker.signedness.SignednessChecker",
    "org.checkerframework.common.initializedfields.InitializedFieldsChecker",
  ]
  extraJavacArgs = [
    "-Werror",
    // "-Aversion",
    // "-verbose",
    "-AcheckPurityAnnotations",
    "-ArequirePrefixInWarningSuppressions",
    "-AwarnRedundantAnnotations",
    "-AwarnUnneededSuppressions",
  ]
}


// Javadoc

tasks.withType(Javadoc) {
  options.noTimestamp = true
}
javadoc {
  // Turn Javadoc warnings into errors.
  options.addStringOption("Xwerror", "-Xdoclint:all")
  options.addStringOption("private", "-quiet")
  doLast {
    ant.replaceregexp(match:"@import url\\('resources/fonts/dejavu.css'\\);\\s*", replace:"",
    flags:"g", byline:true) {
      fileset(dir: destinationDir)
    }
  }
}
check.dependsOn(javadoc)

tasks.register("javadocWeb", Javadoc) {
  description = "Upload API documentation to website."
  dependsOn("javadocWebUpload", "javadocWebChgrp", "javadocWebChmod")
}
tasks.register("javadocWebUpload", Javadoc) {
  source = sourceSets.main.allJava
  destinationDir = file("/cse/web/research/plumelib/${project.name}/api")
  classpath = project.sourceSets.main.compileClasspath
  doLast {
    ant.replaceregexp(match:"@import url\\('resources/fonts/dejavu.css'\\);\\s*", replace:"",
    flags:"g", byline:true) {
      fileset(dir: destinationDir)
    }
  }
}
// Set permissions
tasks.register("javadocWebChgrp", Exec) {
  commandLine("chgrp", "-R",  "plse_www", "/cse/web/research/plumelib/${project.name}/api")
  ignoreExitValue = true
}
javadocWebChgrp.mustRunAfter("javadocWebUpload")
tasks.register("javadocWebChmod", Exec) {
  commandLine("chmod", "-R",  "g+w", "/cse/web/research/plumelib/${project.name}/api")
  ignoreExitValue = true
}
javadocWebChmod.mustRunAfter("javadocWebUpload")

configurations {
  requireJavadoc
}
dependencies {
  requireJavadoc(libs.require.javadoc)
}
def requireJavadoc = tasks.register("requireJavadoc", JavaExec) {
  group = "Documentation"
  description = "Ensures that Javadoc documentation exists."
  inputs.files(sourceSets.main.allJava)
  mainClass = "org.plumelib.javadoc.RequireJavadoc"
  classpath = configurations.requireJavadoc
  args(sourceSets.main.allJava.srcDirs.collect{it.getAbsolutePath()})
  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",
  ]
}
check.dependsOn(requireJavadoc)
javadocWeb.dependsOn(requireJavadoc)

tasks.register("updateUserOptions", Javadoc) {
  dependsOn("assemble")
  description = "Updates printed documentation of command-line arguments."
  source = sourceSets.main.allJava.files.sort()
  classpath = project.sourceSets.main.compileClasspath
  options.memberLevel = JavadocMemberLevel.PRIVATE
  options.docletpath = project.sourceSets.main.runtimeClasspath as List
  options.doclet = "org.plumelib.options.OptionsDoclet"
  options.addStringOption("docfile", "${projectDir}/src/main/java/org/plumelib/htmlprettyprint/HtmlPrettyPrint.java")
  options.addStringOption("format", "javadoc")
  options.addStringOption("i", "-quiet")
  options.noTimestamp(false)
  title = ""
}

// Emacs support

/* Make Emacs TAGS table */
tasks.register("tags", Exec) {
  description = "Run etags to create an Emacs TAGS table"
  commandLine("bash", "-c", "find src/ -name '*.java' | sort | xargs etags")
}