build.gradle

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

  // To create a fat jar build/libs/...-all.jar, run: ./gradlew shadowJar
  id("com.gradleup.shadow").version("9.4.1")

  // Code formatting; defines targets "spotlessApply" and "spotlessCheck"
  // Version 8.0.0 and later requires Java 17+.
  id("com.diffplug.spotless").version("8.4.0")

  // Error Prone linter
  id("net.ltgt.errorprone").version("5.1.0") apply false

  // PMD linter
  id("pmd")

  // code coverage
  id("jacoco")

  // Checker Framework pluggable type-checking
  id("org.checkerframework").version("1.0.2")

  // To show task list as a tree, run: ./gradlew <taskname> taskTree
  id("com.dorongold.task-tree").version("4.0.1")
}

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

ext {
  errorproneVersion = "2.49.0"
  eisopVersion = "3.49.3-eisop1"
  isJava17orHigher = JavaVersion.current() >= JavaVersion.VERSION_17
  isJava21orHigher = JavaVersion.current() >= JavaVersion.VERSION_21
}

dependencies {
  implementation("org.plumelib:plume-util:1.14.0")

  testImplementation("org.junit.jupiter:junit-jupiter:6.0.3")
  testRuntimeOnly("org.junit.platform:junit-platform-launcher")

  // EISOP Checker Framework dependencies
  checkerQual("io.github.eisop:checker-qual:${eisopVersion}")
  checkerFramework("io.github.eisop:checker:${eisopVersion}")
}

application {
  mainClass = "org.plumelib.bibtex.BibtexClean"
}

java {
  sourceCompatibility = JavaVersion.VERSION_1_8
  targetCompatibility = JavaVersion.VERSION_1_8
}

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" is because of JDK 21 warning "source value 8 is obsolete..."
  if (isJava21orHigher) {
    options.compilerArgs << "-Xlint:all,-options,-processing,-this-escape"
  } else {
    options.compilerArgs << "-Xlint:all,-options,-processing"
  }
}
if (isJava21orHigher) {
  apply plugin: "net.ltgt.errorprone"
  dependencies {
    errorprone("com.google.errorprone:error_prone_core:${errorproneVersion}")
  }
  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("PatternMatchingInstanceof") // requires Java 16 or later
      disable("ReferenceEquality") // Use Interning Checker instead.
      disable("StatementSwitchToExpressionSwitch") // requires Java 12 or later
      disable("StringConcatToTextBlock") // requires Java 15 or later
    }
  }
}


// PMD linter

pmd {
  toolVersion = "7.24.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 = "dependencies"
  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 = [
    // No "'-Werror'" because of JDK 21 warning "source value 8 is obsolete..."
    // "-Werror",
    // "-Aversion",
    // "-verbose",
    "-AcheckPurityAnnotations",
    "-ArequirePrefixInWarningSuppressions",
    "-AwarnRedundantAnnotations",
    "-AwarnUnneededSuppressions",
  ]
}


// Javadoc

tasks.withType(Javadoc) {
  options.noTimestamp = true
}
javadoc {
  // No "'-Werror'" because of JDK 21 warning "source value 8 is obsolete..."
  // options.addStringOption("Xwerror", "-Xdoclint:all")
  options.addStringOption("-Xdoclint:all")
  options.addStringOption("private", "-quiet")
  options.addStringOption("source", "8")
  doLast {
    ant.replaceregexp(match:"@import url\\('resources/fonts/dejavu.css'\\);\\s*", replace:"",
    flags:"g", byline:true) {
      fileset(dir: destinationDir)
    }
  }
}
check.dependsOn(javadoc)

configurations {
  requireJavadoc
}
dependencies {
  requireJavadoc("org.plumelib:require-javadoc:2.0.0")
}
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)

// 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")
}