build.gradle

plugins {
    id 'java-library'
    id 'maven-publish'
    id 'signing'
}

group = 'com.jsontypedef.jtd'
version = '0.2.2'

// Install dependencies from Maven Central only. This is important, because we
// in turn will deploy to Maven Central. Depending on Maven Central means that
// libraries that depend on us can depend solely on Maven Central if they
// desire.
//
// Since most other repositories will pull down Maven Central too, this ends up
// being the most flexible option for users.
repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.code.gson:gson:2.8.6'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.10.3'
    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.10.3'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.1'
}

// Have the "assemble" task produce -javadoc.jar and -sources.jar libraries.
java {
    withSourcesJar()
    withJavadocJar()
}

// Have the "test" task produce a report at: build/reports/tests/test/index.html
test {
    useJUnitPlatform()
}

publishing {
    // Declare mavenJava, a Maven (as opposed to e.g. Ivy) publication.
    publications {
        mavenJava(MavenPublication) {
            // The java-library plugin defines the components.java
            // SoftwareComponent that makes up most of our publication.
            from components.java

            // Although Gradle/java-library does most of the work, there are
            // certain things in the generated POM file that need to be
            // customized. The Maven Central repository has additional
            // requirements.
            pom {
                name = 'JSON Type Definition'
                description = 'A Java implementation of JSON Type Definition validation'
                url = 'https://github.com/jsontypedef/json-typedef-java'

                licenses {
                    license {
                        name = 'The MIT License'
                        url = 'https://opensource.org/licenses/MIT'
                    }
                }

                developers {
                    developer {
                        id = 'ucarion'
                        name = 'Ulysse Carion'
                        email = 'ulysse@segment.com'
                    }
                }

                scm {
                    connection = 'scm:git:https://github.com/jsontypedef/json-typedef-java'
                    developerConnection = 'scm:git:https://github.com/jsontypedef/json-typedef-java'
                    url = 'https://github.com/jsontypedef/json-typedef-java'
                }
            }
        }
    }

    // Declare mavenCentral, a Maven repository. This is the usual Maven Central
    // repository.
    repositories {
        maven {
            name = 'mavenCentral'
            url = 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'

            credentials {
                username = findProperty('JTD_MAVEN_CENTRAL_USERNAME')
                password = findProperty('JTD_MAVEN_CENTRAL_PASSWORD')
            }
        }
    }
}

// Always sign the mavenJava publication, which is what we deploy to Maven
// Central. Signing publications is a requirement for Maven Central.
signing {
    // Use an in-memory key and password, so that we can more easily sign
    // artifacts from CI, where setting up GPG is comparably difficult.
    //
    // Under the hood, the signing key was created using:
    //
    // gpg --armor --export-secret-keys KEYID
    //
    // And the password is an additional level of security.
    def signingKey = findProperty('JTD_MAVEN_CENTRAL_GPG_SIGNING_KEY')
    def signingPassword = findProperty('JTD_MAVEN_CENTRAL_GPG_SIGNING_PASSWORD')
    useInMemoryPgpKeys(signingKey, signingPassword)

    sign publishing.publications.mavenJava
}