publish.gradle

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

// Java / publishing

java {
    // Configure the Java "software component" to include javadoc and sources jars in addition to the classes jar.
    // Ultimately, this component is what makes up the publication for this project.
    withJavadocJar()
    withSourcesJar()
}

jar {
    manifest {
        attributes(
                // Basic JAR manifest attributes
                'Specification-Title': project.name,
                'Specification-Version': project.version,
                'Specification-Vendor': 'Hibernate.org',
                'Implementation-Title': project.name,
                'Implementation-Version': project.version,
                'Implementation-Vendor': 'Hibernate.org',
                'Implementation-Vendor-Id': 'org.hibernate',
                'Implementation-Url': 'http://hibernate.org/reactive',
        )
    }
}

javadoc {
    if(JavaVersion.current().isJava9Compatible()) {
        options.addBooleanOption('html5', true)
    }
    options.addStringOption('Xdoclint:none', '-quiet')
}

publishing {
    publications {
        register( "publishedArtifacts", MavenPublication) {
            from components.java

            pom {
                name = project.mavenPomName
                description = project.description
                url = 'https://github.com/hibernate/hibernate-reactive'
                organization {
                    name = 'Hibernate.org'
                    url = 'https://hibernate.org'
                }
                licenses {
                    license {
                        name = 'Apache License Version 2.0'
                        url = 'https://opensource.org/licenses/Apache-2.0'
                        comments = 'See discussion at http://hibernate.org/community/license/ for more details.'
                        distribution = 'repo'
                    }
                }
                issueManagement {
                    system = 'github'
                    url = 'https://github.com/hibernate/hibernate-reactive/issues'
                }
                scm {
                    connection = 'scm:git:ssh://git@github.com/hibernate/hibernate-reactive.git'
                    developerConnection = 'scm:git:ssh://git@github.com/hibernate/hibernate-reactive.git'
                    url = 'https://github.com/hibernate/hibernate-reactive.git'
                }
                developers {
                    developer {
                        id = 'hibernate-team'
                        name = 'The Hibernate Development Team'
                        organization = 'Hibernate.org'
                        organizationUrl = 'https://hibernate.org'
                    }
                }
            }
        }
    }
}


// Signing

var signingExtension = project.getExtensions().getByType(SigningExtension) as SigningExtension

var publishingExtension = project.getExtensions().getByType(PublishingExtension) as PublishingExtension
signingExtension.sign publishingExtension.publications.publishedArtifacts

var signingKey = resolveSigningKey()
var signingPassphrase = resolveSigningPassphrase()
signingExtension.useInMemoryPgpKeys(signingKey, signingPassphrase)

gradle.taskGraph.whenReady { TaskExecutionGraph graph ->
    boolean wasPublishingRequested = false

    graph.allTasks.each {task ->
        if ( task instanceof PublishToMavenRepository ) {
            logger.lifecycle( "Found PublishToMavenRepository task : {}", task.path )
            wasPublishingRequested = true
        }
    }

    if ( wasPublishingRequested ) {
        def publishUser = resolvePublishUser()
        def publishPass = resolvePublishPass()
        if ( publishUser == null || publishPass == null ) {
            throw new RuntimeException( "Cannot perform publishing to OSSRH without credentials." )
        }

        logger.lifecycle "Publishing {} : {} : {}", project.group, project.name, project.version

        // require signing if publishing to OSSRH
        signingExtension.required = true
    }
    else if ( signingKey == null || signingPassphrase == null ) {
        tasks.withType( Sign ).each { t-> t.enabled = false }
    }
}


static String resolveSigningKey() {
    var key = System.getenv().get( "SIGNING_GPG_PRIVATE_KEY" )
    if ( key != null ) {
        return key
    }

    var keyFile = System.getenv().get( "SIGNING_GPG_PRIVATE_KEY_PATH" )
    if ( keyFile != null ) {
        return new File( keyFile ).text
    }

    return null
}

static String resolveSigningPassphrase() {
    return System.getenv().get( "SIGNING_GPG_PASSPHRASE" )
}

String resolvePublishUser() {
    var envVar = System.getenv().get( "ORG_GRADLE_PROJECT_sonatypeUsername" )
    if ( envVar != null ) {
        return envVar
    }

    def projectProp = projectPropOrNull( "sonatypeUsername" )
    if ( projectProp != null ) {
        return projectProp
    }

    return null
}

String resolvePublishPass() {
    var envVar = System.getenv().get( "ORG_GRADLE_PROJECT_sonatypePassword" )
    if ( envVar != null ) {
        return envVar
    }

    def projectProp = projectPropOrNull( "sonatypePassword" )
    if ( projectProp != null ) {
        return projectProp
    }

    return null
}

String projectPropOrNull(String name) {
    if ( project.hasProperty( name ) ) {
        return project.findProperty( name )
    }
    return null;
}