repositories {
    jcenter()
    mavenCentral()
}

ext {
    release = false

    // On a Java 8 JVM, use error-prone javac and source/target 8.
    // On a Java 9+ JVM, use the host javac, default source/target, and required module flags.
    isJava8 = JavaVersion.current() == JavaVersion.VERSION_1_8

    errorproneJavacVersion = '9+181-r4173-1'

    parentDir = file("${rootDir}/../").absolutePath

    annotationTools = "${parentDir}/annotation-tools"
    afu = "${annotationTools}/annotation-file-utilities"
    afuJar = "${afu}/annotation-file-utilities-all-but-javac.jar"

    stubparser = "${parentDir}/stubparser"
    stubparserJar = "${stubparser}/javaparser-core/target/stubparser.jar"

    jtregHome = "${parentDir}/jtreg"

    javadocMemberLevel = JavadocMemberLevel.PROTECTED

    // The local git repository, typically in the .git directory, but not for worktrees.
    // This value is always overwritten, but Gradle needs the variable to be initialized.
    localRepo = ".git"
}

task setLocalRepo(type:Exec) {
    commandLine 'git', 'worktree', 'list'
    standardOutput = new ByteArrayOutputStream()
    doLast {
       String worktreeList = standardOutput.toString()
       localRepo = worktreeList.substring(0, worktreeList.indexOf(" ")) + "/.git"
    }
}

allprojects {
    apply plugin: 'java'

    group 'org.checkerframework'
    // Increment the minor version rather than just the patch level if:
    //   * any new checkers have been added,
    //   * the patch level is 9 (keep the patch level as a single digit), or
    //   * backward-incompatible changes have been made to APIs or elsewhere.
    version '3.0.1'

    repositories {
        mavenCentral()
    }

    configurations {
        javacJar

        // There's a bug in IntelliJ that adds the processor path to the classpath when building
        // a Gradle project.  Because ErrorProne uses old versions of some of our jars, IntelliJ uses
        // those jars instead of the source code. The next 3 lines exclude Checker Framework from the
        // from the processor path as a work around for this problem.
        annotationProcessor.exclude group:'org.checkerframework', module:'javacutil'
        annotationProcessor.exclude group:'org.checkerframework', module:'dataflow'
        annotationProcessor.exclude group:'org.checkerframework', module:'checker-qual'
    }

    // After all the tasks have been created, modify some of them.
    afterEvaluate {
        /// TODO: One day we can enable this.  For now, CI jobs require Javadoc on changed lines.
        // // Turn Javadoc warnings into errors.
        // tasks.withType(Javadoc) {
        //     options.addStringOption('Xwerror', '-quiet')
        // }

        // Add standard javac options
        tasks.withType(JavaCompile) {
            sourceCompatibility = 8
            targetCompatibility = 8
            // Because the target is 8, all of the public compiler classes are accessible, so
            // --add-exports are not required, (nor are they allowed with target 8). See
            // https://openjdk.java.net/jeps/247 for details on compiling for older versions.

            // When sourceCompatibilty is changed to 11, then the following will be required.
            // options.compilerArgs += [
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
            // "--add-exports", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
            // ]
            // This is equivalent to writing "exports jdk.compiler/... to ALL-UNNAMED" in the
            // module-info.java of jdk.compiler, so corresponding --add-opens are only required for
            // reflective access to private members.
            //
            // From https://openjdk.java.net/jeps/261, Section titled: "Breaking encapsulation"
            // "The effect of each instance [of --add-exports] is to add a qualified export of the
            // named package from the source module to the target module. This is, essentially, a
            // command-line form of an exports clause in a module declaration[...].
            // [...]
            // The --add-exports option enables access to the public types of a specified package.
            // It is sometimes necessary to go further and enable access to all non-public elements
            // via the setAccessible method of the core reflection API. The --add-opens option can
            // be used, at run time, to do this."

            options.failOnError = true
            options.deprecation = true
            options.compilerArgs += [
                    '-g',
                    '-Werror',
                    // To not get a warning about missing bootstrap classpath for Java 8 (once we use Java 9).
                    "-Xlint:-options",
                    "-Xlint",
            ]

            options.encoding = 'UTF-8'
            options.fork = true
            if (isJava8) {
                options.forkOptions.jvmArgs += ["-Xbootclasspath/p:${configurations.javacJar.asPath}"]
            }
        }
    }
}

task cloneAndBuildDependencies(type: Exec) {
    description 'Clones (or updates) and builds all dependencies'
    executable 'checker/bin-devel/build.sh'
    args = ['downloadjdk']
}

task version() {
    description 'Print Checker Framework version'
    doLast {
        println version
    }
}




task htmlValidate(type: Exec, group: 'Format') {
    description 'Validate that HTML files are well-formed'
    executable 'html5validator'
    args = [
            "--ignore",
            "/api/",
            "/build/",
            "/docs/manual/manual.html",
            "/checker/jdk/nullness/src/java/lang/ref/package.html"
    ]
}



/**
 * Creates a task named taskName that runs javadoc.
 *
 * @param taskName the name of the task to create
 * @param taskDescription description of the task
 * @param memberLevel the JavadocMemberLevel to use
 * @param requireJavadoc whether or not to run the RequireJavadoc doclet. If false -Xdoclint:all is
 * passed. Defaults to true.
 * @return the new task
 */



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

task tags {
    description 'Create Emacs TAGS table'
    doLast {
        exec {
            commandLine "etags", "-i", "checker/TAGS", "-i", "dataflow/TAGS", "-i", "framework/TAGS", "-i", "framework-test/TAGS", "-i", "javacutil/TAGS", "-i", "docs/manual/TAGS"
        }
        exec {
            commandLine "make", "-C", "docs/manual", "tags"
        }
    }
}

subprojects {


    // Things in this block reference definitions in the subproject that do not exist,
    // until the project is evaluated.
    afterEvaluate {

        // Adds manifest to all Jar files
        tasks.withType(Jar) {
            includeEmptyDirs = false
            //We're only building checker-qual
                metaInf {
                    from './LICENSE.txt'
                }
            manifest {
                attributes("Implementation-Version": "${version}")
                attributes("Implementation-URL": "https://checkerframework.org")

                //We're only building checker-qual
                    attributes("Bundle-License": "MIT")
            }
        }

    }
}


task checkBasicStyle(group: 'Format') {
    description 'Check basic style guidelines.  Not related to Checkstyle tool.'
    String[] ignoreDirectories = ['.git',
                                  '.gradle',
                                  '.idea',
                                  '.plume-scripts',
                                  'annotated',
                                  'api',
                                  'bib',
                                  'bootstrap',
                                  'build',
                                  'jdk',
                                  'maven-artifacts']

    String[] ignoreFilePatterns = [
            '*.aux',
            '*.bib',
            '*.class',
            '*.dvi',
            '*.expected',
            '*.gif',
            '*.jar',
            '*.jtr',
            '*.log',
            '*.out',
            '*.patch',
            '*.pdf',
            '*.png',
            '*.sty',
            '*.xcf',
            '*~',
            '#*#',
            'CFLogo.ai',
            'logfile.log.rec.index',
            'manual.html',
            'manual.html-e',
            'junit.*.properties']
    doLast {
        FileTree tree = fileTree(dir: projectDir)
        for (String dir : ignoreDirectories) {
            tree.exclude "**/${dir}/**"
        }
        for (String file : ignoreFilePatterns) {
            tree.exclude "**/${file}"
        }
        boolean failed = false
        tree.visit {
            if (!it.file.isDirectory()) {
                int isBlankLine
                it.file.eachLine { line ->
                    if (line.endsWith(' ')) {
                        println("Trailing whitespace: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (!line.startsWith('\\') &&
                            (line.matches('^.* (else|finally|try)\\{}.*$')
                                    || line.matches('^.*}(catch|else|finally) .*$')
                                    || line.matches('^.* (catch|for|if|while)\\('))) {
                        // This runs on non-java files, too.
                        println("Missing space: ${it.file.absolutePath}")
                        failed = true
                    }
                    if (line.isEmpty()) {
                        isBlankLine++;
                    } else {
                        isBlankLine = 0;
                    }
                }

                if (isBlankLine > 1) {
                    println("Blank line at end of file: ${it.file.absolutePath}")
                    failed = true
                }

                RandomAccessFile file
                try {
                    file = new RandomAccessFile(it.file, 'r')
                    int end = file.length() - 1;
                    if (end > 0) {
                        file.seek(end)
                        byte last = file.readByte()
                        if (last != '\n') {
                            println("Missing newline at end of file: ${it.file.absolutePath}")
                            failed = true
                        }
                    }
                } finally {
                    if (file != null) {
                        file.close()
                    }
                }
            }
        }
        if (failed) {
            throw new GradleException("Files do not meet basic style guidelines.")
        }
    }
}

task releaseBuild(type: GradleBuild) {
    description 'Build everything required for a release'
    startParameter = new StartParameter()
    startParameter.setProjectProperties(release: true)
    // This downloads rather than builds the jdk8.jar because that's what is used in the CI tests.
    tasks = ['clean', 'assemble']
}

task releaseAndTest(type: GradleBuild, dependsOn: 'releaseBuild') {
    description 'Build everything required for a release and run allTests'
    startParameter = new StartParameter()
    startParameter.setProjectProperties(release: true)
    tasks = ['allTests']
}

// Don't create an empty checker-framework-VERSION.jar
jar.onlyIf {false}