build.gradle

/*
 * build.gradle for Randoop
 *
 * Quick instructions: in project directory run with command
 *   ./gradlew build
 */

plugins {
  id 'com.github.johnrengelman.shadow' version '2.0.4'
  id 'java'
  id 'eclipse'
  id 'idea'
  id 'jacoco'

  /*
   * Plugin that applies Google-Java-format to the Java files in the project.
   * https://github.com/sherter/google-java-format-gradle-plugin
   */
  id 'com.github.sherter.google-java-format' version '0.7.1'

  /*
   * Plugin that applies Google's Error Prone linter (http://errorprone.info/).
   * https://github.com/tbroyer/gradle-errorprone-plugin
   * Elsewhere this file excludes src/testinput from directories examined by Error Prone.
   * To run Error Prone, do:  ./gradlew compileJava
   * There is no separate target to just run Error Prone.
   */
  id "net.ltgt.errorprone-base" version "0.0.11" // 0.0.13 does not work with Java 7
}

// For Checker Framework pluggable type-checking, run:  ./gradlew checkTypes
apply from: "checkerframework-annos-in-comments.gradle"
// apply from: "checkerframework.gradle"

/* Common build configuration for Randoop and agents */
allprojects {

  apply plugin: 'java'
  apply plugin: 'com.github.johnrengelman.shadow'

  sourceCompatibility = 1.7
  targetCompatibility = 1.7

  /* Use Maven Central when have external dependencies */
  repositories {
    mavenCentral()
    jcenter()
  }

  /* Randoop version number - added to generated jar files */
  version = '4.0.4'

  configurations {
    // A collection of all plumelib dependencies required, so that all
    // sub-projects use the same versions.
    plumelib
  }

  dependencies {
    plumelib 'org.plumelib:bcel-util:0.0.9'
    // To use a local version comment out line above and uncomment line below.
    //plumelib files("${rootDir}/libs/bcel-util-all.jar")

    plumelib 'org.plumelib:options:0.3.3'
    plumelib 'org.plumelib:plume-util:0.1.1'
  }
}

/******
 * Configuration specific to Randoop and not agents.
 * Configuration for agent FOO appears in agents/FOO/FOO.gradle .
 ******/

description = "Randoop automated test generation"

/* Root for working directories for system test generated files */
def workingDirectories = "$buildDir/working-directories"

sourceSets {
  /* JUnit tests that must be run with -javaagent */
  /* JUnit tests are run in nondeterministic order, but system tests are
     run in deterministic order. */
  coveredTest {
    java {
      srcDir 'src/coveredtest/java'
    }
    resources {
      srcDir 'src/coveredtest/resources'
    }
  }

  replacecallTest {
    java {
      srcDir 'src/replacecalltest/java'
    }
    resources {
      srcDir 'src/replacecalltest/resources'
    }
  }

  /* system tests */
  systemTest {
    java {
      srcDir 'src/systemtest/java'
    }
    resources {
      srcDir 'src/systemtest/resources'
      srcDir 'src/testinput/resources'
    }
    output.dir(workingDirectories, builtBy: 'generateWorkingDirs')
  }

  /* Code sets used by system tests. There are no actual tests here. */
  testInput {
    java {
      srcDir 'src/testinput/java'
    }
    resources {
      srcDir 'src/testinput/resources'
    }
  }

  test {
    resources {
      srcDir 'src/testinput/resources'
    }
  }
}

configurations {
  /*
   * Used to manage javaagent jar file
   */
  jacocoagent

  /*
   * The agent tests are JUnit tests run with the covered-class-agent, so
   * borrow from unit test configurations.
   */
  coveredTestImplementation.extendsFrom testImplementation
  coveredTestRuntimeOnly.extendsFrom testRuntimeOnly
  replacecallTestImplementation.extendsFrom testImplementation
  replacecallTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
  implementation configurations.plumelib

  implementation 'org.apache.commons:commons-exec:1.3'
  implementation group: 'commons-io', name: 'commons-io', version: '2.4'
  implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.0'
  implementation group: 'junit', name: 'junit', version: '4.+'
  implementation files(project(':replacecall').sourceSets.main.output)

  /* JavaParser 2.4.0 is the most recent version available with JDK7 jar files. */
  implementation group: 'com.github.javaparser', name: 'javaparser-core', version: '2.4.0'

  /* Jacoco measures coverage of classes and methods under test. */
  implementation group: 'org.jacoco', name: 'org.jacoco.core', version: '0.7.9'
  implementation group: 'org.jacoco', name: 'org.jacoco.agent', version: '0.7.9', classifier: 'runtime'

  /* sourceSet test uses JUnit and some use testInput source set */
  testImplementation group: 'commons-codec', name: 'commons-codec', version: '1.5'
  testImplementation group: 'backport-util-concurrent', name: 'backport-util-concurrent', version: '2.1'
  testImplementation group: 'junit', name: 'junit', version: '4.+'
  testImplementation group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
  testImplementation sourceSets.testInput.output

  /*
   * sourceSet coveredTest uses output from main sourceSet, and agent projects.
   * (Also, see configuration block.)
   */
  coveredTestImplementation sourceSets.main.output
  coveredTestImplementation sourceSets.test.output
  coveredTestRuntimeOnly project(':covered-class')

  replacecallTestImplementation files(project(':replacecall').sourceSets.main.output)

  jacocoagent group: 'org.jacoco', name: 'org.jacoco.agent', version: '0.7.7.201606060606'

  /*
   * source set systemTest
   */
  systemTestImplementation configurations.plumelib
  systemTestImplementation group: 'commons-io', name: 'commons-io', version: '2.4'
  systemTestImplementation 'org.apache.commons:commons-exec:1.3'
  systemTestImplementation group: 'junit', name: 'junit', version: '4.+'
  systemTestImplementation group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
  systemTestImplementation group: 'org.jacoco', name: 'org.jacoco.core', version: '0.7.7.201606060606'
  systemTestImplementation group: 'org.jacoco', name: 'org.jacoco.report', version: '0.7.7.201606060606'
  systemTestRuntimeOnly sourceSets.testInput.output

  /*
   * sourceSet testInput depends on output of main.
   * Also, src/testinput/java/ps1/RatPolyTest.java uses JUnit
   */
  testInputImplementation sourceSets.main.output
  testInputImplementation group: 'junit', name: 'junit', version: '4.+'
}

/*
 * Configuration for formatting
 */
googleJavaFormat {
  // as of 5/2018, default is still 1.1
  // versions 1.2 and higher require Java 8
  toolVersion '1.1'
  exclude '**/CloneVisitor.java'
}

tasks.googleJavaFormat {
  group 'Formatting'
  description = "Reformat Java source code with Google-Java-format"
  exclude 'src/testinput'
}

tasks.verifyGoogleJavaFormat {
  group 'Formatting'
  description = "Check Java source code formatting with Google-Java-format"
  exclude 'src/testinput'
}

// This is annoying to happen on every build:  it may delete import statements
// if there are certain types of syntax errors in the source code.
// // should verifyGoogleJavaFormat before compiling
// tasks.withType(JavaCompile) {
//   dependsOn 'googleJavaFormat' // task name conflicts with plugin name
// }

/*
 * Configuration for compilation.
 */
compileJava.options.compilerArgs = ['-Xlint','-g','-Xlint:-classfile']
compileTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileCoveredTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileReplacecallTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileSystemTestJava.options.compilerArgs = ['-g','-Xlint:-classfile']
compileTestInputJava.options.compilerArgs = ['-nowarn','-g','-Xlint:-classfile', '-XDenableSunApiLintControl', '-Xlint:-sunapi']

task compileAll() {
  dependsOn compileJava
  dependsOn compileTestJava
  dependsOn ':covered-class:compileJava'
  dependsOn ':covered-class:compileTestJava'
  dependsOn ':replacecall:compileJava'
  dependsOn ':covered-class:compileTestJava'
  dependsOn compileCoveredTestJava
  dependsOn compileReplacecallTestJava
  dependsOn compileSystemTestJava
}

// This isn't working; maybe I need to make it run first.
// Get early notification of any compilation failures, before running any tests
build.dependsOn compileAll

/*
 * Configuration for using Error Prone linter.
 *
 * Only works in Java 8+.
 */
import net.ltgt.gradle.errorprone.ErrorProneToolChain

tasks.withType(JavaCompile).each { t ->
  if (JavaVersion.current().isJava8Compatible()) {
    if (!t.name.equals("compileTestInputJava") && !t.name.startsWith("checkTypes")) {
      t.toolChain ErrorProneToolChain.create(project)
      t.options.compilerArgs += [
        // Maybe NamedParameters is no longer supported?
        // // undocumented, and suggestion seems bad
	// '-Xep:NamedParameters:OFF',
 	// Is always a false positive in my experience.
	'-Xep:StringSplitter:OFF'
        // TODO: uncomment once we run the Interning Checker on Randoop
        // '-Xep:ReferenceEquality:OFF'
        ]
    }
  }
}


/*
 * Configuration for clean
 */
clean.dependsOn ':replacecall:clean'
clean.dependsOn ':covered-class:clean'

/*
 * Configuration for testing.
 * In terms of build, we have two kinds of tests, both using JUnit.
 *   * Those in src/coveredtest require the covered-class Java agent.
 *   * Those in src/test are run without the agent.
 *     This second group includes tests that run the full Randoop over
 *     classes that (mostly) are located in src/testinput.
 */

/*
 * Configuration of test task from Java plugin.
 * Runs all tests in test sourceSet except those excluded below.
 */
test {

  /*
   * Set the working directory for JUnit tests to the resources directory
   * instead of the project directory.
   */
  workingDir = file("$buildDir/resources")

  /*
   * Show as much as possible to console.
   */
  testLogging {
    events 'started', 'passed'
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false

  /*
   * Temporary exclusion b/c script file uses generics as raw types and conflicts with
   * other uses of parsing.
   */
  exclude '**/randoop/test/SequenceTests.*'

  /*
   * Temporary exclusion b/c incomplete.
   */
  exclude '**/randoop/output/JUnitCreatorTest.*'

  /*
   * Problematic tests excluded during Gradle setup that need to be evaluated.
   * Unless otherwise noted, these are tests that were not previously run by
   * Makefile. However, some included tests were also not run, but are not
   * failing.
   */
  exclude 'randoop/test/NonterminatingInputTest.*'
  exclude 'randoop/test/EmptyTest.*'
  exclude 'randoop/test/RandoopPerformanceTest.*' /* had target but not run */
  exclude 'randoop/test/ForwardExplorerPerformanceTest.*'
  exclude 'randoop/test/ForwardExplorerTests2.*' /* sporadic heap space issue */
  exclude 'randoop/test/Test_SomeDuplicates.*'
  exclude 'randoop/test/Test_SomePass.*'
  exclude 'randoop/operation/OperationParserTests.*'
}

task coveredTest(type: Test, dependsOn: ['copyJars', 'compileTestJava']) {
  /*
   * Set the working directory for JUnit tests to the resources directory
   * instead of the project directory.
   */
  workingDir = sourceSets.coveredTest.output.resourcesDir
  testClassesDirs = sourceSets.coveredTest.output.classesDirs
  classpath = sourceSets.coveredTest.runtimeClasspath
  jvmArgs "-javaagent:$buildDir/libs/covered-class-${version}.jar"

  /*
   * Show as much as possible to console.
   */
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}

/*
 * Link the coveredTest task into project check task. Includes agent tests into
 * the project build task.
 */
check.dependsOn coveredTest

task replacecallTest(type: Test, dependsOn: 'copyJars') {
  workingDir = sourceSets.replacecallTest.output.resourcesDir
  testClassesDirs = sourceSets.replacecallTest.output.classesDirs
  classpath = sourceSets.replacecallTest.runtimeClasspath + files("$buildDir/libs/replacecall-${version}.jar")
  // use the replacecall agent using the exclusions file from replacecalltest/resources
  jvmArgs "-javaagent:$buildDir/libs/replacecall-${version}.jar=--dont-transform=replacecall-exclusions.txt,--debug"
  jvmArgs "-Xbootclasspath/a:$buildDir/libs/replacecall-${version}.jar"
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}
check.dependsOn replacecallTest

jacocoTestReport {
  group 'Report'
  reports {
    xml.enabled = true
    html.enabled = true
  }
}
// Expects these files to exist in build/javcoco/:
//   agentTest.exec
//   coveredTest.exec
//   systemTest.exec
//   test.exec
// What is creating the agentTest.exec files, and how do I create it?
// test.exec is the default, though it it also greated by "gradle test".
// jacocoTestReport.dependsOn agentTest
jacocoTestReport.dependsOn coveredTest
jacocoTestReport.dependsOn test

check.dependsOn jacocoTestReport

/*
 * Task to build the root directory of working directories used by the
 * JUnit tests in the systemTest task.
 * If the directory exists then cleans out the contents.
 */
task generateWorkingDirs {
  doLast {
    def generated = file(workingDirectories)
    if (! generated.exists()) {
      generated.mkdir()
    } else {
      def workingFiles = fileTree(workingDirectories) {
        include '**/*.java'
        include '**/*.class'
        include '**/*.exec'
        include '**/*.txt'
      }
      delete workingFiles
    }
  }
}

/*
 * Extracts JaCoCo javaagent into build/jacocoagent
 */
task extractJacocoAgent(type: Copy) {
  from {
    configurations.jacocoagent.collect { zipTree(it) }
  }
  into "$buildDir/jacocoagent/"
}

/*
 * Configuration of the systemTest task.
 * Runs JUnit over all classes in systemTest sourceSet.
 * JUnit tests assume that working directories can be found in the build directory.
 */
task systemTest(type: Test, dependsOn: [ 'extractJacocoAgent', 'generateWorkingDirs', 'assemble' ]) {

  /*
   * Set system properties for jar paths, used by randoop.main.SystemTestEnvironment
   */
  doFirst {
    systemProperty 'jar.randoop', shadowJar.archivePath
    systemProperty 'jar.replacecall.agent', project(':replacecall').shadowJar.archivePath
    systemProperty 'jar.covered.class.agent', project(':covered-class').shadowJar.archivePath
  }

  workingDir = file("$buildDir")
  testClassesDirs = sourceSets.systemTest.output.classesDirs
  classpath = sourceSets.systemTest.runtimeClasspath

  /*
   * Show as much as possible to console.
   */
  testLogging {
    showStandardStreams = true
    exceptionFormat = 'full'
  }

  /* Turn off HTML reports -- handled by testReport task */
  reports.html.enabled = false
}

systemTest.dependsOn shadowJar

/*
 * Link the systemTest task into the project check task.
 * Includes system tests into the project build task.
 */
check.dependsOn systemTest
jacocoTestReport.dependsOn systemTest

tasks.withType(Test) {
 /*
  * Set the destination directory for JUnit XML output files
  */
  reports.junitXml.destination = file("$buildDir/test-results/${name}")
 /*
  * Set the heap size and GC for running tests.
  */
  jvmArgs '-Xmx384m', '-XX:+UseG1GC', '-XX:SoftRefLRUPolicyMSPerMB=250'

  /*
   * Pass along any system properties that begin with "randoop."
   * Used by randoop.main.RandoopOptions in systemtest.
   */
  System.properties.each { k,v->
        if (k.startsWith("randoop.")) {
            systemProperty k, v
        }
  }
}

/*
 * Configuration of task to write HTML reports into build/reports/allTests for
 * all tests.
 * [
 *   Note that this may not work correctly if different Test tasks use the same
 *   test classes. Fine here because sourceSets use different packages for test
 *   classes.
 * ]
 */
task testReport(type: TestReport) {
  group 'Report'
  description "Creates HTML reports for tests results"
  destinationDir = file("$buildDir/reports/allTests")
  reportOn tasks.withType(Test)
}

//****************** Building distribution *****************

/*
 * Only want the jar file to include class files from main source set.
 * (Task part of build by default.)
 */
jar {
  from sourceSets.main.output
}

// want to archive locally
uploadArchives {
  repositories {
    flatDir {
      dirs 'dist'
    }
  }
}

task copyJars(type: Copy, dependsOn: [':covered-class:jar', ':replacecall:jar']) {
  from subprojects.collect { it.tasks.withType(Jar) }
  into "$buildDir/libs"
}

assemble.dependsOn copyJars

shadowJar {
  // The jar file name is randoop-all-$version.jar
  baseName = 'randoop-all'
  classifier = null

  exclude '**/pom.*'
  exclude '**/default-*.txt'

  // don't include either mocks or agent classes
  // otherwise creates problems for replacement creation of replacecall agent
  exclude '**/randoop/mock/*'
  exclude '**/randoop/instrument/*'

  relocate 'com.github.javaparser', 'randoop.com.github.javaparser'
  relocate 'com.google', 'randoop.com.google'
  relocate 'com.jcraft.jsch', 'randoop.com.jcraft.jsch'
  relocate 'com.sun.javadoc', 'randoop.com.sun.javadoc'
  relocate 'com.sun.jna', 'randoop.com.sun.jna'
  relocate 'com.trilead.ssh2', 'randoop.com.trilead.ssh2'
  relocate 'de.regnis.q.sequence', 'randoop.de.regnis.q.sequence'
  relocate 'edu.emory.mathcs.backport.java.util', 'randoop.edu.emory.mathcs.backport.java.util'
  relocate 'net.fortuna.ical4j', 'randoop.net.fortuna.ical4j'
  relocate 'nu.xom', 'randoop.nu.xom'
  relocate 'org.antlr', 'randoop.org.antlr'
  relocate 'org.apache', 'randoop.org.apache'
  relocate 'org.ccil.cowan.tagsoup', 'randoop.org.ccil.cowan.tagsoup'
  relocate 'org.checkerframework', 'randoop.org.checkerframework'
  relocate 'org.ini4j', 'randoop.org.ini4j'
  relocate 'org.plumelib', 'randoop.org.plumelib'
  relocate 'org.slf4j', 'randoop.org.slf4j'
  relocate 'org.tigris.subversion', 'randoop.org.tigris.subversion'
  relocate 'org.tmatesoft', 'randoop.org.tmatesoft'
}

assemble.dependsOn shadowJar

task distributionZip (type: Zip , dependsOn: ['shadowJar', 'copyJars', 'manual']) {
  group 'Publishing'
  description "Assemble a zip file with jar files and user documentation"
  def dirName = "$baseName-$version"
  from 'build/libs/'
  from ('build/docs/manual/index.html') {
    into 'doc'
  }
  from ('build/docs/manual/stylesheets') {
    into 'doc/manual/stylesheets'
  }
  from 'src/distribution/resources/README.txt'
  into (dirName)
  exclude { details -> details.file.name.contains('randoop') && ! details.file.name.contains('-all-') }
}

/********************* Building manual *******************/
/*
 * The "manual" gradle target creates the contents of the manual directory
 * within src/, which will eventually be moved to project docs directory.
 *
 * Has structure:
 *   docs/
 *     api/ - contains javadoc for main source set
 *     manual/
 *       dev.html - developer documentation
 *       index.html - user documentation
 *       *example.txt - example configuration files for user manual
 *       stylesheets/ - contains css file for web pages
 */

 /*
  * Clone or update repositories containing executable scripts.
  *
  * Grgit has too many limitations.  Use exec instead.
  */
task cloneLibs( dependsOn: [ 'cloneChecklink', 'cloneHtmlTools', 'clonePlumeScripts' ]) { }

task cloneChecklink {
  doLast {
    if ( ! file("$buildDir/utils/checklink").exists() ) {
      exec {
        commandLine 'git', 'clone', '--depth', '1', "https://github.com/plume-lib/checklink.git", "$buildDir/utils/checklink"
      }
    } else {
      // Ignore exit value so this does not halt the build when not connected to the Internet.
      exec {
        workingDir "$buildDir/utils/checklink"
        ignoreExitValue true
        commandLine 'git', 'pull', '-q'
      }
    }
  }
}

task cloneHtmlTools {
  doLast {
    if ( ! file("$buildDir/utils/html-tools").exists() ) {
      exec {
        commandLine 'git', 'clone', '--depth', '1', "https://github.com/plume-lib/html-tools.git", "$buildDir/utils/html-tools"
      }
    } else {
      // Ignore exit value so this does not halt the build when not connected to the Internet.
      exec {
        workingDir "$buildDir/utils/html-tools"
        ignoreExitValue true
        commandLine 'git', 'pull', '-q'
      }
    }
  }
}

task clonePlumeScripts {
  doLast {
    if ( ! file("$buildDir/utils/plume-scripts").exists() ) {
      exec {
        commandLine 'git', 'clone', '--depth', '1', "https://github.com/plume-lib/plume-scripts.git", "$buildDir/utils/plume-scripts"
      }
    } else {
      // Ignore exit value so this does not halt the build when not connected to the Internet.
      exec {
        workingDir "$buildDir/utils/plume-scripts"
        ignoreExitValue true
        commandLine 'git', 'pull', '-q'
      }
    }
  }
}

/*
 * Set destination directory to build/docs/api, and restrict to classes in
 * main sourceSet.
 */
javadoc {
  destinationDir = file("${buildDir}/docs/api")
  source sourceSets.main.allJava
  options.memberLevel = JavadocMemberLevel.PRIVATE
  options.addStringOption("stylesheetfile", "${projectDir}/src/javadoc/resources/stylesheets/javadocstyle.css")
  // Use of Javadoc's -linkoffline command-line option makes Javadoc generation
  // much faster, especially on Travis.
  options.with {
    linksOffline 'https://docs.oracle.com/javase/8/docs/api/', 'https://docs.oracle.com/javase/8/docs/api/'
  }
  failOnError = true  // does not fail on warnings
}

// Make Javadoc fail on warnings
// From https://stackoverflow.com/a/49544352/173852
if (JavaVersion.current().isJava8Compatible()) {
    tasks.withType(Javadoc) {
        // The '-quiet' as second argument is actually a hack,
        // since the one paramater addStringOption doesn't seem to
        // work, we extra add '-quiet', which is added anyway by
        // gradle. See https://github.com/gradle/gradle/issues/2354
        // See JDK-8200363 (https://bugs.openjdk.java.net/browse/JDK-8200363)
        // for information about the -Xwerror option.
        options.addStringOption('Xwerror', '-quiet')
    }
}

configurations {
  requireJavadoc
}
dependencies {
  compile group: 'org.plumelib', name: 'require-javadoc', version: '0.0.7'
}
task requireJavadoc(type: Javadoc) {
  description = 'Ensures that all Java elements have Javadoc documentation.'
  destinationDir.deleteDir()
  source = sourceSets.main.allJava
  classpath = project.sourceSets.main.compileClasspath
  // options.memberLevel = JavadocMemberLevel.PRIVATE
  options.docletpath = project.sourceSets.main.compileClasspath as List
  options.doclet = "org.plumelib.javadoc.RequireJavadoc"
  // options.addStringOption('skip', 'ClassNotToCheck|OtherClass')
}
task requireJavadocPrivate(type: Javadoc) {
  description = 'Ensures that all (even private) Java elements have Javadoc documentation.'
  destinationDir.deleteDir()
  source = sourceSets.main.allJava
  classpath = project.sourceSets.main.compileClasspath
  options.memberLevel = JavadocMemberLevel.PRIVATE
  options.docletpath = project.sourceSets.main.compileClasspath as List
  options.doclet = "org.plumelib.javadoc.RequireJavadoc"
  // options.addStringOption('skip', 'ClassNotToCheck|OtherClass')
}

// needed for javadoc.doLast
javadoc.dependsOn cloneLibs

javadoc.doLast {
  def preplace = file("$buildDir/utils/plume-scripts/preplace")
  // Work around Javadoc bug
  exec {
    commandLine preplace, "<dt><span class=\"memberNameLink\"><a href=\".*\\(\\)</a></span> - Constructor for enum [a-zA-Z0-9_.]*<a href=\".*</a></dt>", "", "build/docs/api/index-all.html"
  }
  // Reduce size of diffs (when it's copied over to docs/api whech is under
  // version control).  Note that build/docs/api/ is the same as src/docs/api/.
  exec {
    commandLine preplace, "^<!-- Generated by javadoc \\(.* -->\$", "", "build/docs/api/"
  }
  exec {
    commandLine preplace, "^<meta name=\"date\" content=\"[-0-9]+\">\$", "", "build/docs/api/"
  }
}

/*
 * Make sure that build runs the same tasks as the script in .travis.yml
 */
build.dependsOn javadoc

/*
 * Configuration of updateUserTOC task to update the table-of-contents for the
 * user documentation.
 */
task updateUserTOC( type:Exec, dependsOn: [ 'cloneLibs' ]) {
  executable file("$buildDir/utils/html-tools/html-update-toc")
  args  file("${projectDir}/src/docs/manual/index.html")
  environment PATH: "$System.env.PATH:$buildDir/utils/html-tools"
}

/* Configuration of task updateDevTOC to update table of contents in developer
 * documentation.
 */
task updateDevTOC( type:Exec, dependsOn: ['cloneLibs' ]) {
  executable file("$buildDir/utils/html-tools/html-update-toc")
  args file("${projectDir}/src/docs/manual/dev.html")
  environment PATH: "$System.env.PATH:$buildDir/utils/html-tools"
}

// TODO: Why isn't this a Javadoc task?  That is, why does it call javadoc
// from the command line?
/*
 * Applies OptionsDoclet to src/docs/manual/index.html to add
 * command-line arguments extracted from the given @Option annotated classes.
 * Applied in-place.
 */
task updateUserOptions(dependsOn: 'assemble') {
  description "Runs OptionsDoclet on src/docs/manual/index.html"
  def classpath = sourceSets.main.runtimeClasspath.asPath
  def docFile = file("${projectDir}/src/docs/manual/index.html")
  def options = [
    "-classpath", classpath,
    "-docletpath", classpath,    // doclet loads class files from the documented classes
    "-doclet", "org.plumelib.options.OptionsDoclet",
    "-docfile", docFile,
    "-i",
  ]
  def fileList = [
    file("${projectDir}/src/main/java/randoop/main/GenInputsAbstract.java"),
    file("${projectDir}/src/main/java/randoop/generation/AbstractGenerator.java"),
    file("${projectDir}/src/main/java/randoop/util/ReflectionExecutor.java"),
    file("${projectDir}/src/main/java/randoop/main/Minimize.java")
  ]
  doLast {
    project.exec {
      commandLine = [ "javadoc" ] + options + fileList
    }
  }
}

/* Requires that the html5validator program is installed */
task html5validatorExists {
    doLast {
        def result = exec {
            def command = "command -v html5validator"
            ignoreExitValue = true
            executable "bash" args "-l", "-c", command
        }
        if (result.getExitValue() != 0) {
            ant.fail('html5validator is not installed.  See https://randoop.github.io/randoop/manual/dev.html#prerequisites .')
        }
    }
}

/*
 * Configuration of manual task to generate/update and move documentation into
 * build/docs directory.
 */
task manual(type: DefaultTask, dependsOn: [ 'updateUserOptions', 'updateUserTOC', 'updateDevTOC', 'html5validatorExists']) {
  group 'Documentation'
  description "Adds options and TOC to documentation in src/docs"
  doLast {
    exec {
      if (JavaVersion.current().isJava8Compatible()) {
        environment PATH: "$System.env.PATH"
        commandLine "html5validator", "--root", file("${projectDir}/src/docs/manual")
      } else {
        commandLine "echo","WARNING: HTML validation of manuals is only run in Java 8+"
      }
    }
  }
}

build.dependsOn manual

/*
 * Applies HTML5 validator to API javadoc.
 * Note: prior to Java 9, javadoc does not comply with HTML5.
 */
task validateAPI(type: Exec, dependsOn: ['javadoc', 'html5validatorExists']) {
  group 'Documentation'
  description "Run html5validator to find HTML errors in API documentation"
  if (JavaVersion.current().isJava9Compatible()) {
    environment PATH: "$System.env.PATH"
    commandLine "html5validator", "--root", file("${buildDir}/docs/api")
  } else {
    commandLine "echo", "WARNING: HTML validation of API is only run in Java 9+"
  }
}


/*
 * WARNING: do not run this task unless you mean to wipe out the project pages
 * directory. It can be repopulated by publishSite, but the contents will be
 * based on changes to the files in src/docs and the Javadoc in the source.
 */
task cleanSite {
  group=null
  description 'Removes all files from the project pages directory (CAUTION!)'
  def siteDir = file("${projectDir}/docs")
  def oldSiteFiles = fileTree(siteDir) {
    exclude 'README.md'
  }
  doLast {
    delete oldSiteFiles
  }
}

/*
 * Publishes changes to the project documentation to the project pages directory
 * (docs). This task ensures that all old site files are removed, new API
 * documentation is generated, the manual is updated, and the HTML has been
 * validated.
 *
 * Note that the contents of any subdirectory of build/docs will be included in
 * the site. Currently, this is only the api directory generated by the javadoc
 * task.
 *
 * All site files will be read-only.
 */
task publishSite (dependsOn: ['cleanSite', 'javadoc', 'validateAPI', 'manual']) {
  group 'Publishing'
  description 'Publish changes to site files and javadoc to the project pages directory'
  def siteDir = file("${projectDir}/docs")
  def buildDocsDir = file("${buildDir}/docs") // include any built docs (e.g., api)
  def newSiteFiles = fileTree("${projectDir}/src/docs") {
    exclude 'README.md'
    exclude 'api'
  }
  doLast {
      copy {
        from (buildDocsDir)  //copy api
        from (newSiteFiles)
        into siteDir
        fileMode = Integer.parseInt("444", 8)
      }
  }
}

/*
 * Applies HTML5 validator to project site HTML, including the manual
 */
task validateSite(dependsOn: 'html5validatorExists') {
  description "Run html5validator to find HTML errors in site files (excludes manual and api)"
  if (JavaVersion.current().isJava8Compatible()) {
    exec {
      environment PATH: "$System.env.PATH"
      commandLine "html5validator", "--root", "src/docs/", "--ignore", "src/docs/api"
    }
    exec {
      environment PATH: "$System.env.PATH"
      commandLine "html5validator", "--root", "docs/", "--ignore", "docs/api"
    }
  } else {
    println "WARNING: HTML validation of site is only run in Java 8+"
  }
}

task buildRelease(type: DefaultTask, dependsOn: [ 'assemble', 'check', 'publishSite', 'validateSite', 'distributionZip' ]) {
  group 'Publishing'
  description "Builds system and documentation, validates HTML, and publishes site"
}

/*************** Gradle Wrapper ******************/
/* Declares the Gradle version to be used when the wrapper is built */
task wrapper(type: Wrapper) {
  description "Configure Gradle Wrapper for this project"
  gradleVersion = '4.1'
}

/*************** Other tool configs *************/
/* Make Emacs TAGS table */
task tags(type: Exec, dependsOn: 'cloneLibs') {
  group 'Emacs'
  description "Run etags to create an Emacs TAGS table"
  commandLine "bash", "-c", "find src/ agent/covered-class/src/ agent/replacecall/src/ -name '*.java' | grep -v src/testinput | $buildDir/utils/plume-scripts/sort-directory-order | xargs etags"
}

/* Make Emacs TAGS table, with only Randoop code (not test code) */
task tagsNoTests(type: Exec, dependsOn: 'cloneLibs') {
  group 'Emacs'
  description "Run etags to create an Emacs TAGS table"
  commandLine "bash", "-c", "find src/ -name *.java | $buildDir/utils/plume-scripts/sort-directory-order | grep -v /testinput/ | xargs etags"
}

/* Run checklink */
task checklink(type: Exec, dependsOn: 'cloneLibs') {
  group 'Validation'
  description "Run checklink on randoop.github.io/randoop/ and write output to checklink-log.txt"
  environment PATH: "$System.env.PATH:$buildDir/utils/checklink"
  commandLine 'bash', '-c', """
     checklink -q -r `grep -v '^#' build/utils/checklink/checklink-args.txt` https://randoop.github.io/randoop/ &> checklink-log.txt
  """
}

task installGitHooks(type: Copy) {
  group=null
  description "Installs git hooks for pre-commit and managing docs permissions"
  from 'scripts/'
  into '.git/hooks'
}
/* Always run this task. */
tasks.installGitHooks.execute()