build.gradle

plugins {
    id "me.champeau.gradle.jmh" version "0.4.4"
    id "com.github.breadmoirai.github-release" version "1.0.9"
}
import org.gradle.internal.os.OperatingSystem;

apply from: 'version.gradle'
apply from: 'caplin-version-2.3.1.gradle'

apply plugin: 'java'
apply plugin: 'c'
apply plugin: 'maven-publish'

tasks.printVersion.execute()
defaultTasks 'printVersion'

repositories {
    mavenCentral()
    maven { url "http://artifactory.caplin.com/artifactory/caplin-ci/" }
}

configurations {
    distributables
    github
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    distributables files("lib/nanotime.dll");
    distributables files("lib/nanotime.dylib");
    distributables files("lib/nanotime.so");
    distributables files("lib/nanotime-ARM.so");

    github group: 'com.caplin.platform.components.codelibrary', name: 'nanotime', version: version, ext: 'jar'
}

sourceCompatibility = "1.8"
targetCompatibility = "1.8"

// Set up platform specific configuration
project.ext {
    jdkDir = System.getenv().JAVA_HOME

    distributableName = 'libnanotime'
    if (OperatingSystem.current().isWindows()) {
        headersDir = 'win32'
        extension = 'dll'
        platformClassifier = 'win64'
        distributableName = 'nanotime'
    } else if (OperatingSystem.current().isLinux()) {
        headersDir = 'linux'
        extension = 'so'
        platformClassifier = 'linux'
    } else if (OperatingSystem.current().isMacOsX()) {
        headersDir = 'darwin'
        extension = 'dylib'
        platformClassifier = 'darwin'
    } else {
        distributableName = 'libnanotime-ARM'
        headersDir = 'linux'
        extension = 'so'
        platformClassifier = 'linux'
    }
}

// Build the c distributable
model {
    platforms {
        x64 {
            architecture "x86_64"
        }
    }
    binaries {
        all {
            if (toolChain in VisualCpp) {
                cCompiler.define "WIN"
            }
            if (toolChain in Gcc) {
                linker.args "-lrt"
            }
        }
    }
    components {
        nanotime(NativeLibrarySpec) {
            targetPlatform "x64"
            sources {
                c {
                    source {
                        srcDir "src/native"
                        include "**/*.c"
                    }
                    exportedHeaders {
                        srcDirs "src/native", "$jdkDir/include", "$jdkDir/include/$headersDir"
                        include "**/*.h"
                    }
                }
            }
        }
    }
}

// Create a jar with the distributable for this platform
def nativeLibPath = "build/libs/nanotime/shared"
jar {
    into('native') {
        from nativeLibPath
        include '*.dll'
        include '*.so'
        include '*.dylib'
        rename { String fileName ->
            fileName.replace("libnanotime", "nanotime")
        }
    }
    classifier = platformClassifier
}
jar.dependsOn tasks.matching { it.name.startsWith("nanotime") }

// Configure the jmh harness.
jmh {
    timeUnit = 'ns'
}
jmhJar {
    into('native') {
        from nativeLibPath
        include '*.dll'
        include '*.so'
        include '*.dylib'
        rename { String fileName ->
            fileName.replace("libnanotime", "nanotime")
        }
    }
}
jmhJar.dependsOn tasks.matching { it.name.startsWith("nanotime") }

// Create a jar with the distributables from all platforms
task buildAllPlatformsJar(type: Jar) {
    from sourceSets.main.output
    into('native') {
        from configurations.distributables
        //rename { String fileName -> "nanotime." + fileName.tokenize('.').last() }
    }
}

// Copy the distributable to the resources/native directory in order to test it
task createTestNativeDependenciesDirectory(type: Copy, dependsOn: tasks.matching { it.name.startsWith("nanotime") }) {
    from nativeLibPath
    into 'build/resources/test/native'
    include '*.dll'
    include '*.so'
    include '*.dylib'
    rename { String fileName ->
        fileName.replace("libnanotime", "nanotime")
    }
}
test.dependsOn createTestNativeDependenciesDirectory

publishing {
    publications {
        // Publish the distributable for this platform
        distributable(MavenPublication) {
            groupId 'com.caplin.platform.components.codelibrary'
            artifactId 'nanotime'
            artifact file("$nativeLibPath/$distributableName.$extension")
        }

        // Publish the Jar with the distributables for all platforms
        allPlatformsJar(MavenPublication) {
            groupId 'com.caplin.platform.components.codelibrary'
            artifact tasks.buildAllPlatformsJar
        }
    }
}

afterEvaluate {
    tasks.withType(PublishToMavenRepository).all { publishTask ->
        // Make publishing the distributable dependent upon building the distributable
        publishTask.dependsOn { task ->
            if (task.name.contains('Distributable'))
                'test'
        }
    }
}

publishing {
    repositories {
        maven {
            url "http://artifactory.caplin.com/artifactory/caplin-ci/"
        }
    }
}

task gatherArtifact(type: Copy){
    from configurations.github
    into buildDir
}

githubRelease {

    if (!project.hasProperty("githubToken")) {
        project.ext.set('githubToken', '')
    }

    token = project.githubToken
    repo = "nanotime"
    owner = "caplin"
    tagName = "${project.version}"
    targetCommitish = "master"
    body = "Caplin Nanotime version ${version}"
    draft = true
    prerelease = false
    releaseAssets = fileTree('build/'){
        include "nanotime-${version}.jar"
    }
}