hibernate-orm/hibernate-core/hibernate-core.gradle

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
import groovy.xml.*
import org.apache.tools.ant.filters.ReplaceTokens
import org.gradle.plugins.ide.eclipse.model.SourceFolder
import org.gradle.plugins.ide.eclipse.model.Library
import org.apache.tools.ant.taskdefs.condition.Os
import java.io.StringWriter

apply from: rootProject.file( 'gradle/published-java-module.gradle' )
apply plugin: Antlr4Plugin
apply plugin: 'hibernate-matrix-testing'

apply plugin: 'org.hibernate.build.gradle.xjc'

description = 'Hibernate\'s core ORM functionality'

configurations {
    tests {
        description = 'Configuration for the produced test jar'
    }
	
	eclipseConfig {
	}
}

dependencies {
    compile( libraries.jpa )
    // Javassist is no longer the default enhancer but still required for other purposes, e.g. Scanning
    compile( libraries.javassist )
    compile( libraries.byteBuddy )
    compile( libraries.antlr )
    compile( libraries.jta )
    compile( libraries.jandex )
    compile( libraries.classmate )
    compile( libraries.activation )

    // We need dom4j for a number of things temporarily:
    //      1) (unsupported) EntityMode.DOM4J support
    //      2) Envers
    //      3) hibernate-commons-annotations
    compile( libraries.dom4j )
    compile( libraries.commons_annotations )
    antlr( libraries.antlr )

    // JAXB
    compile( libraries.jaxb_api )
    compile( libraries.jaxb_runtime )
    xjc( libraries.jaxb_runtime )
    xjc( libraries.jaxb_xjc )
    xjc( libraries.jaxb2_basics )
    xjc( libraries.jaxb2_basics_ant )
    xjc( libraries.activation )

    provided( libraries.jacc )
    provided( libraries.validation )
    provided( libraries.ant )
	eclipseConfig( compileOnly( libraries.ant ) )
	eclipseConfig( compileOnly( libraries.logging_annotations ) )
	eclipseConfig( runtime( libraries.junit ) )
	eclipseConfig( runtime( libraries.junit5_api ) )
	eclipseConfig( runtime( libraries.junit5_jupiter ) )
	eclipseConfig( runtime( libraries.junit5_params ) )
	eclipseConfig( runtime( libraries.junit_pcomms ) )

	runtime( libraries.junit5_vintage )
	runtime( libraries.junit5_jupiter )
	
    provided( libraries.cdi )

    testCompile( project(':hibernate-testing') )
    testCompile( libraries.shrinkwrap_api )
    testCompile( libraries.shrinkwrap )
    testCompile( libraries.jacc )
    testCompile( libraries.validation )
    testCompile( libraries.jandex )
    testCompile( libraries.classmate )
    testCompile( libraries.mockito )
    testCompile( libraries.mockito_inline )
    testCompile( libraries.jodaTime )

    testCompile( libraries.cdi ) {
        // we need to force it to make sure we influence the one coming from arquillian
        force=true
    }

    testCompile( libraries.validator ) {
        // for test runtime
        transitive = true
    }

    // for testing stored procedure support
    testCompile( libraries.derby )

    testRuntime( "org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final" )
    testRuntime( libraries.expression_language )
    testRuntime( 'jaxen:jaxen:1.1' )
    testRuntime( libraries.javassist )
    testRuntime( libraries.byteBuddy )
    testRuntime( libraries.weld )
    testRuntime( libraries.atomikos )
    testRuntime( libraries.atomikos_jta )
    testRuntime(libraries.wildfly_transaction_client)

    testAnnotationProcessor( project( ':hibernate-jpamodelgen' ) )

    testCompile libraries.arquillian_junit_container
    testCompile libraries.arquillian_protocol_servlet
    testCompile libraries.shrinkwrap_descriptors_api_javaee
    testCompile libraries.shrinkwrap_descriptors_impl_javaee
    testCompile libraries.wildfly_arquillian_container_managed

    testCompile libraries.jboss_ejb_spec_jar
    testCompile libraries.jboss_annotation_spec_jar
}

jar {
    manifest {
        mainAttributes( 'Main-Class': 'org.hibernate.Version' )

        instructionFirst 'Import-Package',
                         'javax.security.auth;resolution:=optional',
                         'javax.security.jacc;resolution:=optional',
                         'javax.validation;resolution:=optional',
                         'javax.validation.constraints;resolution:=optional',
                         'javax.validation.groups;resolution:=optional',
                         'javax.validation.metadata;resolution:=optional',
                         // TODO: Shouldn't have to explicitly list this, but the plugin
                         // generates it with a [1.0,2) version.
                         "javax.persistence;version=\"${project.jpaVersion.osgiName}\"",
                         // optionals
                         'javax.management;resolution:=optional',
                         'javax.naming.event;resolution:=optional',
                         'javax.naming.spi;resolution:=optional',
                         'org.apache.tools.ant;resolution:=optional',
                         'org.apache.tools.ant.taskdefs;resolution:=optional',
                         'org.apache.tools.ant.types;resolution:=optional',
                         '!javax.enterprise*',
                         'javax.enterprise.context.spi;resolution:=optional',
                         'javax.enterprise.inject.spi;resolution:=optional',
                         'javax.inject;resolution:=optional',
                         'net.bytebuddy.*;resolution:=optional',
                         // We must specify the version explicitly to allow Karaf
                         // to use an older version of JAXB (the only one we can use in Karaf)
                         "javax.xml.bind.*;version=\"${project.jaxbApiVersionOsgiRange}\""

//        // TODO: Uncomment once EntityManagerFactoryBuilderImpl no longer
//        // uses ClassLoaderServiceImpl.
//        instruction 'Export-Package',
//            'org.hibernate.boot.registry.classloading.internal',
//            '*'
    }
}

ext {
    jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
}

sourceSets.main {
    java.srcDir project.jaxbTargetDir
}

// resources inherently exclude sources
sourceSets.test.resources {
    setSrcDirs( ['src/test/java','src/test/resources'] )
}

idea {
    module {
        sourceDirs += file( "${buildDir}/generated-src/antlr/main" )
    }
}

cleanEclipse {
	project.delete '.externalToolBuilders'
	project.delete 'hibernate-core-RunnableIdeTest.launch'
}

tasks.eclipse.dependsOn(cleanEclipse)

eclipse {
	project {
		file {
			withXml { provider ->
				//println('name:')
				//println(name)
				def projectDescriptionNode = provider.asNode()
				def buildSpecNode = projectDescriptionNode.children().find { child -> child.name(  ).equals('buildSpec') }
				def buildCommandSW = new StringWriter()
				def buildCommandXml = new MarkupBuilder(new IndentPrinter(buildCommandSW, "  ", true))
				buildCommandXml.doubleQuotes = true
				buildCommandXml.buildCommand(  ) {
					//[java - Groovy's MarkupBuilder exception on generating "id" XML tag - Stack Overflow](https://stackoverflow.com/a/14284927/1350308)
					"${'name'}"( "org.eclipse.ui.externaltools.ExternalToolBuilder" ) { }
					triggers( 'auto,full,incremental,' )
					arguments(  ) {
						dictionary(  ) {
							key ( 'LaunchConfigHandle' )
							value ( '<project>/.externalToolBuilders/gradlew_process_test_resources.launch' )
						}
						dictionary(  ) {
							key ( 'incclean' )
							value ( true )
						}
					}
				}
				def buildCommandNode = new XmlParser().parseText( buildCommandSW.toString() )
				//println('strWriter:')
				//println(buildCommandSW.toString())
				buildSpecNode.append( buildCommandNode )
			}
		}
	}
	mkdir '.externalToolBuilders'
	file('.externalToolBuilders/gradlew_process_test_resources.launch').withWriter { writer ->
		// Create MarkupBuilder with 4 space indent
		def xml = new MarkupBuilder(new IndentPrinter(writer, "  ", true))

		xml.doubleQuotes = true
		xml.mkp.xmlDeclaration(version: '1.0', encoding: 'utf-8', standalone: 'no')
		xml.launchConfiguration( type: 'org.eclipse.ui.externaltools.ProgramBuilderLaunchConfigurationType' ) {
			stringAttribute( key: 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE', value: "${project.name}" )
			booleanAttribute( key: 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND', value: 'false' )
			
			if (Os.isFamily(Os.FAMILY_WINDOWS)) {
				stringAttribute( key: 'org.eclipse.ui.externaltools.ATTR_LOCATION', value: file('../gradlew.bat').absolutePath )
			} else {
				stringAttribute( key: 'org.eclipse.ui.externaltools.ATTR_LOCATION', value: file('../gradlew').absolutePath )
			}
			booleanAttribute( key: 'org.eclipse.debug.core.ATTR_REFRESH_RECURSIVE', value: false )
			stringAttribute(
					key: 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE',
					value: '\${working_set:<?xml version="1.0" encoding="UTF-8"?>\n' +
					'<resources>\n' +
					'<item path="/' + "${project.name}" + '/src/test/bundles" type="2"/>\n' +
					'<item path="/' + "${project.name}" + '/src/test/resources" type="2"/>\n' +
					'</resources>}'
					)
			booleanAttribute( key: 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND', value: false )
			stringAttribute(
				key: 'org.eclipse.ui.externaltools.ATTR_BUILD_SCOPE',
				value: '\${working_set:<?xml version="1.0" encoding="UTF-8"?>\n' +
                       '<resources>\n' +
                       '<item path="/' + "${project.name}" + '/src/test/bundles" type="2"/>\n' +
                       '<item path="/' + "${project.name}" + '/src/test/resources" type="2"/>\n' +
                       '</resources>}'
			)
			stringAttribute( key: 'org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS', value: 'incremental,auto,' )
			stringAttribute( key: 'org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS', value: 'hibernate-core:processTestResources --no-daemon' )
			booleanAttribute( key: 'org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED', value: true )
			stringAttribute( key: 'org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY', value: file('../').absolutePath )
		}
		xml.mkp.comment("AUTO-GENERATED FILE.  DO NOT MODIFY. This is generated by gradle eclipse task")
	}
	file('hibernate-core-RunnableIdeTest.launch').withWriter { writer ->
		// Create MarkupBuilder with 4 space indent
		def xml = new MarkupBuilder(new IndentPrinter(writer, "  ", true))

		xml.doubleQuotes = true
		xml.mkp.xmlDeclaration(version: '1.0', encoding: 'utf-8', standalone: 'no')
		xml.launchConfiguration( type: 'org.eclipse.jdt.junit.launchconfig' ) {
			listAttribute( key: 'org.eclipse.debug.core.MAPPED_RESOURCE_PATHS' ) {
				listEntry( value: "${project.name}" )				
			}
			listAttribute( key: 'org.eclipse.debug.core.MAPPED_RESOURCE_TYPES' ) {
				listEntry( value: '4' )
			}
			stringAttribute( key: 'org.eclipse.jdt.junit.CONTAINER', value: "=${project.name}" )
			stringAttribute( key: 'org.eclipse.jdt.junit.EXCLUDE_TAGS', value: '' )
			booleanAttribute( key: 'org.eclipse.jdt.junit.HAS_EXCLUDE_TAGS', value: false )
			booleanAttribute( key: 'org.eclipse.jdt.junit.HAS_INCLUDE_TAGS', value: true )
			stringAttribute( key: 'org.eclipse.jdt.junit.INCLUDE_TAGS', value: 'RunnableIdeTest' )
			booleanAttribute( key: 'org.eclipse.jdt.junit.KEEPRUNNING_ATTR', value: false )
			stringAttribute( key: 'org.eclipse.jdt.junit.TESTNAME', value: '' )
			stringAttribute( key: 'org.eclipse.jdt.junit.TEST_KIND', value: 'org.eclipse.jdt.junit.loader.junit5' )
			stringAttribute( key: 'org.eclipse.jdt.launching.MAIN_TYPE', value: '' )
			stringAttribute( key: 'org.eclipse.jdt.launching.PROJECT_ATTR', value: 'hibernate-core' )
			stringAttribute( key: 'org.eclipse.jdt.launching.VM_ARGUMENTS', value: '-ea' )
		}
		xml.mkp.comment("AUTO-GENERATED FILE.  DO NOT MODIFY. This is generated by gradle eclipse task")
	}
	
	
	classpath {
		plusConfigurations += [
			configurations.eclipseConfig
		]
		def frf = it.fileReferenceFactory
		
		file {
			beforeMerged { classpath ->
			}
			whenMerged { classpath ->
				Set exclusionSourceSet = [
					'src/main/resources',
					'src/test/resources'
				]
				List newSourceSet = []
				classpath.entries.each { item ->
					if( !exclusionSourceSet.contains( item.path ) ) {
						//println( 'INCLUDING:     ' + item )
						newSourceSet.add( item )
					} else {
						//println( 'NOT INCLUDING: ' + item )
					}
				}
				
				def aptMain = new SourceFolder('target/generated-src/apt/main', 'bin/main')
				def aptTest = new SourceFolder('target/generated-src/apt/test', 'bin/test')
				def resourceMain = new SourceFolder('src/main/resources', 'target/resources/main')
				def resourceTest = new SourceFolder('src/test/resources', 'target/resources/test')
				newSourceSet += [
					aptMain,
					aptTest,
					resourceMain,
					resourceTest
				]
				classpath.entries = newSourceSet
			}
		}
	}
}

xjc {
    outputDir = project.jaxbTargetDir

    schemas {
        cfg {
            xsd = file( 'src/main/resources/org/hibernate/xsd/cfg/legacy-configuration-4.0.xsd' )
            xjcBinding = file( 'src/main/xjb/hbm-configuration-bindings.xjb' )
        }
        hbm {
            xsd = file( 'src/main/resources/org/hibernate/xsd/mapping/legacy-mapping-4.0.xsd' )
            xjcBinding = file( 'src/main/xjb/hbm-mapping-bindings.xjb' )
            xjcExtensions = ['inheritance', 'simplify']
        }
    }
}


//sourceSets.main.sourceGeneratorsTask.dependsOn xjc
//sourceSets.main.sourceGeneratorsTask.dependsOn antlr
tasks.compile.dependsOn antlr

// todo (6.0) : remove this once we get 6.0 stable-ish
tasks.withType( JavaCompile ).forEach({ JavaCompile c -> c.options.compilerArgs += ["-Xmaxerrs", "4999"]})

task copyBundleResources (type: Copy) {
    ext {
        bundlesTargetDir = file( "${buildDir}/bundles" )
        bundleTokens = dbBundle[db]
        ext.bundleTokens['buildDirName'] = buildDir.absolutePath
    }

    from file('src/test/bundles')
    into ext.bundlesTargetDir
    filter( ReplaceTokens, tokens: ext.bundleTokens)
	//println( 'ext: ' + ext )
	//println( 'ext.bundleTokens:' + ext.bundleTokens )
    doFirst {
        ext.bundlesTargetDir.mkdirs()
    }
}
processTestResources.dependsOn copyBundleResources

task testJar(type: Jar, dependsOn: testClasses) {
    classifier = 'test'
    from sourceSets.test.output
}

artifacts {
    tests testJar
}

task generateEnversStaticMetamodel(
        type: JavaCompile,
        description: "Generate the Hibernate Envers revision entity static metamodel classes." ) {
    source = sourceSets.main.java
    // we only want to include these specific classes for metamodel generation.
    // if envers adds any additional revision entity classes, they must be listed here.
    include 'org/hibernate/envers/DefaultRevisionEntity.java'
    include 'org/hibernate/envers/DefaultTrackingModifiedEntitiesRevisionEntity.java'
    include 'org/hibernate/envers/enhanced/SequenceIdRevisionEntity.java'
    include 'org/hibernate/envers/enhanced/SequenceIdTrackingModifiedEntitiesRevisionEntity.java'

    classpath = sourceSets.main.runtimeClasspath + sourceSets.test.compileClasspath
    options.compilerArgs = [
            "-proc:only",
            "-processor",
            "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor"
    ]

    // put static metamodel classes back out to the source tree since they're version controlled.
    destinationDir = new File( "${projectDir}/src/main/java" )
}
//
//if ( JavaVersion.current().isJava9Compatible() ) {
//    logger.warn( '[WARN] Skipping Javassist-related tests for hibernate-core due to Javassist JDK 9 incompatibility' )
//
//    // we need to exclude tests using Javassist enhancement, which does not properly support
//    // Java 9 yet - https://issues.jboss.org/browse/JASSIST-261
//    test {
//        // rather than wild-cards, keep an explicit list
//        exclude 'org/hibernate/jpa/test/enhancement/InterceptFieldClassFileTransformerTest.class'
//        exclude 'org/hibernate/jpa/test/enhancement/runtime/JpaRuntimeEnhancementTest.class'
//        exclude 'org/hibernate/test/bytecode/enhancement/EnhancerTest.class'
//        exclude 'org/hibernate/test/bytecode/enhancement/basic/BasicInSessionTest.class'
//
//        // also, any tests using Arquillian for in-container testing with WildFly currently
//        // need to be excluded because WildFly does not yet work with Java 9
//        exclude 'org/hibernate/test/wf/ddl/**'
//        exclude 'org/hibernate/jpa/test/cdi/**'
//        exclude 'org/hibernate/envers/internal/tools/MapProxyTest.class'
//        exclude 'org/hibernate/envers/test/integration/components/dynamic/AuditedDynamicComponentTest.class'
//        exclude 'org/hibernate/envers/test/integration/components/dynamic/AuditedDynamicComponentsAdvancedCasesTest.class'
//    }
//}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// todo (6.0) : fix after fixing hibernate-spatial
//processTestResources {
//    doLast {
//        copy {
//            from file( 'src/test/resources' )
//            into file( "${buildDir}/resources/test" )
//            include 'arquillian.xml'
//            include 'org/hibernate/test/wf/ddl/manifest.mf'
//            expand wildFlyInstallDir: project( ':hibernate-orm-modules' ).wildFlyInstallDir,
//                   hibernateMajorMinorVersion: "${project.ormVersion.family}",
//                   arquillianDeploymentExportDir: "${rootProject.buildDir.absolutePath}/arquillian-deployments"
//        }
//    }
//}
//
//test.dependsOn ':hibernate-orm-modules:prepareWildFlyForTests'
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

test {
    systemProperty 'file.encoding', 'utf-8'
    beforeTest { descriptor ->
        //println "Starting test: " + descriptor
    }
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Custom Antlr v4 Plugin (to work with Gradle 3)

ext {
    baseAntlrInputPath = 'src/main/antlr'
    baseAntlrOutputPath = 'generated-src/antlr/main'
}

class GrammarDescriptor {
    String packageName
    String grammarName

    GrammarDescriptor(String packageName, String grammarName) {
        this.packageName = packageName
        this.grammarName = grammarName
    }

    File resolveSourceFile(Project project) {
        return project.file(
                project.baseAntlrInputPath +
                        '/' + packageName.replace( '.', '/' ) +
                        '/' + grammarName + '.g4'
        )
    }

    File resolveOutputFile(Project project) {
        final File baseOutputDir = project.file( "${project.buildDir}/${project.baseAntlrOutputPath}/" )
        final File packagedOutputDirectory = new File( baseOutputDir, packageName.replace( '.', '/' ) )

        return new File( packagedOutputDirectory, grammarName + '.g4' )
    }
}

class Antlr4Plugin implements Plugin<Project> {
    void apply(Project project) {
        project.with {
            apply plugin : 'java'

            configurations.maybeCreate 'antlr'

            Antlr4GenerationTask genTask = tasks.create 'antlr', Antlr4GenerationTask
            genTask.group = 'Build'
            genTask.description = 'Generate source code from ANTLR grammar'

            tasks.getByName('compileJava').dependsOn genTask

            SourceSet mainSourceSet = project.convention.getPlugin( JavaPluginConvention ).sourceSets.getByName( SourceSet.MAIN_SOURCE_SET_NAME );
            mainSourceSet.compileClasspath += configurations.antlr

            SourceSet testSourceSet = project.convention.getPlugin( JavaPluginConvention ).sourceSets.getByName( SourceSet.TEST_SOURCE_SET_NAME );
            testSourceSet.compileClasspath += configurations.antlr

            project.afterEvaluate({
                mainSourceSet.java.srcDir( genTask.outputDirectory )
            })

        }
    }
}

class Antlr4GenerationTask extends DefaultTask {
    static final String HQL_PCKG = 'org.hibernate.query.hql.internal'
    static final String IMPORT_SQL_PCKG = 'org.hibernate.tool.hbm2ddl.grammar'
    static final String GRAPH_PCKG = 'org.hibernate.graph.internal.parse'

    List<GrammarDescriptor> grammarDescriptors = [
            new GrammarDescriptor( HQL_PCKG, 'HqlLexer' ),
            new GrammarDescriptor( HQL_PCKG, 'HqlParser' ),
            new GrammarDescriptor( IMPORT_SQL_PCKG, 'SqlStatementLexer' ),
            new GrammarDescriptor( IMPORT_SQL_PCKG, 'SqlStatementParser' ),
            new GrammarDescriptor( GRAPH_PCKG, 'GraphLanguageLexer' ),
            new GrammarDescriptor( GRAPH_PCKG, 'GraphLanguageParser' )
    ]

    @InputFiles
    @SkipWhenEmpty
    FileCollection getSource() {
        // only used for UP-TO-DATE checking
        return project.files( grammarDescriptors*.resolveSourceFile( project ) )
    }

    @OutputDirectory
    File getOutputDirectory() {
        // only used for UP-TO-DATE checking
        return project.file( "${project.buildDir}/${project.baseAntlrOutputPath}" )
    }

    @TaskAction
    void antlrGeneration() {
        logger.lifecycle( "Starting custom Antlr (v4) grammar generation" )

        grammarDescriptors.forEach( { grammarDescriptor -> generate( grammarDescriptor ) } )
    }

    def generate(GrammarDescriptor grammarDescriptor) {
        final File sourceFile = grammarDescriptor.resolveSourceFile( project )
        final File outputFile = grammarDescriptor.resolveOutputFile( project )

        logger.lifecycle( "Starting Antlr grammar generation `${grammarDescriptor.grammarName} : [${sourceFile.absolutePath}] -> [${outputFile.absolutePath}]" )

        outputFile.parentFile.mkdirs()

        project.javaexec {
            main 'org.antlr.v4.Tool'
            classpath project.configurations.antlr
            args '-o', outputFile.parentFile.absolutePath
//            args '-lib', sourceFile.parentFile.absolutePath
            args '-long-messages'
            args '-listener'
            args '-visitor'
            args sourceFile.absolutePath
        }
    }
}