build.gradle

import edu.wpi.first.nativeutils.NativeUtils
import edu.wpi.first.nativeutils.tasks.JNIHeaders

buildscript {
    repositories {
        mavenLocal()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath 'gradle.plugin.edu.wpi.first:native-utils:1.5.1'
    }
}

plugins {
    id 'net.ltgt.errorprone' version '0.0.10'
    id 'edu.wpi.first.wpilib.versioning.WPILibVersioningPlugin' version '2.0'
    id 'idea'
}

ext.licenseFile = file("$rootDir/LICENSE.txt")

ext.getJNIHeadersClass = {
    return JNIHeaders
}

ext.getClassifier = { binary->
    return NativeUtils.getClassifier(binary)
}

ext.getPlatformPath = { binary->
    return NativeUtils.getPlatformPath(binary)
}

ext.createComponentZipTasks = { components, name, base, type, project, func ->
    def configMap = [:]
    components.each {
        if (it in NativeLibrarySpec && it.name == name) {
            it.binaries.each {
                def target = getClassifier(it)
                if (configMap.containsKey(target)) {
                    configMap.get(target).add(it)
                } else {
                    configMap.put(target, [])
                    configMap.get(target).add(it)
                }
            }
        }
    }
    def taskList = []
    def outputsFolder = file("$project.buildDir/outputs")
    def baseN = base + name
    configMap.each { key, value ->
        def task = project.tasks.create(baseN + "-${key}", type) {
            description = 'Creates component archive for platform ' + key
            destinationDir =  outputsFolder
            classifier = key
            baseName = baseN + '-classifier'
            duplicatesStrategy = 'exclude'

            from(licenseFile) {
                into '/'
            }

            func(it, value)
        }
        taskList.add(task)

        project.build.dependsOn task

        project.artifacts {
            task
        }
    }
    return taskList
}

ext.createAllCombined = { list, name, base, type, project ->
    def outputsFolder = file("$project.buildDir/outputs")
    def baseN = base + name
    def task = project.tasks.create(baseN + '-all', type) {
        description = 'Creates component archive for all classifiers'
        destinationDir = outputsFolder
        classifier = 'all'
        baseName = baseN + '-classifier'
        duplicatesStrategy = 'exclude'

        list.each {
            it.outputs.files.each {
                from project.zipTree(it)
            }
            dependsOn it
        }
    }

    project.build.dependsOn task

    project.artifacts {
        task
    }

    return task

}

ext.includeStandardZipFormat = { task, value ->
    value.each { binary->
        if (binary.buildable) {
            if (binary instanceof SharedLibraryBinarySpec) {
                task.dependsOn binary.buildTask
                task.from(new File(binary.sharedLibraryFile.absolutePath + ".debug")) {
                    into getPlatformPath(binary) + '/shared'
                }
                task.from (binary.sharedLibraryFile) {
                    into getPlatformPath(binary) + '/shared'
                }
                task.from (binary.sharedLibraryLinkFile) {
                    into getPlatformPath(binary) + '/shared'
                }
            } else if (binary instanceof StaticLibraryBinarySpec) {
                task.dependsOn binary.buildTask
                task.from (binary.staticLibraryFile) {
                    into getPlatformPath(binary) + '/static'
                }
            }
        }
    }
}

// Ensure that the WPILibVersioningPlugin is setup by setting the release type, if releaseType wasn't
// already specified on the command line
if (!hasProperty('releaseType')) {
    WPILibVersion {
        releaseType = 'dev'
    }
}

def pubVersion
if (project.hasProperty("publishVersion")) {
    pubVersion = project.publishVersion
} else {
    pubVersion = WPILibVersion.version
}

def outputsFolder = file("$buildDir/outputs")

def versionFile = file("$outputsFolder/version.txt")

task outputVersions() {
    description = 'Prints the versions of wpilib to a file for use by the downstream packaging project'
    group = 'Build'
    outputs.files(versionFile)

    doFirst {
        buildDir.mkdir()
        outputsFolder.mkdir()
    }

    doLast {
        versionFile.write pubVersion
    }
}

task build() {}

build.dependsOn outputVersions

task clean(type: Delete) {
    delete buildDir
}

subprojects {
    apply plugin: 'eclipse'
    apply plugin: 'idea'
    apply plugin: 'checkstyle'

    repositories {
        mavenCentral()
    }

    checkstyle {
        toolVersion = "8.1"
        configFile = new File(rootDir, "styleguide/checkstyle.xml")
    }

    // Disables doclint in java 8.
    if (JavaVersion.current().isJava8Compatible()) {
        tasks.withType(Javadoc) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
    }
    ext.setupWpilibRepo = { publishing ->
        publishing.repositories.maven {
            url = WPILibVersion.mavenLocalUrl
        }
    }
}

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