build.gradle

import org.gradle.internal.os.OperatingSystem

plugins {
    id 'java'
    id 'jacoco'
    id 'signing'
    id 'checkstyle'
    id 'java-library'
    id 'maven-publish'
    id "io.morethan.jmhreport" version "0.9.0"
    id 'com.github.kt3k.coveralls' version '2.12.2'
    id "io.github.gradle-nexus.publish-plugin" version "1.3.0"
    id 'io.franzbecker.gradle-lombok' version '5.0.0'
}

ext {
    depVersions = [
            lombok      : '1.18.30',
            jna         : '5.13.0',
            commonsLang3: '3.14.0',
            jsr305      : '3.0.2'
    ]
    testDepVersions = [
            junitPlatform: '1.10.1',
            junit        : '5.10.1'
    ]
    benchmarkDepVersions = [
            commonsIO: '2.15.0',
            jmh      : '1.37'
    ]
    nexus = [
            target  : project.findProperty("nexus.target") ?: System.getenv("NEXUS_TARGET") ?: 'SNAPSHOT',
            username: project.findProperty('nexus.username') ?: System.getenv("NEXUS_USERNAME"),
            password: project.findProperty("nexus.password") ?: System.getenv("NEXUS_PASSWORD"),
    ]
    signing = [
            gpgPrivateKey: project.findProperty("signing.gpg.privateKey") ?: System.getenv("GPG_PRIVATE_KEY"),
            gpgPassphrase: project.findProperty("signing.gpg.passphrase") ?: System.getenv("GPG_PASSPHRASE")
    ]
}

group 'org.sheinbergon'
version '2.1.0'

repositories {
    mavenCentral()
}

sourceSets {
    benchmark
}

dependencies {
    // JNA
    api "net.java.dev.jna:jna:${depVersions.jna}"

    // Utility
    api "org.apache.commons:commons-lang3:${depVersions.commonsLang3}"
    api "com.google.code.findbugs:jsr305:${depVersions.jsr305}"

    // Lombok
    compileOnly "org.projectlombok:lombok:${depVersions.lombok}"

    // Junit 5
    testCompileOnly "org.projectlombok:lombok:${depVersions.lombok}"
    testImplementation "org.junit.jupiter:junit-jupiter-api:${testDepVersions.junit}"
    testImplementation "org.junit.jupiter:junit-jupiter-engine:${testDepVersions.junit}"
    testImplementation "org.junit.platform:junit-platform-launcher:${testDepVersions.junitPlatform}"

    // JMH Benchmarking
    benchmarkImplementation project
    benchmarkImplementation "org.openjdk.jmh:jmh-core:${benchmarkDepVersions.jmh}"
    benchmarkAnnotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${benchmarkDepVersions.jmh}"
    benchmarkImplementation "commons-io:commons-io:${benchmarkDepVersions.commonsIO}"
}

sourceCompatibility = JavaVersion.VERSION_11

test {

    systemProperties = ['jna.debug_load': false]
    afterSuite { desc, result ->
        if (!desc.parent) {
            println ""
            println "Test result: ${result.resultType}"
            println "Test summary: ${result.testCount} tests, " +
                    "${result.successfulTestCount} succeeded, " +
                    "${result.failedTestCount} failed, " +
                    "${result.skippedTestCount} skipped"
        }
    }

    useJUnitPlatform()
    testLogging {
        exceptionFormat = 'full'
        showStandardStreams = true
        events "passed", "skipped", "failed"
    }
    finalizedBy jacocoTestReport

}

jacoco {
    toolVersion = '0.8.9'
}

checkstyle {
    toolVersion '10.12.5'
    configFile file("$rootDir/checkstyle.xml")
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required = true
        csv.required = false
        html.required = true
    }
}


coveralls {
    jacocoReportPath "$buildDir/reports/jacoco/test/jacocoTestReport.xml"
}

afterEvaluate {
    // Ensure snapshot versions defer from release ones
    version = nexus.target.equals('SNAPSHOT') ? "$version-${nexus.target}" : version

    // Set the DLL library path
    def task = tasks.getByName('test')
    def libPath = project.hasProperty('libPath') ? project.properties['libPath'] : System.properties['java.library.path']
    task.systemProperty "jna.library.path", libPath

    // Setup signing based on nexus-target
    signing {
        required { nexus.target == 'RELEASE' }
        useInMemoryPgpKeys(signing.gpgPrivateKey, signing.gpgPassphrase)
        publishing.publications.forEach {
            sign(it)
        }
    }
}

jmhReport {
    jmhResultPath = project.file('build/reports/benchmark/result.json')
    jmhReportOutput = project.file('build/reports/benchmark')
}

task jmh(type: JavaExec, description: 'Executing JMH benchmarks') {

    doFirst {
        def aacEncBin = project.properties.getOrDefault('aacEncBin', "/usr/bin/aac-enc")
        assert file(aacEncBin).exists()
        assert OperatingSystem.current().isLinux()
        systemProperties = ['benchmark.aac.enc.bin': aacEncBin, 'jna.debug_load': true]
    }

    classpath = sourceSets.benchmark.runtimeClasspath
    main = 'org.openjdk.jmh.Main'
    def format = project.properties.getOrDefault('format', 'json')
    def resultFile = file("build/reports/benchmark/result.${format}")
    resultFile.parentFile.mkdirs()

    args 'Benchmark.*'
    args '-rf', format
    args '-rff', resultFile
}

jar {
    archiveClassifier.set('')
    from sourceSets.main.output
    from("$resources") {
        include '*.dll'
        include '*.so'
        include '*.so.*'
        include '*.dylib'
    }
    from("$projectDir") {
        include 'NOTICE'
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier.set('sources')
    from sourceSets.main.allSource
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    archiveClassifier.set('javadoc')
    from javadoc.destinationDir
}

publishing {
    publications {
        maven(MavenPublication) {
            from components.java
            artifactId = "jna-aac-encoder"
            artifact tasks.javadocJar
            artifact tasks.sourcesJar
            pom {
                name = project.name
                description = 'AAC encoding capabiltiies for the JVM'
                url = 'https://github.com/sheinbergon/jna-aac-encoder'
                inceptionYear = '2018'

                licenses {
                    license {
                        name = 'Apache License 2.0'
                        url = 'https://github.com/sheinbergon/jna-aac-encoder/blob/master/LICENSE'
                        distribution = 'repo'
                    }
                }

                developers {
                    developer {
                        id = 'sheinbergon'
                        name = 'Idan Sheinberg'
                        email = 'ishinberg0@gmail.com'
                    }
                }
                scm {
                    url = 'https://github.com/sheinbergon/jna-aac-encoder'
                    connection = 'scm:https://github.com/sheinbergon/jna-aac-encoder.git'
                    developerConnection = 'scm:git@github.com:sheinbergon/jna-aac-encoder.git'
                }
            }

            repositories {
                mavenLocal()
                maven {
                    name "oss-sonatype-nexus"
                    url nexus.url
                    credentials {
                        username = nexus.username
                        password = nexus.password
                    }
                }
            }
        }
    }
}

wrapper {
    gradleVersion = '8.4'
}

nexusPublishing {
    transitionCheckOptions {
        maxRetries.set(100)
        delayBetween.set(Duration.ofSeconds(5))
    }
    useStaging = (provider { "${nexus.target}".toString() == "RELEASE" })
    repositories {
        sonatype {
            username = nexus.username
            password = nexus.password
        }
    }
}