hibernate-orm/build.gradle

apply plugin: 'eclipse'
apply plugin: 'idea'

allprojects {
    repositories {
        mavenCentral()
        mavenLocal()
        mavenRepo name: 'jboss-nexus', urls: "https://repository.jboss.org/nexus/content/groups/public/"
        mavenRepo name: "jboss-snapshots", urls: "http://snapshots.jboss.org/maven2/"
    }
}

ideaProject {
    javaVersion = "1.6"
    withXml { provider ->
        def node = provider.asNode()
        def vcsConfig = node.component.find { it.'@name' == 'VcsDirectoryMappings' }
        vcsConfig.mapping[0].'@vcs' = 'Git'
    }
}

ideaModule {
}

// build a map of the dependency artifacts to use.  Allows centralized definition of the version of artifacts to
// use.  In that respect it serves a role similar to <dependencyManagement> in Maven
slf4jVersion = '1.5.8'
libraries = [
        // Ant
        ant:            'ant:ant:1.6.5',

        // Antlr
        antlr:          'antlr:antlr:2.7.7',

        // Annotations
        commons_annotations:
                        'org.hibernate:hibernate-commons-annotations:3.2.0.Final',

        // CGLIB
        cglib:          'cglib:cglib:2.2',

        // Jakarta commons-collections  todo : get rid of commons-collections dependency
        commons_collections:
                        'commons-collections:commons-collections:3.1',

        // Dom4J
        dom4j:          'dom4j:dom4j:1.6.1@jar',

        // h2
        h2:             'com.h2database:h2:1.2.145',

        // Javassist
        javassist:      'javassist:javassist:3.12.0.GA',

        // javax
        jpa:            'org.hibernate.javax.persistence:hibernate-jpa-2.0-api:1.0.0.Final',
        jta:            'javax.transaction:jta:1.1',
        validation:     'javax.validation:validation-api:1.0.0.GA',
        validator:      'org.hibernate:hibernate-validator:4.0.2.GA',
        jacc:           'org.jboss.javaee:jboss-jacc-api:1.1.0.GA',

        // logging
        logging:        'org.jboss.logging:jboss-logging:3.0.0.Beta5',
        logging_tools:  'org.jboss.logging:jboss-logging-tools:1.0.0.Beta4',
        slf4j_api:      'org.slf4j:slf4j-api:' + slf4jVersion,
        slf4j_simple:   'org.slf4j:slf4j-simple:' + slf4jVersion,
        jcl_slf4j:      'org.slf4j:jcl-over-slf4j:' + slf4jVersion,
        jcl_api:        'commons-logging:commons-logging-api:99.0-does-not-exist',
        jcl:            'commons-logging:commons-logging:99.0-does-not-exist',

        // testing
        atomikos:       'com.atomikos:transactions-jdbc:3.7.0',
        junit:          'junit:junit:3.8.2',
        testng:         'org.testng:testng:5.8:jdk15',
        jpa_modelgen:   'org.hibernate:hibernate-jpamodelgen:1.1.1.Final',
        shrinkwrap_api: 'org.jboss.shrinkwrap:shrinkwrap-api:1.0.0-alpha-6',
        shrinkwrap:     'org.jboss.shrinkwrap:shrinkwrap-impl-base:1.0.0-alpha-6'
]


subprojects { subProject ->
    apply plugin: 'idea'
	apply plugin: 'eclipse'

    defaultTasks 'build'

    group = 'org.hibernate'
    version = '4.0.0-SNAPSHOT'

    // minimize changes, at least for now (gradle uses 'build' by default)..
    buildDir = "target"
    
    if ( ! subProject.name.startsWith( 'release' ) ) {
        apply plugin: 'java'
        apply plugin: 'maven' // for install task as well as deploy dependencies
        apply plugin: org.hibernate.build.gradle.upload.UploadAuthenticationManager

        configurations {
            provided {
                // todo : need to make sure these are non-exported
                description = 'Non-exported compile-time dependencies.'
            }
            deployerJars {
                description = 'Jars needed for doing deployment to JBoss Nexus repo'
            }
        }

        // appropriately inject the common dependencies into each sub-project
        dependencies {
		    compile( libraries.logging )
		    compile( libraries.logging_tools )
            compile( libraries.slf4j_api )
            testCompile( libraries.junit )
            testCompile( libraries.atomikos )
            testRuntime( libraries.slf4j_simple )
            testRuntime( libraries.jcl_slf4j )
            testRuntime( libraries.jcl_api )
            testRuntime( libraries.jcl )
            testRuntime( libraries.javassist )
            testRuntime( libraries.h2 )
            deployerJars "org.apache.maven.wagon:wagon-http:1.0-beta-6"
        }
        
		generatedSrcDirName = buildDirName + "/generated-src/main/java"
		generatedSrcDir = dir( generatedSrcDirName )
		
		task compileJavaAnnotations(type: Compile, dependsOn: generatedSrcDir) {
		    classpath = compileJava.classpath
		    source = compileJava.source
		    destinationDir = compileJava.destinationDir
		    options.define(compilerArgs: ["-proc:only", "-s", "$generatedSrcDir.dir.absolutePath"])
		}

		compileJava.dependsOn compileJavaAnnotations
		compileJava.source += fileTree(generatedSrcDirName)
 		compileJava.options.define(compilerArgs: ["-proc:none"])
        
		generatedTestSrcDirName = buildDirName + "/generated-src/test/java"
		generatedTestSrcDir = dir( generatedTestSrcDirName )

		task compileTestJavaAnnotations(type: Compile, dependsOn: generatedTestSrcDir) {
		    classpath = compileTestJava.classpath
		    source = compileTestJava.source
		    destinationDir = compileTestJava.destinationDir
		    options.define(compilerArgs: ["-proc:only", "-s", "$generatedTestSrcDir.dir.absolutePath"])
		}

		compileTestJava.dependsOn compileTestJavaAnnotations
		compileTestJava.source += fileTree(generatedTestSrcDirName)
 		compileTestJava.options.define(compilerArgs: ["-proc:none"])

        sourceSets {
            main {
                compileClasspath += configurations.provided
            }
        }

        manifest.mainAttributes(
                provider: 'gradle',
                'Implementation-Url': 'http://hibernate.org',
                'Implementation-Version': version,
                'Implementation-Vendor': 'Hibernate.org',
                'Implementation-Vendor-Id': 'org.hibernate'
        )

        test {
            systemProperties['hibernate.test.validatefailureexpected'] = true
            maxHeapSize = "1024m"
        }

        processTestResources.doLast( {
            copy {
                from( sourceSets.test.java.srcDirs ) {
                    include '**/*.properties'
                    include '**/*.xml'
                }
                into sourceSets.test.classesDir
            }
        } )

        assemble.doLast( { install } )
        uploadArchives.dependsOn install

        targetCompatibility = "1.6"
        sourceCompatibility = "1.6"

        ideaModule {
            // treat our "provided" configuration dependencies as "compile" scope dependencies in IntelliJ
            scopes.COMPILE.plus.add( configurations.provided )
            whenConfigured { module ->
                module.dependencies*.exported = true
            }
	        testSourceDirs.add( file( generatedSrcDirName ) )
	        testSourceDirs.add( file( generatedTestSrcDirName ) )
        }
		eclipseClasspath {
			plusConfigurations.add( configurations.provided )
		}

        // elements used to customize the generated POM used during upload
        def pomConfig = {
            url 'http://hibernate.org'
            organization {
                name 'Hibernate.org'
                url 'http://hibernate.org'
            }
            issueManagement {
                system 'jira'
                url 'http://opensource.atlassian.com/projects/hibernate/browse/HHH'
            }
            scm {
                url "http://github.com/hibernate/hibernate-core"
                connection "scm:git:http://github.com/hibernate/hibernate-core.git"
                developerConnection "scm:git:git@github.com:hibernate/hibernate-core.git"
            }
            licenses {
                license {
                    name 'GNU Lesser General Public License'
                    url 'http://www.gnu.org/licenses/lgpl-2.1.html'
                    comments 'See discussion at http://hibernate.org/356.html for more details.'
                    distribution 'repo'
                }
            }
            developers {
            }
        }

        subProject.basePomConfig = pomConfig

        configure(install.repositories.mavenInstaller) {
            pom.project pomConfig
        }

        uploadArchives {
            repositories.mavenDeployer {
                name = 'jbossDeployer'
                configuration = configurations.deployerJars
                pom.project pomConfig
                repository(id: "jboss-releases-repository", url: "https://repository.jboss.org/nexus/service/local/staging/deploy/maven2/")
                snapshotRepository(id: "jboss-snapshots-repository", url: "https://repository.jboss.org/nexus/content/repositories/snapshots")
            }
        }

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

        artifacts {
            archives sourcesJar
        }

        uploadArchives.dependsOn sourcesJar
    }

}

dependsOnChildren()

// This is a task that generates the gradlew scripts, allowing users to run gradle without having gradle installed
// on their system.
// This task should be run by "build master" and the resulting ouput committed to source control.  Its outputs include:
//  1) /gradlew which is the *NIX shell script for executing builds
//  2) /gradlew.bat which is the windows bat script for for executing builds
//  3) /wrapper which is a directory named by the "jarPath" config which contains other needed files.
task wrapper(type: Wrapper) {
    gradleVersion = '0.9.2'
}