build.gradle

buildscript {
    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath 'com.netflix.nebula:gradle-aggregate-javadocs-plugin:2.2.+'
        classpath 'net.ltgt.gradle:gradle-errorprone-plugin:0.0.8'
    }
}
plugins {
    id 'java'
    id 'idea'
    id 'eclipse'
    id 'jacoco'
    id 'com.google.osdetector' version '1.4.0'
    id 'com.github.johnrengelman.shadow' version '1.2.3'
}
apply plugin: 'nebula-aggregate-javadocs'

def getGitCommit = { ->
    String HEAD_REF = new File(rootDir, '.git/HEAD').text.replace("ref: ", "").replace("\n", "")
    String COMMIT_HASH = new File(rootDir, ".git/${HEAD_REF}").text.substring(0, 7)
    return COMMIT_HASH
}

idea.project {
    ipr.withXml { provider ->
        def node = provider.asNode()
        def compilerConfig = node.component.find { it.'@name' == 'CompilerConfiguration'}
        compilerConfig.annotationProcessing[0].'@enabled' = 'true'
//        def ccfg = node.component.find { it.@name == 'CompilerConfiguration' }
//        ccfg.remove(ccfg.annotationProcessing)
//        ccfg.append(new NodeBuilder().annotationProcessing() {
//            profile(default: true, name: 'Default', enabled: true) {
//                processorPath(useClasspath: true)
//            }
//        })
    }
}

/*
 * Gets the version name from the latest Git tag
 * http://ryanharter.com/blog/2013/07/30/automatic-versioning-with-git-and-gradle/
 */
def getVersionName = { ->
    if (project.hasProperty("vers")) return vers
    try {
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'git', 'describe', '--tags'
            standardOutput = stdout
        }
        return stdout.toString().trim().substring(1)
    } catch (org.gradle.process.internal.ExecException e) {
        if (!new File(rootDir, '.git/HEAD').exists()) {
            println("WARN: Could not fetch Git Tag for build version. No Git HEAD available. Substituting version 0.0.0")
            return "0.0.0"
        }
        println("WARN: Could not fetch Git Tag for build version. Please install Git and add it to your PATH. For now, the Git commit hash has been substituted.")
        return getGitCommit()
    }
}

def getVersionSimple = { ->
    if (project.hasProperty("vers")) return vers
    try {
        def stdout = new ByteArrayOutputStream()
        exec {
            commandLine 'git', 'describe', '--tags', '--abbrev=0'
            standardOutput = stdout
        }
        return stdout.toString().trim().substring(1)
    } catch (org.gradle.process.internal.ExecException e) {
        if (!new File(rootDir, '.git/HEAD').exists()) {
            println("WARN: Could not fetch Git Tag for build version. No Git HEAD available. Substituting version 0.0.0")
            return "0.0.0"
        }
        println("WARN: Could not fetch Git Tag for build version. Please install Git and add it to your PATH. For now, the Git commit hash has been substituted.")
        return getGitCommit()
    }
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'application'
    apply plugin: 'jacoco'
    apply plugin: 'net.ltgt.errorprone'

    configurations.errorprone {
        resolutionStrategy.force 'com.google.errorprone:error_prone_core:2.0.9'
    }


    repositories {
        mavenCentral()
        jcenter()
    }
    jacoco {
        toolVersion = "0.7.5.201505241946"
    }


    dependencies {
        testCompile group: 'net.jodah', name: 'concurrentunit', version: '0.4.2'
        testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
        testCompile group: 'junit', name: 'junit', version: '4.12'
        testCompile group: 'com.google.truth', name: 'truth', version: '0.28'
        testCompile group: 'com.google.guava', name: 'guava-testlib', version: '19.0'
    }

    version = getVersionName()

    compileJava {
        options.compilerArgs << "-g"
    }

    jacocoTestReport {
        reports {
            xml.enabled = true
            html.enabled = true
        }
    }

    check.dependsOn jacocoTestReport

    tasks.withType(Javadoc) {
        source compileJava.source
        options.addStringOption('Xdoclint:all,-html', '-quiet')
        failOnError false
    }

    tasks.withType(JavaExec) {
        enableAssertions = true
    }

    // Turn on test results
    test {
        testLogging {
            if (project.hasProperty('logTests')) {
                events  "started", "passed", "skipped", "failed"
            } else {
                events "failed"
            }
            exceptionFormat "full"
        }
        doFirst {
            filter.includePatterns.each {
                include "${it.replaceAll('\\.', "\\${File.separator}")}.class"
            }
            filter.setIncludePatterns('*')
        }
    }
}

def os = osdetector.classifier.replace("osx", "macosx").replace("x86_32", "x86")
def arch = osdetector.arch.replace("x86_64", "x64")

project(":core") {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'jacoco'
    apply plugin: "com.github.johnrengelman.shadow"

    configurations {
        shadow
        // I'm not sure what's going on here, but this works
        // https://github.com/bytedeco/javacv/issues/395
        all*.exclude group: 'org.bytedeco', module: 'javacpp-presets'
    }

    repositories {
        flatDir {
            dirs 'libs'
        }
        maven {
            url = "http://first.wpi.edu/FRC/roborio/maven/development"
        }
        maven {
            url = "https://github.com/WPIRoboticsProjects/rosjava_mvn_repo/raw/master"
        }
    }

    dependencies {
        compile group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.1'
        compile group: 'org.bytedeco', name: 'javacv', version: '1.2'
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv', version: '3.1.0-1.2'
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv', version: '3.1.0-1.2', classifier: os
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv', version: '3.1.0-1.2', classifier: 'linux-armhf'
        // I can uncomment this once someone rebuilds the opencv javacpp-presets for frc.
        // I was having trouble installing the frc toolchain on xenial, so that means for now you can't deploy to the rio
        //compile group: 'org.bytedeco.javacpp-presets', name: 'opencv-3.1.0-1.2', classifier: 'linux-frc'
        compile group: 'org.bytedeco.javacpp-presets', name: 'videoinput', version: '0.200-1.2', classifier: os
        compile group: 'org.python', name: 'jython', version: '2.7.0'
        compile group: 'com.thoughtworks.xstream', name: 'xstream', version: '1.4.8'
        compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.4'
        compile group: 'com.google.guava', name: 'guava', version: '19.0'
        compile group: 'com.google.auto.value', name: 'auto-value', version: '1.1'
        // We use the no_aop version of Guice because the aop isn't avaiable in arm java
        // http://stackoverflow.com/a/15235190/3708426
        // https://github.com/google/guice/wiki/OptionalAOP
        compile group: 'com.google.inject', name: 'guice', version: '4.0', classifier: 'no_aop'
        compile group: 'com.google.inject.extensions', name: 'guice-assistedinject', version: '4.0'

        // Network publishing dependencies
        compile group: 'org.ros.rosjava_core', name: 'rosjava', version: '[0.2,0.3)'
        compile group: 'org.ros.rosjava_messages', name: 'grip_msgs', version: '0.0.1'
        compile group: 'edu.wpi.first.wpilib.networktables.java', name: 'NetworkTables', version: '3.0.0-SNAPSHOT', classifier: 'desktop'
        compile group: 'edu.wpi.first.wpilib.networktables.java', name: 'NetworkTables', version: '3.0.0-SNAPSHOT', classifier: 'arm'
    }

    mainClassName = 'edu.wpi.grip.core.Main'

    jar {
        manifest {
            attributes 'Implementation-Version': version, 'Main-Class': mainClassName
        }
    }

    shadowJar {
        artifacts {
            shadow(tasks.shadowJar.archivePath) {
                builtBy shadowJar
            }
        }

        /* The icudt54b directory in Jython takes up 9 megabytes and doesn't seem to do anything useful. */
        exclude 'org/python/icu/impl/data/icudt54b/'

        /* We don't use all of the OpenCV libraries, and they seem to take up a lot of space.  If we ever decide to
        use any more of these (or perhaps just include them for people to use from Python scripts), the following lines
        should be changed, but for now this saves us a lot of space. */
        exclude 'org/bytedeco/javacpp/*/*calib3d*'
        exclude 'org/bytedeco/javacpp/*/*face*'
        exclude 'org/bytedeco/javacpp/*/*objdetect*'
        exclude 'org/bytedeco/javacpp/*/*optflow*'
        exclude 'org/bytedeco/javacpp/*/*photo*'
        exclude 'org/bytedeco/javacpp/*/*shape*'
        exclude 'org/bytedeco/javacpp/*/*stitching*'
        exclude 'org/bytedeco/javacpp/*/*superres*'
        exclude 'org/bytedeco/javacpp/*/*videostab*'
        exclude 'org/bytedeco/javacpp/*/*xfeatures2d*'
    }

    sourceSets {
        generated {
            java {
                /* Note: When referencing this it becomes `srcDirs` */
                srcDir 'src/generated/java'
            }
        }
    }

    task generateCodeFromSource(type: CodeGenerator) {
        description 'Generates the Operation Wrappers for the OpenCV methods.\n To skip run with parm `-PskipGenerate`'
        dest sourceSets.generated.java.srcDirs
        removeExisting true
    }
    generateCodeFromSource.onlyIf { !project.hasProperty('skipGenerate') }
    compileJava.source sourceSets.generated.java, sourceSets.main.java
    compileJava.dependsOn generateCodeFromSource

    // IDE setup
    eclipse.classpath {
        file.whenMerged { cp ->
            sourceSets.generated.java.srcDirs.forEach { srcDir ->
                def source_folder = new org.gradle.plugins.ide.eclipse.model.SourceFolder(srcDir.getAbsolutePath(), "build/classes/merged")
                if (cp.entries.find() { it.path == source_folder.path } == null)
                    cp.entries.add(source_folder)
            }
        }
    }

    idea.module {
        sourceDirs += sourceSets.generated.java.srcDirs
        sourceDirs += file('generated')
    }
}

project(":ui") {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'jacoco'
    apply plugin: 'application'
    apply from: 'http://dl.bintray.com/shemnon/javafx-gradle/8.1.1/javafx.plugin'

    configurations {
        ideProvider
    }

    dependencies {
        compile project(path: ':core', configuration: 'shadow')
        ideProvider project(path: ':core', configuration: 'compile')
        compile group: 'org.controlsfx', name: 'controlsfx', version: '8.40.10'
        compile group: 'com.hierynomus', name: 'sshj', version: '0.15.0'
        testCompile files(project(':core').sourceSets.test.output.classesDir)
        testCompile files(project(':core').sourceSets.test.output.resourcesDir)
        testCompile group: 'org.testfx', name: 'testfx-core', version: '4.0.+'
        testCompile group: 'org.testfx', name: 'testfx-junit', version: '4.0.+'
        testRuntime group: 'org.testfx', name: 'openjfx-monocle', version: '1.8.0_20'
    }

    evaluationDependsOn(':core')
    compileTestJava.dependsOn tasks.getByPath(':core:testClasses')

    idea.module {
        scopes.PROVIDED.plus += [configurations.ideProvider]
    }

    /*
     * Allows you to run the UI tests in headless mode by calling gradle with the -Pheadless=true argument
     */
    if (project.hasProperty('headless') && project.headless) {
        println "Running UI Tests Headless"
        test {
            jvmArgs = ['-Djava.awt.headless=true', '-Dtestfx.robot=glass', '-Dtestfx.headless=true', '-Dprism.order=sw', '-Dprism.text=t2k']
        }
    }


    javafx {
        profiles {
            linux {
                category = 'Development'
                bundleArguments = [
                        // for DEB bundles
                        'email': 'wpilib@wpi.edu', // This is the email used for the deb maintainer field.
                ]
            }
        }
        appID = 'GRIP'
        appName = 'GRIP'
        mainClass = "edu.wpi.grip.ui.Main"
        version = getVersionSimple()

        // This prevents the JIT from eating stack traces that get thrown a lot
        // This is slower but means we actually get the stack traces instead of
        // having them become one line like `java.lang.ArrayIndexOutOfBoundsException`
        // and as such, would be useless.
        // See: https://plumbr.eu/blog/java/on-a-quest-for-missing-stacktraces
        jvmArgs = ["-XX:-OmitStackTraceInFastThrow"]
    }
    mainClassName = javafx.mainClass

    // The JavaFX plugin does not provide a way to change the installer artifact's name without changing the appName or appID,
    // so instead, we simply rename the artifact to append the architecture (x86 or x64)
    jfxDeploy.doLast {
        def filet = fileTree(dir: 'build/distributions', include: "${javafx.appName}-${getVersionSimple()}.*")
        filet.each { File f ->
            def f2 = new File(f.getParentFile(), "${f.getName().replace("${getVersionSimple()}", "${getVersionSimple()}-${arch}")}")
            f.renameTo(f2)
        }
    }
}

/*
 * This is roughly based upon this post:
 * https://discuss.gradle.org/t/merge-jacoco-coverage-reports-for-multiproject-setups/12100/6
 */
task jacocoRootReport(type: JacocoReport, group: 'Coverage reports') {
    description = 'Generates an aggregate report from all subprojects'
    dependsOn(subprojects.test)

    additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)
    sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
    classDirectories = files(subprojects.sourceSets.main.output)
    executionData = files(subprojects.jacocoTestReport.executionData)

    reports {
        html.enabled = true
        xml.enabled = true
    }

    doFirst {
        executionData = files(executionData.findAll { it.exists() })
    }
}
check.dependsOn jacocoRootReport

task wrapper(type: Wrapper) {
    gradleVersion = '2.13'
}