build.gradle

/*
 * Copyright (c) Terl Tech Ltd  • 04/04/2021, 00:07 • goterl.com
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at http://mozilla.org/MPL/2.0/.
 */

plugins {
    id 'java-library'
    id 'application'
    id 'idea'
    id 'com.github.johnrengelman.shadow' version '5.1.0'
    id 'signing'
    id 'maven'
    id 'maven-publish'
    id 'biz.aQute.bnd.builder'
}

ext {
    artifactId = "resource-loader"
    groupId = "com.goterl"
    version = '2.0.2'
    description = "Resource Loader gives you the functions to load resource files inside or outside JARs."
}


group project.ext.groupId
version = project.ext.version
mainClassName = "com.goterl.resourceloader.Main"
sourceCompatibility = 1.8
targetCompatibility = 1.8


repositories {
    mavenCentral()
}

dependencies {
    implementation "org.slf4j:slf4j-api:2.0.0-alpha1"
    implementation "net.java.dev.jna:jna:5.9.0"

    testImplementation "org.assertj:assertj-core:3.21.0"
    testImplementation "org.testng:testng:7.4.0"
    testImplementation "org.mockito:mockito-core:4.1.0"
    testImplementation "net.jodah:concurrentunit:0.4.6"
    testImplementation 'ch.qos.logback:logback-classic:1.2.9'
}


test {
    useTestNG()
    scanForTestClasses = false
    testLogging {
        showStandardStreams = true
        events "passed", "skipped", "failed"
    }
}


jar {
    manifest {
        attributes(
            'Main-Class': 'com.goterl.resourceloader.Main',
            "-exportcontents": "com.goterl.resourceloader.*",
            "-sources": true
        )
    }
}

void loadProps() {
    File secretPropsFile = project.rootProject.file('local.properties')
    if (secretPropsFile.exists()) {
        Properties p = new Properties()
        new FileInputStream(secretPropsFile).withCloseable { is ->
            p.load(is)
        }
        p.each { name, value ->
            ext[name] = value
        }
    } else {
        ext.isCi = true
    }
}

loadProps()


// Return an empty string if a property
// cannot be found
String getProp(String propName) {
    return ext.hasProperty(propName) == null ? "" : ext[propName]
}

String getPropBool(String propName) {
    return ext.hasProperty(propName) == null ? false : ext[propName]
}

String getSonatypeUserName() {
    return findProperty("ossrhUsername")
}

String getSonatypePassword() {
    return findProperty("ossrhPassword")
}

boolean isCi() {
    return getPropBool("isCi")
}

String getSigningKey() {
    return ext.signingKey
}

String getSigningKeyId() {
    return ext.signingKeyId
}

String getSigningPassword() {
    return ext.signingPassword
}

signing {
    useGpgCmd()
    sign publishing.publications
}

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
}

task signPom(type: Sign) {
    sign project.file("$buildDir/publications/mavenJava/pom-default.xml")

    // The signing plugin does not seem to notice
    // it when the publications folder with the
    // signature has been deleted. So we always
    // create a new signature
    outputs.upToDateWhen { false }
}

artifacts {
    archives sourcesJar, javadocJar
}

Closure createPomClosure = {
    def root = asNode()
    root.appendNode('description', project.ext.description)
    root.appendNode('name', project.ext.artifactId)
    root.appendNode('url', 'https://github.com/terl/resource-loader')

    def scm = root.appendNode('scm')
    scm.appendNode("connection", "scm:git:git://github.com/terl/resource-loader.git")
    scm.appendNode("developerConnection", "scm:git:ssh://github.com/terl/resource-loader")
    scm.appendNode("url", "http://github.com/terl/resource-loader")

    def license = root.appendNode('licenses').appendNode('license')
    license.appendNode('name', 'MIT')
    license.appendNode('url', 'https://opensource.org/licenses/MIT')
    license.appendNode('distribution', 'repo')

    def developer = root.appendNode('developers').appendNode('developer')
    developer.appendNode('name', 'Terl Tech Ltd')
    developer.appendNode('email', 'hello@terl.co')
}

publishing {
    publications {
        snapshot(MavenPublication) {
            from components.java
            groupId project.ext.groupId
            artifactId project.ext.artifactId
            version project.ext.version + "-SNAPSHOT"
            artifact sourcesJar
            artifact javadocJar

            pom.withXml createPomClosure
        }
        release(MavenPublication) {
            from components.java
            groupId project.ext.groupId
            artifactId project.ext.artifactId
            version project.ext.version
            artifact sourcesJar
            artifact javadocJar

            pom.withXml createPomClosure
        }
    }

    repositories {
        maven {
            name = "release"
            url = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
            credentials {
                username getSonatypeUserName()
                password getSonatypePassword()
            }
        }
        maven {
            name = "snapshot"
            url = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
            credentials {
                username getSonatypeUserName()
                password getSonatypePassword()
            }
        }
    }
}

// Force character encoding in case the workspace was not set up correctly
tasks.withType(Javadoc) {
    options.encoding = 'UTF-8'
}

tasks.withType(Test) {
    // a collection to track failedTests
    ext.failedTests = []

    afterTest { descriptor, result ->
        if (result.resultType == TestResult.ResultType.FAILURE) {
            String failedTest = "${descriptor.className}::${descriptor.name}"
            logger.debug("Adding " + failedTest + " to failedTests...")
            failedTests << [failedTest]
        }
    }

    afterSuite { suite, result ->
        if (!suite.parent) { // will match the outermost suite
            // logs each failed test
            if (!failedTests.empty) {
                logger.lifecycle("Failed tests:")
                failedTests.each { failedTest ->
                    logger.lifecycle("${failedTest}")
                }
            }
        }
    }
}