build.gradle

/**
 * This is a gradle multi project build that works with GitHub Actions to publish
 * release branch commits to mavenCentral.
 *
 * You can browse published artifacts here: https://repo1.maven.org/maven2/io/inversion/inversion-api/
 *
 * The following examples/articles were super helpful in figuring all fo this out
 *   - https://docs.gradle.org/current/userguide/signing_plugin.html
 *   - https://github.com/gradle-nexus/publish-plugin/
 *   - https://central.sonatype.org/publish/publish-guide/
 *
 */

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.netflix.nebula:gradle-aggregate-javadocs-plugin:3.0.1'
    }
}

plugins {
    id "java-library"
    id "maven-publish"
    id "signing"
	//-- publishes to OSSRH and on to mavenCentral
    id("io.github.gradle-nexus.publish-plugin") version "1.1.0"
	//-- provides the "dependencyUpdates" task that reports available updates for your dependencies
    id "com.github.ben-manes.versions" version "${dependencyUpdatesVersion}"
}
apply plugin: 'nebula-aggregate-javadocs'


/**
 * The gradle-aggregate-javadocs-plugin generates a combined
 * javadoc for all subprojects but as of this writing, the
 * plugin did not seem to offer the ability to change the output
 * directory.  Running 'allJavadocs' instead of 'aggregateJavadocs' 
 * will generate the combined docs and put them into /docs/javadoc
 * where they can be checked into github and served up from
 * github pages.
 */
task allJavadocs {
    dependsOn 'aggregateJavadocs'
    doLast {
        ant.delete(dir: 'docs/javadoc/')
        //ant.move(file: 'build/docs/javadoc/', tofile: 'docs/javadoc/')
    }
}

tasks.withType(Javadoc) {
    failOnError false
    title = "Inversion Cloud API Engine - " + project.version
}

//regenerate javadocs after a build	
build.finalizedBy(allJavadocs)

allprojects {

    group = 'io.inversion'
    def isSnapshot = Boolean.valueOf(System.getProperty("snapshot"))
    project.version = project.version + (isSnapshot ? "-SNAPSHOT" : "")

    //required for generating comprehensive javadocs with
    //gradle-aggregate-javadocs-plugin and not failing on error
    tasks.withType(Javadoc) {
        failOnError false
        options.bottom = "Copyright &#169; ${java.time.Year.now()} <a href=\"http://rocketpartners.io\">Rocket Partners, LLC</a>. All rights reserved."
    }

}

nexusPublishing {
    repositories {
        sonatype()
    }
}

subprojects {

    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    //./gradlew printSubDependencies --configuration runtimeClasspath
    task printSubDependencies(type: DependencyReportTask) {}

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }

    /*
    test {
        exclude '**'
    }
    */

    repositories {
        mavenCentral()
    }

    signing {
        def signingKeyId = findProperty("signingKeyId")
        def signingKey = findProperty("signingKey")
        def signingPassword = findProperty("signingPassword")
        useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
        sign publishing.publications
    }

    dependencies {
        testImplementation "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
    }

    javadoc.failOnError = false
    task javadocJar(type: Jar) {
        classifier = 'javadoc'
        from javadoc
    }

    task sourcesJar(type: Jar) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    artifacts {
        archives javadocJar, sourcesJar
    }


    //keeps integration test that require access to external systems
    //from running as part of the standard CICD pipeline build
    //run intergration tests via:  ./gradlew test -Dtest.profile=integration
    test {
        useJUnitPlatform()
        if (System.properties['test.profile'] != 'integration') {
            exclude '**/*IntegTest*'
        }
        testLogging {
            outputs.upToDateWhen { false }
            showStandardStreams = true
        }
    }

    //causes a new ${subpoject}/pom.xml file to be generated after each build
    gradle.buildFinished { buildResult ->
        if (Boolean.valueOf(System.getProperty("release"))) {
            tasks.generatePomFileForMavenJavaPublication.doGenerate()
        }

    }
    project.getGradle().getTaskGraph().whenReady {
        tasks.withType(GenerateMavenPom.class) {
            destination = file("$buildDir/../pom.xml")
        }
    }


    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifactId = project.name
                from components.java
                artifact sourcesJar
                artifact javadocJar

                //-- the following will generate poms with resolved dependencies
                //-- instead of potentially dynamic dependencies declared in the gradle build
                //-- https://docs.gradle.org/current/userguide/publishing_maven.html
                versionMapping {
                    usage('java-api') {
                        fromResolutionOf('runtimeClasspath')
                    }
                    usage('java-runtime') {
                        fromResolutionResult()
                    }
                }

                pom {
                    name = project.name
                    description = 'Inversion Cloud API Engine'
                    url = 'https://inversion.io'
                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    developers {
                        developer {
                            name = 'Wells Burke'
                            email = 'wells@inversion.io'
                            organization = 'inversion.io'
                            organizationUrl = 'https://inversion.io'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/inversion-api/inversion-engine.git'
                        developerConnection = 'scm:git:ssh://github.com:inversion-api/inversion-engine.git'
                        url = 'https://github.com/inversion-api/inversion-engine/'
                    }
                }
            }
        }
    }
}