build.gradle

import groovyx.net.http.RESTClient

import static groovyx.net.http.ContentType.JSON

buildscript {
    repositories {
        mavenLocal()
        maven { url "https://repo.grails.org/grails/core" }
    }
    dependencies {
        classpath "org.codehaus.groovy.modules.http-builder:http-builder:0.7.1"
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4"
        classpath 'com.bmuschko:gradle-nexus-plugin:2.3.1'
        // classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.5.3"
        classpath "io.github.groovylang.groovydoc:groovydoc-gradle-plugin:1.0.1"
        classpath "org.grails:grails-gradle-plugin:$grailsVersion"
        classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.9.2'
        classpath "gradle.plugin.com.energizedwork.webdriver-binaries:webdriver-binaries-gradle-plugin:$webdriverBinariesVersion"
    }
}

plugins {
    id 'com.gradle.build-scan' version '1.16'
}


group "org.grails"
//version "7.1.0.M2"
version "7.1.0.BUILD-SNAPSHOT"
logger.info("GORM VERSION = ${project.gormVersion}")

ext {
    isTravisBuild = System.getenv().get("TRAVIS") == 'true'
    isCiBuild = project.hasProperty("isCiBuild")
    isBuildSnapshot = version.endsWith("BUILD-SNAPSHOT")
    nexusUsername = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
    nexusPassword = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
}

allprojects { project ->
    buildScan {
        termsOfServiceUrl = 'https://gradle.com/terms-of-service'
        termsOfServiceAgree = 'yes'

        publishAlways()
    }
}

subprojects { project ->

    repositories {
        maven { url "https://repo.grails.org/grails/core" }
        if(groovyVersion && groovyVersion.endsWith('-SNAPSHOT')) {
            maven {
                name 'JFrog OSS snapshot repo'
                url 'https://oss.jfrog.org/oss-snapshot-local/'
            }
        }
    }

    configurations.all {
        resolutionStrategy.dependencySubstitution {
            substitute module("org.codehaus.groovy:groovy-all") with module("org.codehaus.groovy:groovy:$groovyVersion")
        }
    }

    if(project.name.startsWith("examples-")) {
        if(project.name.startsWith("examples-grails")) {
            apply plugin:"org.grails.grails-web"
            apply plugin:"org.grails.grails-gsp"            
        }
        configurations.all {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                if(details.requested.group == 'org.codehaus.groovy' && details.requested.name.startsWith('groovy')) {
                    details.useVersion(groovyVersion)
                }
                if(details.requested.group == 'org.springframework') {
                    details.useVersion(springVersion)
                }
                if (details.requested.group == "org.springframework.boot") {
                    details.useVersion(springBootVersion)
                }
                if (details.requested.group == "org.grails" && details.requested.name.contains("testing-support")) {
                    details.useVersion(testingSupportVersion)
                }
            }
        }
        boolean usesGeb = project.name.contains('examples-grails') 
        if (usesGeb) {
            apply plugin:"com.energizedwork.webdriver-binaries"
        }

        apply plugin: "java"

        dependencies {
            testCompile "org.codehaus.groovy:groovy-test-junit5:$groovyVersion"
            testCompile("org.spockframework:spock-core:$spockVersion") { transitive = false}
            testCompile "org.junit.jupiter:junit-jupiter-api:5.6.0"
            testCompile "org.junit.platform:junit-platform-runner:1.6.0"
            testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.6.0"
        }

        apply from: "${rootProject.projectDir}/gradle/testVerbose.gradle"
        return
    }

    boolean isPluginProject = project.name.endsWith("-plugin") && (project.name.startsWith("grails") || project.name.startsWith("rx-"))
    boolean isGrails3PluginProject = project.name.endsWith("-plugin")

    ext {
        projectInfo = new PublishingConvention(project)
        pomInfo = {
            delegate.name projectInfo.projectName
            delegate.description projectInfo.projectDescription
            delegate.url projectInfo.projectURL

            delegate.licenses {
                delegate.license {
                    delegate.name 'The Apache Software License, Version 2.0'
                    delegate.url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    delegate.distribution 'repo'
                }
            }

            delegate.scm {
                delegate.url projectInfo.projectVcsUrl
                delegate.connection projectInfo.projectVcsUrl
                delegate.developerConnection projectInfo.projectVcsUrl
            }


            delegate.developers {
                delegate.developer {
                    delegate.id 'graemerocher'
                    delegate.name 'Graeme Rocher'
                }
                delegate.developer {
                    delegate.id 'jeffscottbrown'
                    delegate.name 'Jeff Brown'
                }
                delegate.developer {
                    delegate.id 'burtbeckwith'
                    delegate.name 'Burt Beckwith'
                }
            }

        }
    }

    configurations {
        documentation
    }

    // Uncomment below code to force refresh dependencies
    /*configurations.all {
            resolutionStrategy {
                cacheDynamicVersionsFor 0, 'hours'
                cacheChangingModulesFor 0, 'hours'
            }
    }*/

    if(isPluginProject) {
        group "org.grails.plugins"
        version project.rootProject.version - '.RELEASE'
    }
    else {
        group "org.grails"
        version project.rootProject.version
    }

    if(project.name == 'docs') {
        return
    }       

    if(isGrails3PluginProject) {
        apply plugin: "org.grails.grails-plugin"       
    }
    else {
        apply plugin:"groovy"
        apply plugin: 'com.bmuschko.nexus'

        modifyPom {
            delegate.project pomInfo
        }
    }

    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.bintray'
    if(!isGrails3PluginProject) {
        apply plugin: "io.github.groovylang.groovydoc"
        groovydoc.jvmArgs "-Xmx512M"
    }

    sourceCompatibility = "1.8"
    targetCompatibility = "1.8"

    dependencies {
        documentation "org.fusesource.jansi:jansi:$jansiVersion"
        documentation "org.codehaus.groovy:groovy-dateutil:$groovyVersion"
        documentation 'info.picocli:picocli:3.8.2'

        testCompile "org.codehaus.groovy:groovy-test-junit5:$groovyVersion"
        testCompile("org.spockframework:spock-core:$spockVersion") { transitive = false}
        testCompile "org.junit.jupiter:junit-jupiter-api:5.6.0"
        testCompile "org.junit.platform:junit-platform-runner:1.6.0"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.6.0"
        documentation "info.picocli:picocli:$picocliVersion"
    }

    apply from: "${rootProject.projectDir}/gradle/testVerbose.gradle"

    groovydoc.classpath += configurations.documentation

    publishing {

        repositories {
            maven {
                credentials {
                    def u = System.getenv("ARTIFACTORY_USERNAME") ?: project.hasProperty("artifactoryPublishUsername") ? project.artifactoryPublishUsername : ''
                    def p = System.getenv("ARTIFACTORY_PASSWORD") ?: project.hasProperty("artifactoryPublishPassword") ? project.artifactoryPublishPassword : ''
                    username = u
                    password = p
                }
                if(isGrails3PluginProject) {
                    if(isBuildSnapshot) {
                        url  "https://repo.grails.org/grails/plugins3-snapshots-local"
                    }
                    else {
                        url  "https://repo.grails.org/grails/plugins3-releases-local"
                    }                    
                }
                else {
                    if(isBuildSnapshot) {
                        url  "https://repo.grails.org/grails/libs-snapshots-local"
                    }
                    else {
                        url  "https://repo.grails.org/grails/libs-releases-local"
                    }
                }
            }
        }

        publications {
            maven(MavenPublication) {
                artifactId projectInfo.projectArtifactId

                from components.java
                afterEvaluate {
                    artifact source: sourcesJar, classifier: "sources"
                    artifact source: javadocJar, classifier: "javadoc"

                    if(isGrails3PluginProject) {
                        artifact source:"${sourceSets.main.groovy.outputDir}/META-INF/grails-plugin.xml",
                                classifier:"plugin",
                                extension:'xml'
                    }
                }
                pom.withXml {
                    def xml = asNode()
                    def dependency = xml.dependencies.find { dep -> dep.artifactId == 'slf4j-simple' }
                    dependency?.optional = true
                    xml.children().last() + pomInfo
                }

            }
        }
    }   
    bintray {
        def u = System.getenv("BINTRAY_USER") ?: project.hasProperty("bintrayUser") ? project.bintrayUser : ''
        def p = System.getenv("BINTRAY_KEY") ?: project.hasProperty("bintrayKey") ? project.bintrayKey : ''

        user = u
        key = p
        publications = ['maven']
        publish = true
        dryRun = false
        pkg {
            if(isGrails3PluginProject) {
                repo = 'plugins'
            }
            else {
                repo = 'grails-core'
            }
            userOrg = 'grails'
            name = projectInfo.projectArtifactId
            desc = projectInfo.projectDescription
            websiteUrl = projectInfo.projectURL
            issueTrackerUrl = projectInfo.projectIssueTrackerUrl
            vcsUrl = projectInfo.projectVcsUrl
            licenses = ['Apache-2.0']
            publicDownloadNumbers = true
            version {
                name = project.version
                gpg {
                    sign = true
                    passphrase = System.getenv("SIGNING_PASSPHRASE") ?: project.hasProperty("signingPassphrase") ? project.signingPassphrase : ''
                }
                mavenCentralSync {
                    sync = false
                    def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
                    def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
                    user = ossUser
                    password = ossPass
                }

            }
        }
    }

    if (!isGrails3PluginProject) {
        def bintrayUser = System.getenv("BINTRAY_USER") ?: project.hasProperty("bintrayUser") ? project.bintrayUser : ''
        def bintrayKey = System.getenv("BINTRAY_KEY") ?: project.hasProperty("bintrayKey") ? project.bintrayKey : ''
        def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
        def ossPass = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''

        task synchronizeWithMavenCentral() {
            description = "Syncs with Maven Central/Sonatype"
            doLast {
                println """
Synchronizing with Maven central. This may take a few minutes ...
If this fails, log on to http://oss.sonatype.org/ using the centralUser credentials
and progress through process manually -> Close -> Publish ... under staging repositories
"""
                try {
                    try {
                        def mavenClent = new RESTClient("https://repo.maven.apache.org/maven2/")
                        mavenClent.get(path:"${project.group.replace('.','/')}/$project.name/$project.version/$project.name-${project.version}.jar")
                    } catch(groovyx.net.http.HttpResponseException e) {
                        // doesn't exist.. try sync
                        def client = new RESTClient('https://api.bintray.com/maven_central_sync/grails/grails-core/')
                        client.headers['Authorization'] = 'Basic ' + "$bintrayUser:$bintrayKey".getBytes('iso-8859-1').encodeBase64()
                        def body = /{}/
                        def resp = client.post(
                                path: "$bintray.pkg.name/versions/$project.version",
                                body: body,
                                requestContentType: JSON
                        )
                        assert resp.status == 200
                        println resp.data.status
                        println resp.data.messages.join('\n')
                    }
                } catch (groovyx.net.http.HttpResponseException e) {
                    println "Error: $e"
                    println "Message: $e.message"
                    println "Body: $e.response.data"
                    throw e
                }
            }
        }
    }
}

class PublishingConvention {
    Project project

    String projectArtifactId
    String projectName = 'GORM for Hibernate 5'
    String projectDescription = 'Provides a GORM Object Mapping implementations for Hibernate 5'
    String projectURL = 'https://gorm.grails.org/latest/hibernate'
    String projectIssueTrackerUrl = 'https://github.com/grails/gorm-hibernate5/issues'
    String projectVcsUrl = 'https://github.com/grails/gorm-hibernate5'

    PublishingConvention(Project project) {
        this.project = project

        def name = project.name
        if(name.startsWith('grails') && name.endsWith('-plugin')) {
            name = 'hibernate5'
        }
        projectArtifactId = name
    }
}