build.gradle

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

    projectVersion = "4.0.0"
//        releaseType = "RELEASE"
    releaseType = "BUILD-SNAPSHOT"
    isCiBuild = project.hasProperty("isCiBuild")
    isBuildSnapshot = releaseType == "BUILD-SNAPSHOT"
}

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

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

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}")
            }
        }
    }

    if(!project.hasProperty("artifactoryPublishPassword") && System.getenv("ARTIFACTORY_PASSWORD")) {
        project.ext.artifactoryPublishPassword = System.getenv("ARTIFACTORY_PASSWORD")
    }


    version = "${projectVersion}.${releaseType}"
    group = "org.grails"


    def isStandardGroovyMavenProject = isGroovyProject(project)

    if (isStandardGroovyMavenProject) {
        apply plugin: 'groovy'
        apply plugin: 'eclipse'
        apply plugin: 'maven'
        apply plugin: 'idea'
        apply plugin: 'signing'
        sourceCompatibility = "1.6"
        targetCompatibility = "1.6"

/*        apply from: "file:${rootDir}/clover.gradle"*/

        install.doLast {
            def gradleArtifactCache = new File(gradle.gradleUserHomeDir, "cache")
            configurations.archives.artifacts.findAll { it.type == "jar" && !it.classifier }.each { artifact ->

                // Gradle's cache layout is internal and may change in future versions, this is written for gradle 1.0-milestone-3
                def artifactInCache = file("${gradleArtifactCache}/${project.group}/${project.name}/jars/${project.name}-${version}.jar")
                if (artifactInCache.parentFile.mkdirs()) {
                    artifactInCache.withOutputStream { destination ->  artifact.file.withInputStream { destination << it } }
                }
            }
        }
    }

    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) {
            groovy 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) {

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

        task javadocJar(type: Jar, dependsOn:javadoc) {
            classifier = 'javadoc'
            from javadoc.destinationDir
        }

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

        artifacts {
            archives jar
            archives sourcesJar
            archives javadocJar
        }

        signing {
            sign configurations.archives
            required { !isBuildSnapshot && gradle.taskGraph.hasTask(uploadArchives) }
        }

        configure(install.repositories.mavenInstaller) {
            pom.whenConfigured { pom ->
                def dependency = pom.dependencies.find { dep -> dep.artifactId == 'slf4j-simple' }
                dependency?.optional = true
            }
            pom.project {
                licenses {
                    license {
                        name 'The Apache Software License, Version 2.0'
                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        distribution 'http://github.com/SpringSource/grails-data-mapping/'
                    }
                }
            }
        }

        uploadArchives {
            description = "Does a maven deploy of archives artifacts"

            // add a configuration with a classpath that includes our s3 maven deployer
            configurations { deployerJars }
            dependencies {
                deployerJars "org.springframework.build.aws:org.springframework.build.aws.maven:3.0.0.RELEASE"
            }

            repositories.mavenDeployer {
                if(!isBuildSnapshot) {
                beforeDeployment { MavenDeployment deployment ->
                    signing.signPom(deployment)
                    }
                }

                if(project.hasProperty("sonatypeUsername")) {
                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: project.hasProperty("sonatypeUsername") ? project.sonatypeUsername : null,
                            password: project.hasProperty("sonatypePassword") ?  project.sonatypePassword : null)
                    }
                }
                if(project.hasProperty("artifactoryPublishUsername")) {
                    snapshotRepository(url: "https://repo.grails.org/grails/libs-snapshots-local") {
                    authentication(userName: project.hasProperty("artifactoryPublishUsername") ? project.artifactoryPublishUsername : null,
                            password: project.hasProperty("artifactoryPublishPassword") ?  project.artifactoryPublishPassword : null)
                }
                }

                pom.project {
                    name 'Grails GORM'
                    packaging 'jar'
                    description 'GORM - Grails Data Access Framework'
                    delegate.url 'http://grails.org/'

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

                    scm {
                        delegate.url 'scm:git@github.com:grails/grails-data-mapping.git'
                        connection 'scm:git@github.com:grails/grails-data-mapping.git'
                        developerConnection 'scm:git@github.com:grails/grails-data-mapping.git'
                    }

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

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

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 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)
    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"

            fileTree { from dir }.copy { 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) }
                fileTree { from groovydocTask.destinationDir }.copy { into "$docsDir/api"}
            }
            mkdir "$docsDir/manual"
            fileTree { from dir }.copy { into "$docsDir/manual" }
        }

        def engine = new groovy.text.SimpleTemplateEngine()
        def binding = [
            datastores:stores.collect { "<li><a href=\"http://grails.github.io/grails-data-mapping/$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")
    }
}