458 lines
16 KiB
Groovy
458 lines
16 KiB
Groovy
plugins {
|
|
id 'org.hibernate.build.xjc' version '2.0.0-SNAPSHOT'
|
|
}
|
|
|
|
/*
|
|
* 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 org.apache.tools.ant.filters.ReplaceTokens
|
|
|
|
apply from: rootProject.file( 'gradle/published-java-module.gradle' )
|
|
apply plugin: Antlr4Plugin
|
|
apply plugin: 'hibernate-matrix-testing'
|
|
|
|
description = 'Hibernate\'s core ORM functionality'
|
|
|
|
ext {
|
|
jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
|
|
}
|
|
|
|
sourceSets.main {
|
|
java.srcDir project.jaxbTargetDir
|
|
}
|
|
|
|
sourceSets {
|
|
// resources inherently exclude sources
|
|
test {
|
|
resources {
|
|
setSrcDirs( ['src/test/java','src/test/resources'] )
|
|
}
|
|
}
|
|
|
|
testJavassist {
|
|
java {
|
|
compileClasspath += main.output + test.output
|
|
runtimeClasspath += main.output + test.output
|
|
}
|
|
}
|
|
}
|
|
|
|
configurations {
|
|
tests {
|
|
description = 'Configuration for the produced test jar'
|
|
}
|
|
|
|
//Configures the compile and runtime configurations for our javassist tests
|
|
//and includes the dependencies of the test task.
|
|
testJavassistCompile.extendsFrom testCompile
|
|
testJavassistRuntime.extendsFrom testRuntime
|
|
}
|
|
|
|
dependencies {
|
|
compile( libraries.jpa )
|
|
// This can now be made provided
|
|
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 )
|
|
|
|
// JAXB
|
|
compile( libraries.jaxb_api )
|
|
compile( libraries.jaxb_runtime )
|
|
|
|
// Antlr
|
|
antlr( libraries.antlr )
|
|
|
|
// xjc plugin
|
|
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 )
|
|
provided( libraries.cdi )
|
|
|
|
runtime( libraries.junit5_vintage )
|
|
runtime( libraries.junit5_jupiter )
|
|
|
|
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.assertj )
|
|
|
|
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
|
|
|
|
// Additional tests requiring Javassist
|
|
// folder in src/javassist/java
|
|
testJavassistCompile libraries.javassist
|
|
}
|
|
|
|
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" )
|
|
}
|
|
}
|
|
|
|
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)
|
|
|
|
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
|
|
// - the Gradle-supplied Antlr plugin attempts to simultaneously support
|
|
// multiple versions of Antlr which leads to many difficulties. this custom
|
|
// plugin provides dedicated and simplified support for Antlr v4
|
|
|
|
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.grammars.hql'
|
|
static final String IMPORT_SQL_PCKG = 'org.hibernate.grammars.importsql'
|
|
static final String GRAPH_PCKG = 'org.hibernate.grammars.graph'
|
|
static final String ORDER_PCKG = 'org.hibernate.grammars.ordering'
|
|
|
|
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' ),
|
|
new GrammarDescriptor( ORDER_PCKG, 'OrderingLexer' ),
|
|
new GrammarDescriptor( ORDER_PCKG, 'OrderingParser' )
|
|
]
|
|
|
|
@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
|
|
}
|
|
}
|
|
|
|
}
|
|
//Create the task that runs the integration tests found from the
|
|
//configured source directory and uses the correct classpath.
|
|
task testJavassist(type: Test) {
|
|
testClassesDirs = sourceSets.testJavassist.output.classesDirs
|
|
classpath = sourceSets.testJavassist.runtimeClasspath
|
|
//If you want to ensure that integration tests are run every time when you invoke
|
|
//this task, uncomment the following line.
|
|
//outputs.upToDateWhen { false }
|
|
}
|
|
|
|
check.dependsOn testJavassist
|
|
testJavassist.mustRunAfter test
|
|
|