hibernate-orm/build.gradle

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

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

buildscript {
    repositories {
        mavenCentral()
        mavenLocal()
        mavenRepo name: 'jboss-nexus', url: "https://repository.jboss.org/nexus/content/groups/public/"
        mavenRepo name: "jboss-snapshots", url: "http://snapshots.jboss.org/maven2/"
    }
    dependencies {
        classpath 'org.hibernate.build.gradle:gradle-upload-auth-plugin:1.1.1'
    }
}

idea {
    project {
        jdkName = "1.6"
        ipr {
            withXml { provider ->
                provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'
                def maxHeapSizeConfig =  provider.node.component.find { it.@name == 'JavacSettings' }
                if( maxHeapSizeConfig == null ){
                    def javacSettingsNode =  provider.node.appendNode('component',[name: 'JavacSettings'])
                    javacSettingsNode.appendNode('option', [name:"MAXIMUM_HEAP_SIZE", value:"512"])
                }
            }
            beforeMerged { project ->
                project.modulePaths.clear()
            }
        }
    }
    module {
        name = "hibernate-orm"
    }
}

// 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.6.1'
junitVersion = '4.10'
h2Version = '1.2.145'
bytemanVersion = '1.5.2'

libraries = [
        // Ant
        ant:            'org.apache.ant:ant:1.8.2',

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

        // Annotations
        commons_annotations:
                        'org.hibernate.common:hibernate-commons-annotations:4.0.1.Final@jar',
        jandex:         'org.jboss:jandex:1.0.3.Final',
        classmate:      'com.fasterxml:classmate:0.5.4',

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

        // Javassist
        javassist:      'org.javassist:javassist:3.15.0-GA',

        // javax
        jpa:            'org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.0.Draft-7plus',
        jta:            'org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:1.0.0.Final',
        validation:     'javax.validation:validation-api:1.0.0.GA',
        jacc:           'org.jboss.spec.javax.security.jacc:jboss-jacc-api_1.4_spec:1.0.0.Final',

        // logging
        logging:        'org.jboss.logging:jboss-logging:3.1.0.GA',
        logging_processor:  'org.jboss.logging:jboss-logging-processor:1.0.0.Final',

        // jaxb task
        jaxb:           'com.sun.xml.bind:jaxb-xjc:2.1.6',
        jaxb2_basics:   'org.jvnet.jaxb2_commons:jaxb2-basics:0.6.0',
        jaxb2_ant:      'org.jvnet.jaxb2_commons:jaxb2-basics-ant:0.6.0',
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~ testing

        // logging for testing
        slf4j_api:      "org.slf4j:slf4j-api:${slf4jVersion}",
        slf4j_log4j12:  "org.slf4j:slf4j-log4j12:${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',


        junit:           "junit:junit:${junitVersion}",
        byteman:         "org.jboss.byteman:byteman:${bytemanVersion}",
        byteman_install: "org.jboss.byteman:byteman-install:${bytemanVersion}",
        byteman_bmunit:  "org.jboss.byteman:byteman-bmunit:${bytemanVersion}",
        jpa_modelgen:    'org.hibernate:hibernate-jpamodelgen:1.1.1.Final',
        shrinkwrap_api:  'org.jboss.shrinkwrap:shrinkwrap-api:1.0.0-beta-6',
        shrinkwrap:      'org.jboss.shrinkwrap:shrinkwrap-impl-base:1.0.0-beta-6',
        validator:       'org.hibernate:hibernate-validator:4.2.0.Final',
        h2:              "com.h2database:h2:${h2Version}"
]


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

    defaultTasks 'build'

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

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

        configurations {
            provided {
                // todo : need to make sure these are non-exported
                description = 'Non-exported compile-time dependencies.'
            }
            jbossLoggingTool {
                description = "Dependencies for running the JBoss logging AnnotationProcessor tool"
            }
            hibernateJpaModelGenTool {
                description = "Dependencies for running the Hibernate JPA Metamodel Generator AnnotationProcessor tool"
            }
            deployerJars {
                description = 'Jars needed for doing deployment to JBoss Nexus repo'
            }
            jaxb {
                description = 'Dependencies for running ant xjc (jaxb class generation)'
            }
            configurations {
                all*.exclude group: 'xml-apis', module: 'xml-apis'
            }

        }
        toolsJar = file("${System.getProperty('java.home')}/../lib/tools.jar")
        // appropriately inject the common dependencies into each sub-project
        dependencies {
            compile( libraries.logging )
            testCompile( libraries.junit )
            testCompile( libraries.byteman )
            testCompile( libraries.byteman_install )
            testCompile( libraries.byteman_bmunit )
            testCompile files( toolsJar )
            testRuntime( libraries.slf4j_api )
            testRuntime( libraries.slf4j_log4j12 )
            testRuntime( libraries.jcl_slf4j )
            testRuntime( libraries.jcl_api )
            testRuntime( libraries.jcl )
            testRuntime( libraries.javassist )
            testRuntime( libraries.h2 )
            jbossLoggingTool( libraries.logging_processor )
            hibernateJpaModelGenTool( libraries.jpa_modelgen )
            jaxb( libraries.jaxb )
            jaxb( libraries.jaxb2_basics )
            jaxb( libraries.jaxb2_ant )
            deployerJars "org.apache.maven.wagon:wagon-http:1.0"
        }

        aptDumpDir = subProject.file( "${buildDir}/tmp/apt" )

        sourceSets.main {
            compileClasspath += configurations.provided
        }

        sourceSets.all {
            originalJavaSrcDirs = java.srcDirs
            generatedLoggingSrcDir = file( "${buildDir}/generated-src/logging/${name}" )
            java.srcDir generatedLoggingSrcDir
        }

        task generateMainLoggingClasses(type: Compile) {
            classpath = compileJava.classpath + configurations.jbossLoggingTool
            source = sourceSets.main.originalJavaSrcDirs
            destinationDir = aptDumpDir
            options.define(
                    compilerArgs: [
                            "-nowarn",
                            "-proc:only",
                            "-encoding", "UTF-8",
                            "-processor", "org.jboss.logging.processor.apt.LoggingToolsProcessor",
                            "-s", "$sourceSets.main.generatedLoggingSrcDir.absolutePath",
                            "-AloggingVersion=3.0",
                            "-source", "1.6",
                            "-target", "1.6",
                            "-AtranslationFilesPath=${project.rootDir}/src/main/resources"

                    ]
            );
            outputs.dir sourceSets.main.generatedLoggingSrcDir;
            doFirst {
//                source = sourceSets.main.originalJavaSrcDirs
                sourceSets.main.generatedLoggingSrcDir.mkdirs()
            }
        }

        // for the time being eat the annoying output from running the annotation processors
        generateMainLoggingClasses.logging.captureStandardError(LogLevel.INFO)

        compileJava.dependsOn generateMainLoggingClasses
        compileJava.options.define(compilerArgs: ["-proc:none", "-encoding", "UTF-8"])
        compileTestJava.options.define(compilerArgs: ["-proc:none", "-encoding", "UTF-8"])

        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.output.classesDir
            }
        } )

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

        targetCompatibility = "1.6"
        sourceCompatibility = "1.6"

        idea {
            module {
                iml {
                    beforeMerged { module ->
                        module.dependencies.clear()
                        module.excludeFolders.clear()
                    }
                    whenMerged { module ->
                        module.dependencies*.exported = true
                        module.excludeFolders += module.pathFactory.path(file(".gradle"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/bundles"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/classes"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/dependency-cache"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/libs"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/reports"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/test-results"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/tmp"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/matrix"))
                        module.excludeFolders += module.pathFactory.path(file("$buildDir/resources"))
                        module.excludeFolders -= module.pathFactory.path(file("$buildDir"))
                    }
                }
                downloadSources = true
                scopes.COMPILE.plus += configurations.provided
            }
        }

        eclipse {
            classpath {
                plusConfigurations.add( configurations.provided )
            }
        }

        // elements used to customize the generated POM used during upload
        def pomConfig = {
            name 'A Hibernate Core Module'
            description 'A module of the Hibernate Core project'
            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/license for more details.'
                    distribution 'repo'
                }
            }
            developers {
                developer {
                    id 'hibernate-team'
                    name 'The Hibernate Development Team'
                    organization 'Hibernate.org'
                    organizationUrl 'http://hibernate.org'
                }
            }
        }

        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 output 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 = '1.0-milestone-8a'
}