build.gradle

import static org.gradle.api.tasks.wrapper.Wrapper.DistributionType

import groovy.xml.XmlUtil

buildscript {
    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
        maven {
            url 'https://github.com/WPIRoboticsProjects/opencv-maven/raw/mvn-repo'
        }
    }

    dependencies {
        classpath group: 'de.dynamicfiles.projects.gradle.plugins', name: 'javafx-gradle-plugin', version: '8.8.0'
        classpath 'com.netflix.nebula:gradle-aggregate-javadocs-plugin:3.0.1'
        classpath 'net.ltgt.gradle:gradle-errorprone-plugin:0.0.11'
        classpath group: 'edu.wpi.first.wpilib.opencv', name: 'opencv-installer', version: '2.0.0'
    }
}

import edu.wpi.first.wpilib.opencv.installer.Installer
import edu.wpi.first.wpilib.opencv.installer.platform.Platform

plugins {
    id 'com.gradle.build-scan' version '1.8'
    id 'java'
    id 'idea'
    id 'eclipse'
    id 'jacoco'
    id 'com.google.osdetector' version '1.4.0'
    id 'com.github.johnrengelman.shadow' version '1.2.4'
    id 'com.dorongold.task-tree' version '1.3'
    id 'org.ajoberstar.grgit' version '1.7.1' apply false
}
apply plugin: 'nebula-aggregate-javadocs'
apply from: 'git.gradle'

buildScan {
    licenseAgreementUrl = 'https://gradle.com/terms-of-service'
    licenseAgree = 'yes'
}

allprojects {
    // Hacky fix to make the build work
    tasks.withType(CreateStartScripts) {
        mainClassName = "someRandomGiberish" + Math.random()
    }
}

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
    return getGitDescribe()
}

def getVersionSimple = { ->
    if (project.hasProperty("vers")) return vers
    return getGitDescribeAbbrev()
}

configure(subprojects - project(':ui:linuxLauncher')) {
    apply plugin: 'java'
    apply plugin: 'application'
    apply plugin: 'jacoco'
    apply plugin: 'net.ltgt.errorprone'
    apply plugin: 'checkstyle'
    apply plugin: 'pmd'
    apply plugin: 'findbugs'

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

    checkstyle {
        configFile = new File(rootDir, "checkstyle.xml")
        toolVersion = '6.19'
        if (project.hasProperty("ignoreCheckstyle")) {
            ignoreFailures = true
        }
    }

    tasks.withType(Checkstyle) {
        // Remove checkstyle dependencies on compilation
        // (This neuters :core:checkstyleGenerated, but since that's not needed anyway, who cares)
        it.dependsOn = []
    }

    pmd {
        consoleOutput = true
        sourceSets = [sourceSets.main, sourceSets.test]
        reportsDir = file("$project.buildDir/reports/pmd")
        ruleSetFiles = files(new File(rootDir, "pmd-ruleset.xml"))
        ruleSets = []
    }

    findbugs {
        sourceSets = [sourceSets.main, sourceSets.test]
        excludeFilter = new File(rootDir, "findBugsSuppressions.xml")
        effort = "max"
    }

    ext.printReportSafe = { xmlReport ->
        if (xmlReport.exists()) {
            def bugs = (new XmlParser().parse(xmlReport)).BugInstance
            bugs.each { System.out.println(new XmlUtil().serialize(it)) }
        }
    }

    task findbugsMainReport {
        doLast {
            printReportSafe(findbugsMain.reports.getXml().destination)
        }
    }

    task findbugsTestReport {
        doLast {
            printReportSafe(findbugsTest.reports.getXml().destination)
        }
    }

    findbugsMain.finalizedBy findbugsMainReport
    findbugsTest.finalizedBy findbugsTestReport

    repositories {
        mavenCentral()
        jcenter()
    }

    dependencies {
        compile group: 'com.google.code.findbugs', name: 'annotations', version: '3.0.1'
        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.34'
        testCompile group: 'com.google.guava', name: 'guava-testlib', version: '22.0'
    }

    version = getVersionName()

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

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

    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
    }

    repositories {
        flatDir {
            dirs 'libs'
        }
        maven {
            url = "http://first.wpi.edu/FRC/roborio/maven/release"
        }
        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.1'
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv', version: '3.0.0-1.1'
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv', version: '3.0.0-1.1', classifier: os
        compile group: 'org.bytedeco.javacpp-presets', name: 'opencv-3.0.0-1.1', classifier: 'linux-frc'
        compile group: 'org.bytedeco.javacpp-presets', name: 'videoinput', version: '0.200-1.1', classifier: os
        compile group: 'org.bytedeco.javacpp-presets', name: 'ffmpeg', version: '0.200-1.1', classifier: os
        compile group: 'org.python', name: 'jython', version: '2.7.0'
        compile group: 'com.thoughtworks.xstream', name: 'xstream', version: '1.4.9'
        compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.5'
        compile group: 'org.apache.commons', name: 'commons-math3', version: '3.6.1'
        compile group: 'com.google.guava', name: 'guava', version: '20.0'
        compile group: 'com.google.auto.value', name: 'auto-value', version: '1.3'
        compile group: 'com.google.code.gson', name: 'gson', version: '2.8.0'
        compile group: 'org.eclipse.jetty', name:'jetty-server', version:'9.3.14.v20161028'
        testCompile group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.2'
        testCompile group: 'org.apache.httpcomponents', name: 'httpcore', version: '4.4.5'
        testCompile group: 'org.apache.httpcomponents', name: 'httpmime', version: '4.5.2'
        compile group: 'commons-cli', name: 'commons-cli', version: '1.3.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.1.0', classifier: 'no_aop'
        compile group: 'com.google.inject.extensions', name: 'guice-assistedinject', version: '4.1.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.1.2', classifier: 'desktop'
        compile group: 'edu.wpi.first.wpilib.networktables.java', name: 'NetworkTables', version: '3.1.2', 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/*/*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:linuxLauncher") {
    apply plugin: 'cpp'

    model {
        binaries {
            all {
                cppCompiler.args '-pthread', '-ldl'
                linker.args '-pthread', '-ldl'
            }
        }
        components {
            linuxLauncher(NativeExecutableSpec) {
                sources {
                    cpp {
                        source {
                            srcDir "src/cpp"
                        }
                    }
                }
            }
        }
    }
}

project (":ui:preloader") {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'jacoco'
    apply plugin: 'application'

    mainClassName = "edu.wpi.grip.preloader.GripPreloader"

    task run(overwrite: true, type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = mainClassName
        args 'windowed'
    }
}

project(":ui") {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'jacoco'
    apply plugin: 'application'
    apply plugin: 'javafx-gradle-plugin'

    repositories {
        maven {
            url = "http://first.wpi.edu/FRC/roborio/maven/development"
        }
    }

    configurations {
        ideProvider
    }
	if(!(project.hasProperty('generation') || project.hasProperty('genonly'))){
	    sourceSets {
            test {
                java {
                    exclude "**/ui/codegeneration"
                    exclude "**/ui/codegeneration/**"
                }
            }
	    }
	}
    dependencies {
        compile project(path: ':core', configuration: 'shadow')
        compile project(path: ':ui:preloader')
        ideProvider project(path: ':core', configuration: 'compile')
        compile group: 'org.controlsfx', name: 'controlsfx', version: '8.40.11'
        compile group: 'com.hierynomus', name: 'sshj', version: '0.16.0'
        compile group: 'org.apache.velocity', name: 'velocity', version: '1.7'
        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.5-alpha'
        testCompile group: 'org.testfx', name: 'testfx-junit', version: '4.0.5-alpha'
        testRuntime group: 'org.testfx', name: 'openjfx-monocle', version: '1.8.0_20'
        testCompile group: 'org.opencv', name: 'opencv-java', version: '3.1.0'
    }

    evaluationDependsOn(':core')
    evaluationDependsOn(':ui:preloader')
    if (System.getProperty("os.name").toLowerCase().contains("linux")) {
        jfxNative.dependsOn tasks.getByPath(':ui:linuxLauncher:linuxLauncherExecutable')
    }
    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']
        }
    }

    task testSharedLib() {
        description 'Compiles the shared library used by c++ generation testing.'
        doLast {
        def syst = osdetector.os
        if(syst == "windows") {
            exec {
                ignoreExitValue true//if clean hasn't been called, directory already exists and mkdir fails.
                workingDir 'build/classes/test'
                commandLine 'cmd', '/c', 'mkdir', 'pipelib'
            }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine '"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat"', 'amd64', '&', 'cmake', '-G', 'Visual Studio 14 2015 Win64', '..\\..\\..\\..\\src\\test\\resources\\edu\\wpi\\grip\\ui\\codegeneration\\tools\\'
           }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine '"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat"', 'amd64', '&', 'cmake', '--build', '.', '--target', 'ALL_BUILD', '--config', 'Release'
            }
            exec {
                workingDir 'build/classes/test'
                commandLine 'cmd', '/C', 'copy /Y pipelib\\Release\\* .'
            }
            exec {
                workingDir 'build/classes/test'
                commandLine 'cmd', '/C', 'copy /Y pipelib\\pipe\\Release\\* .'
            }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine 'cmd', '/C', 'copy /Y ..\\..\\..\\..\\src\\test\\resources\\edu\\wpi\\grip\\ui\\codegeneration\\tools\\pipe\\AbsPipeline.h pipe\\'
            }
            exec {
                workingDir 'build/classes/test'
                commandLine 'cmd', '/C', 'copy /Y ..\\..\\..\\src\\test\\resources\\edu\\wpi\\grip\\ui\\codegeneration\\tools\\realpipe\\CMakeLists.txt .'
            }
        } else {
            exec {
                ignoreExitValue true//if clean hasn't been called, directory already exists and mkdir fails.
                workingDir 'build/classes/test'
                commandLine 'mkdir', 'pipelib'
            }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine 'cmake' , '../../../../src/test/resources/edu/wpi/grip/ui/codegeneration/tools/'
           }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine 'make'
            }
            exec {
                workingDir 'build/classes/test'
                if(syst == "osx"){
                    commandLine 'cp', 'pipelib/libgenJNI.dylib', '.'
                }
                if(syst == "linux"){
                    commandLine 'cp' , 'pipelib/libgenJNI.so', '.'
                }
            }
            exec {
                workingDir 'build/classes/test/pipelib'
                commandLine 'cp' , '../../../../src/test/resources/edu/wpi/grip/ui/codegeneration/tools/pipe/AbsPipeline.h', 'pipe/'
            }
            exec {
                workingDir 'build/classes/test'
                commandLine 'cp', '../../../src/test/resources/edu/wpi/grip/ui/codegeneration/tools/realpipe/CMakeLists.txt', '.'
            }
            }
        }
    }

    if(project.hasProperty('generation') || project.hasProperty('genonly')){
        def syst = osdetector.os
        test {
            Platform platform = Installer.getPlatform()
            Installer.setOpenCvVersion('3.1.0')
            def jniLocation = project.getProperties().getOrDefault('jniLocation', platform.defaultJniLocation())
            Installer.installJni("${jniLocation}")
            def defaultLibPath = System.getProperty('java.library.path');
            jvmArgs = ["-Djava.library.path=${defaultLibPath}${System.getProperty('path.separator')}${jniLocation}"]
            if(project.hasProperty('genonly')){
                useJUnit {
                    includeCategories 'edu.wpi.grip.ui.codegeneration.GenerationTesting'
                }
            }
        }
    }

    jfx {
        mainClass = "edu.wpi.grip.ui.Main"
        preLoader = "edu.wpi.grip.preloader.GripPreloader"

        identifier = "GRIP"
        appName = "GRIP"
        vendor = "Worcester Polytechnic Institute"
        nativeReleaseVersion = "${getVersionSimple()}-${arch}"

        jfxMainAppJarName = "${jfx.appName}-${jfx.nativeReleaseVersion}.jar"

        // -XX:-OmitStackTraceInFastThrow 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
        // -Xmx limits the heap size. This prevents memory use from ballooning with a lot
        // of JavaCV native objects being allocated hanging around waiting to get GC'd.
        // -XX:MaxNewSize limits the size of the eden space to force minor GCs to run more often.
        // This causes old mats (which take up little space on the heap but a lot of native memory) to get deallocated
        // and free up native memory quicker, limiting the memory the app takes up.
        jvmArgs = ["-XX:-OmitStackTraceInFastThrow", "-Xmx200m", "-XX:MaxNewSize=32m"]

        bundleArguments = [
                "linux.launcher.url": file('linuxLauncher/build/exe/linuxLauncher/linuxLauncher').toURI().toURL()
        ]
    }
    mainClassName = jfx.mainClass
}


configure([
        project(":core"),
        project(":ui"),
        project(":ui:preloader")
]) {
    if (project.hasProperty('jvmArgs')) {
        run {
            jvmArgs = (project.jvmArgs.split("\\s+") as List)
        }
    }
    if (project.hasProperty('args')) {
        run {
            args = (project.args.split("\\s+") as List)
        }
    }
}

/*
 * 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'
    configure(subprojects - project(':ui:linuxLauncher')) {
        dependsOn(test)

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

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

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

task wrapper(type: Wrapper) {
    gradleVersion = '4.0.2'
    // We want the sources with the wrapper.
    distributionType = DistributionType.ALL
}