build.gradle

buildscript {
    repositories {
        mavenLocal()
        maven { url "https://repo.grails.org/grails/core" }
        jcenter()
    }
    dependencies {
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1.1"
        classpath "com.netflix.nebula:gradle-extra-configurations-plugin:2.2.0"
        classpath 'com.bmuschko:gradle-nexus-plugin:2.3'
    }
}

project.ext {
    springVersion = "4.1.5.RELEASE"
    grailsVersion = "3.0.0.BUILD-SNAPSHOT"
    slf4jVersion = "1.7.5"
    junitVersion = "4.12"
    groovyVersion = System.getProperty('groovyVersion') ?: '2.4.1'
    isTravisBuild = System.getenv().get("TRAVIS") == 'true'

    projectMajorVersion = "4"
    projectMinorVersion = "0"
    projectPatchVersion = "0"
//    releaseType = "M2"
    releaseType = "BUILD-SNAPSHOT"

    // overall project version
    projectVersion = "${projectMajorVersion}.${projectMinorVersion}.${projectPatchVersion}"

    // driver versions
    neo4jVersion = '2.0.3'

    // plugin versions
    hibernatePluginVersion = releaseType == 'RELEASE' ? "4.3.8.${projectPatchVersion}" : "4.3.8.${projectPatchVersion}.$releaseType"
    mongodbPluginVersion = releaseType == 'RELEASE' ? projectVersion : "${projectVersion}.${releaseType}"
    neo4jPluginVersion = "${projectVersion}.BUILD-SNAPSHOT"
    cassandraPluginVersion = "${projectVersion}.BUILD-SNAPSHOT"


    isCiBuild = project.hasProperty("isCiBuild")
    isBuildSnapshot = releaseType == "BUILD-SNAPSHOT"

    servletApiVersion = "3.0.1"

    nexusUsername = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''
    nexusPassword = System.getenv("SONATYPE_PASSWORD") ?: project.hasProperty("sonatypeOssPassword") ? project.sonatypeOssPassword : ''
}

def groovyMajorVersion = groovyVersion[0..2]
def spockDependency = "org.spockframework:spock-core:1.0-groovy-2.4"

def groovyProjects() {
    subprojects.findAll { project -> isGroovyProject(project) }
}

def isGroovyProject(project) {
    def isGrailsPlugin = project.name.contains("grails-plugins")
    def isDocumentation = project.name.contains("documentation")
    !isGrailsPlugin && !isDocumentation
}

configurations {
   all*.exclude group: "commons-logging"
}

apply plugin: 'idea'
apply plugin: 'project-report'


ext {
    isCiBuild = project.hasProperty("isCiBuild")

}
allprojects {
    repositories {
        mavenLocal()
        if(System.getProperty('useJbossNexus')) {
            // jboss-nexus contains Hibernate source code archives which aren't in maven central
            // usefull with eclipse and idea tasks, for example
            // ./gradlew -PuseJbossNexus cleanEclipse eclipse
            maven {
                name 'jboss-nexus'
                url "https://repository.jboss.org/nexus/content/groups/public/"
            }
        }
        maven { url "https://repo.grails.org/grails/core" }
        if(isBuildSnapshot) {
            maven { url "https://repo.grails.org/grails/libs-snapshots-local" }
        }
    }

    configurations {
        all {
            resolutionStrategy {
//                def cacheHours = isCiBuild ? 1 : 24
//                cacheDynamicVersionsFor cacheHours, 'hours'
//                cacheChangingModulesFor cacheHours, 'hours'
            }
        }
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.3'
}

subprojects {
   if(project.name.endsWith("spring-boot")) return
   afterEvaluate { project ->
        if (isGroovyProject(project)) {
            def hasSnapshotVersion = project.version.endsWith("-SNAPSHOT")
            if(isBuildSnapshot != hasSnapshotVersion) {
                throw new StopExecutionException("${project.name} has version \"${project.version}\" which is${isBuildSnapshot ? 'n\'t' : ''} a snapshot version. Current release type is ${releaseType}")
            }
        }
    }

    version = "${projectVersion}.${releaseType}"
    group = "org.grails"
    ext {
        pomInfo = {
            delegate.name 'Grails GORM'
            delegate.description 'GORM - Grails Data Access Framework'
            delegate.url 'http://grails.org/'

            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 'scm:git@github.com:grails/grails-data-mapping.git'
                delegate.connection 'scm:git@github.com:grails/grails-data-mapping.git'
                delegate.developerConnection 'scm:git@github.com:grails/grails-data-mapping.git'
            }


            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'
                }
            }

        }
    }


    def isStandardGroovyMavenProject = isGroovyProject(project)

    if (isStandardGroovyMavenProject) {
        apply plugin: 'groovy'
        apply plugin: 'eclipse'
        apply plugin: 'com.bmuschko.nexus'
        apply plugin: 'maven-publish'
        apply plugin: 'com.jfrog.bintray'
        apply plugin: 'idea'
        apply plugin: 'provided-base'
        apply plugin: 'optional-base'
        sourceCompatibility = "1.7"
        targetCompatibility = "1.7"
    }

    def isGormDatasource = project.name.startsWith("grails-datastore-gorm-") &&
                                !project.name.endsWith("tck") &&
                                !project.name.endsWith("plugin-support") &&
                                project.name != 'grails-datastore-gorm-hibernate-core'&&
                                project.name != 'grails-datastore-gorm-rest-client'


    def isDocumentationProject = project.name.startsWith("grails-documentation")

    dependencies {
        if (isStandardGroovyMavenProject) {
            compile group: 'org.codehaus.groovy', name: 'groovy', version: groovyVersion

            testCompile group: 'org.codehaus.groovy', name: 'groovy-test', version: groovyVersion

            testCompile "junit:junit:$junitVersion"
            testCompile (spockDependency) {
                exclude group:'junit',module:'junit-dep'
                exclude group:'org.codehaus.groovy',module:'groovy-all'
                exclude group:'org.hamcrest',module:'hamcrest-core'
                transitive = false
            }
        }

        if (project.name == "grails-datastore-gorm-tck") {
            compile spockDependency, {
                exclude group:'junit',module:'junit-dep'
                exclude group:'org.codehaus.groovy',module:'groovy-all'
                exclude group:'org.hamcrest',module:'hamcrest-core'
                transitive = false
            }
        }
    }

    if (isDocumentationProject) {
        configurations {
            documentation
        }
        dependencies {
            documentation group: 'org.grails', name: 'grails-docs', version: grailsVersion
            documentation group: 'org.codehaus.groovy', name: 'groovy-all', version: groovyVersion
            project(":grails-datastore-core")
            documentation "org.slf4j:jcl-over-slf4j:$slf4jVersion"
            documentation "org.slf4j:slf4j-api:$slf4jVersion"
            documentation "org.slf4j:slf4j-simple:$slf4jVersion"
        }
        task docs << {
            ant.taskdef (name: 'docs', classname : 'grails.doc.ant.DocPublisherTask') {
                classpath {
                    configurations.documentation.resolve().each { f ->
                        pathelement(location:f)
                    }
                }

            }
            ant.docs(src:"src/docs", dest:destinationDir, properties:"src/docs/doc.properties")
        }
        docs.ext.destinationDir = "${buildDir}/docs"


        task clean << {
            ant.delete(dir:buildDir)
        }
    }

    if (isGormDatasource) {
        dependencies {
            testCompile project(":grails-datastore-gorm-tck")
        }

        // We need to test against the TCK. Gradle cannot find/run tests from jars
        // without a lot of plumbing, so here we copy the class files from the TCK
        // project into this project's test classes dir so Gradle can find the test
        // classes and run them. See grails.gorm.tests.GormDatastoreSpec for on the TCK.

        // helper, used below.
        def toBaseClassRelativePathWithoutExtension = { String base, String classFile ->
            if (classFile.startsWith(base)) {
                def sansClass = classFile[0 .. classFile.size() - ".class".size() - 1]
                def dollarIndex = sansClass.indexOf('$')
                def baseClass = dollarIndex > 0 ? sansClass[0..dollarIndex - 1] : sansClass
                def relative = baseClass - base - '/'
                relative
            }
            else {
                null
            }
        }

        test {
            testLogging {
                exceptionFormat ='full'
            }
            if (isTravisBuild) {
                maxParallelForks = 2
                jvmArgs = ['-server', '-Xmx768M', '-XX:MaxPermSize=256m']
                forkEvery = 25
                afterSuite {
                    System.out.print('.')
                    System.out.flush()
                }
            } else {
                maxParallelForks = 4
                forkEvery = 100
                jvmArgs = ['-server', '-Xmx2048M', '-XX:MaxPermSize=256m']
            }
            if(System.getProperty("debug.tests")) {
                jvmArgs '-Xmx2g', '-Xdebug', '-Xnoagent', '-Djava.compiler=NONE',
                        '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005'
            }
        }
        test.doFirst {
            def tckClassesDir = project(":grails-datastore-gorm-tck").sourceSets.main.output.classesDir
            def thisProjectsTests = // surely there is a less hardcoded way to do this
            copy {
                from tckClassesDir
                into sourceSets.test.output.classesDir
                include "**/*.class"
                exclude { details ->
                    // Do not copy across any TCK class (or nested classes of that class)
                    // If there is a corresponding source file in the particular modules
                    // test source tree. Allows a module to override a test/helper.

                    def candidatePath = details.file.absolutePath
                    def relativePath = toBaseClassRelativePathWithoutExtension(tckClassesDir.absolutePath, candidatePath)

                    if (relativePath == null) {
                        throw new IllegalStateException("$candidatePath does not appear to be in the TCK")
                    }

                    project.file("src/test/groovy/${relativePath}.groovy").exists()
                }
            }
        }
    }

    if (isStandardGroovyMavenProject) {

        configure([javadoc]) {
            options.encoding "UTF-8"
            options.docEncoding "UTF-8"
            options.charSet "UTF-8"
            options.jFlags "-Xms64M", "-Xmx512M", "-XX:MaxPermSize=256m"
        }

        modifyPom {
            delegate.project {
                def updatePom = pomInfo.clone()
                updatePom.delegate = delegate
                updatePom()
            }
        }

        publishing {

            if(isBuildSnapshot) {
                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
                        }
                        url  "https://repo.grails.org/grails/libs-snapshots-local"
                    }
                }
            }

            publications {
                maven(MavenPublication) {
                    from components.java

                    artifact sourcesJar {
                        classifier "sources"
                    }
                    artifact javadocJar {
                        classifier "javadoc"
                    }

                    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']
            dryRun = false
            publish = false
            pkg {
                repo = 'grails-core'
                userOrg = 'grails'
                name = 'org.grails:grails-data-mapping'
                desc = 'Grails Data Mapping'
                websiteUrl = 'http://grails.org'
                issueTrackerUrl = 'http://jira.grails.org/browse/GRAILS'
                vcsUrl = 'http://jira.grails.org/browse/GRAILS'
                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
                    }

                }
            }
        }


    }
}

configurations {
    build
}

dependencies {
    build "com.cenqua.clover:clover:3.0.2"
    build "org.apache.ant:ant-junit:1.8.1"
    build "org.apache.ant:ant-nodeps:1.8.1"
}

task install(dependsOn: subprojects*.tasks*.withType(PublishToMavenLocal))

task coreApiDocs(type: Groovydoc) {
   def coreDocs = [ 'grails-datastore-core',
                    'grails-datastore-gorm',
                    'grails-datastore-gorm-hibernate-core',
                    'grails-datastore-gorm-hibernate4',
                    'grails-datastore-simple',
                    'grails-datastore-web',
                    'grails-datastore-gorm-test']
   def projs = subprojects.findAll { project -> coreDocs.contains(project.name) }
   source projs.collect { project -> project.sourceSets.main.allGroovy } + projs.collect { project -> project.sourceSets.main.allJava }
   destinationDir = new File(buildDir, 'docs/api')
   // Might need a classpath
   classpath = files(projs.collect {project -> project.sourceSets.main.compileClasspath})
   groovyClasspath = files(projs.collect {project -> project.sourceSets.main.compileClasspath})
}


task allDocs(dependsOn: [getTasksByName("docs", true),coreApiDocs]) << {
    def docTasks = getTasksByName("docs", true)
    def groovydocTasks = getTasksByName("groovydoc", true)
    def allDocsDir = "$buildDir/docs"
    mkdir allDocsDir
    def stores = []
    for(task in docTasks) {
        def dir = task.destinationDir
        def projectName = task.project.name
        if (projectName.endsWith("-core")) {
            mkdir "$allDocsDir/manual"

            copy {
                from dir
                into "$allDocsDir/manual"
            }
        }
        else {
            def storeName = projectName["grails-documentation-".size()..-1]
            stores << storeName
            def docsDir = "$allDocsDir/$storeName"
            mkdir docsDir
            def groovydocTask = groovydocTasks.find { it.project.name == "grails-datastore-$storeName" }
            if (groovydocTask == null) groovydocTask = groovydocTasks.find { it.project.name == "grails-datastore-gorm-$storeName" }
            if (groovydocTask != null) {
                mkdir "$docsDir/api"
                groovydocTask.actions.each { it.execute(groovydocTask) }
                copy {
                    from groovydocTask.destinationDir
                    into "$docsDir/api"
                }
            }
            mkdir "$docsDir/manual"
            copy {
                from dir
                into "$docsDir/manual"
            }
        }

        def engine = new groovy.text.SimpleTemplateEngine()
        def binding = [
            datastores:stores.collect { "<li><a href=\"$it/index.html\">GORM for ${it[0].toUpperCase()}${it[1..-1]}</a></li>" }.join(System.getProperty("line.separator"))
        ]
        def template = engine.createTemplate(new File("src/docs/resources/core.template")).make(binding)
        new File("$allDocsDir/index.html").text = template.toString()

        for(store in stores) {
            def index = "$allDocsDir/$store/index.html"
            def storeName = "${store[0].toUpperCase()}${store[1..-1]}".toString()
            binding = [
                datastore:storeName
            ]
            template = engine.createTemplate(new File("src/docs/resources/datastore.template")).make( binding )
            new File(index).text = template.toString()
        }
    }
}

task test(dependsOn: getTasksByName("test", true)) << {
    def reportsDir = "${buildDir}/reports"

    // Aggregate the test results
    ant.taskdef(
        name: 'junitreport2',
        classname: "org.apache.tools.ant.taskdefs.optional.junit.XMLResultAggregator",
        classpath: configurations.build.asPath
    )

    def testReportsDir = new File("${reportsDir}/tests")
    if (testReportsDir.exists()) {
        testReportsDir.deleteDir()
    }
    testReportsDir.mkdirs()

    ant.junitreport2(todir: testReportsDir) {
        subprojects.each {
            def testResultsDir = "${it.buildDir}/test-results"
            if (new File(testResultsDir).exists()) {
                fileset(dir: testResultsDir) {
                    include(name: "TEST-*.xml")
                }
            }
        }
        report(todir: testReportsDir)
    }

    // Aggregate the coverage results
    if (project.hasProperty("withClover")) {
        def db = "clover/clover.db"
        def mergedDb = "${buildDir}/${db}"
        def cloverReportsDir = "${reportsDir}/clover"
        ant.taskdef(resource: "cloverlib.xml", classpath: configurations.build.asPath)
        ant."clover-merge"(initstring: mergedDb) {
            subprojects.each {
                def projectCloverDb = "${it.buildDir}/${db}"
                if (new File(projectCloverDb).exists()) {
                    cloverdb(initstring: projectCloverDb)
                }
            }
        }
        ant."clover-report"(initstring: mergedDb) {
            current(outfile:"${cloverReportsDir}/clover.xml")
        }
        ant."clover-html-report"(initstring: mergedDb, outdir:"${cloverReportsDir}/html")
    }
}