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

415 lines
15 KiB
Groovy

plugins {
id 'org.hibernate.build.xjc'
}
/*
* 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
description = 'Hibernate\'s core ORM functionality'
apply from: rootProject.file( 'gradle/published-java-module.gradle' )
apply plugin: Antlr4Plugin
apply plugin: 'hibernate-matrix-testing'
ext {
jaxbTargetDir = file( "${buildDir}/generated-src/jaxb/main" )
}
configurations {
tests {
description = 'Configuration for the produced test jar'
}
javassist {
description "Dependencies for compiling and running the Javassist tests in the `javassist` source-set"
}
}
sourceSets {
main {
// add the XJC generated JAXB classes to the main source-set
java.srcDir project.jaxbTargetDir
}
// resources inherently exclude sources
test {
resources {
setSrcDirs( ['src/test/java','src/test/resources','src/test/bundles'] )
}
}
testJavassist {
// define the testJavassist source-set
java {
compileClasspath += main.output + test.output + configurations.javassist
runtimeClasspath += main.output + test.output + configurations.javassist
}
}
}
dependencies {
api libraries.jpa
api libraries.jta
api libraries.jandex
api libraries.classmate
api libraries.commons_annotations
api libraries.jaxb_api
implementation libraries.byteBuddy
implementation libraries.activation
implementation libraries.jaxb_runtime
implementation libraries.antlr
compileOnly libraries.jacc
compileOnly libraries.validation
compileOnly libraries.ant
compileOnly libraries.cdi
compileOnly configurations.javassist
testImplementation project(':hibernate-testing')
testImplementation libraries.shrinkwrap_api
testImplementation libraries.shrinkwrap
testImplementation libraries.shrinkwrap_descriptors_api_javaee
testImplementation libraries.shrinkwrap_descriptors_impl_javaee
testImplementation libraries.jacc
testImplementation libraries.validation
testImplementation( libraries.validator ) {
// for test runtime
transitive = true
}
testImplementation libraries.jandex
testImplementation libraries.classmate
testImplementation libraries.mockito
testImplementation libraries.mockito_inline
testImplementation libraries.jodaTime
testImplementation libraries.assertj
testImplementation libraries.cdi
testImplementation libraries.jboss_ejb_spec_jar
testImplementation libraries.jboss_annotation_spec_jar
testRuntimeOnly "org.jboss.spec.javax.ejb:jboss-ejb-api_3.2_spec:1.0.0.Final"
testRuntimeOnly libraries.expression_language
testRuntimeOnly 'jaxen:jaxen:1.1'
// testRuntimeOnly libraries.javassist
testRuntimeOnly libraries.byteBuddy
testRuntimeOnly libraries.weld
testRuntimeOnly libraries.atomikos
testRuntimeOnly libraries.atomikos_jta
testRuntimeOnly libraries.wildfly_transaction_client
testAnnotationProcessor project( ':hibernate-jpamodelgen' )
antlr libraries.antlr
xjc libraries.jaxb_runtime
xjc libraries.jaxb_xjc
xjc libraries.jaxb2_basics
xjc libraries.jaxb2_basics_ant
xjc libraries.activation
}
jar {
manifest {
attributes(
'Main-Class': 'org.hibernate.Version',
// BND Plugin instructions (for OSGi):
'Import-Package': [
'javax.security.auth;resolution:=optional',
// Make javax.security.jacc optional and do not reference a version range (because that's what we used to do)
'javax.security.jacc;resolution:=optional;version=!',
// Make javax.validation optional and do not reference a version range (because that's what we used to do)
'javax.validation;resolution:=optional;version=!',
'javax.validation.constraints;resolution:=optional;version=!',
'javax.validation.groups;resolution:=optional;version=!',
'javax.validation.metadata;resolution:=optional;version=!',
// Make javax.enterprise optional and do not reference a version range (because that's what we used to do)
'!javax.enterprise*',
'javax.enterprise.context.spi;resolution:=optional;version=!',
'javax.enterprise.inject.spi;resolution:=optional;version=!',
// For JPA, we don't want to target the automatically generated range, but a specific version
"javax.persistence;version=\"${project.jpaVersion.osgiName}\"",
// optionals
'jakarta.persistence.spi;resolution:=optional',
'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.inject;resolution:=optional',
'net.bytebuddy.*;resolution:=optional',
'org.objectweb.jonas_tm;resolution:=optional',
'com.ibm.websphere.jtaextensions;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}\"",
// Temporarily support JTA 1.1 -- Karaf and other frameworks still
// use it. Without this, the plugin generates [1.2,2).
'javax.transaction;version="[1.1,2)"',
// Also import every package referenced in the code
'*'
].join( ',' ),
'-exportcontents': [
// Legacy resource packages containing XSDs that were traditionally not exported
"!org.hibernate.xsd.cfg",
"!org.hibernate.xsd.mapping",
// TODO: Uncomment once EntityManagerFactoryBuilderImpl no longer uses ClassLoaderServiceImpl.
//'org.hibernate.boot.registry.classloading.internal',
"*;version=${project.version}"
].join( ',' ),
)
}
}
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','src/test/bundles'] )
}
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']
}
mapping {
xsd = file( 'src/main/resources/org/hibernate/jpa/orm_2_2.xsd' )
xjcBinding = file( 'src/main/xjb/mapping-bindings.xjb' )
xjcExtensions = ['inheritance']
}
}
}
//sourceSets.main.sourceGeneratorsTask.dependsOn xjc
//sourceSets.main.sourceGeneratorsTask.dependsOn antlr
tasks.compile.dependsOn antlr
task copyBundleResources (type: Copy) {
ext {
bundlesTargetDir = file( "${buildDir}/bundles" )
bundleTokens = dbBundle[db]
ext.bundleTokens['buildDirName'] = buildDir.absolutePath
}
from file('src/test/bundles/templates')
into ext.bundlesTargetDir
filter( ReplaceTokens, tokens: ext.bundleTokens)
doFirst {
ext.bundlesTargetDir.mkdirs()
}
}
// Not sure if this is a proper fix, but if we use dependsOn instead of finalizedBy,
// we will end up a test JAR with bundle files that where variables are replaced
processTestResources.finalizedBy copyBundleResources
task testJar(type: Jar, dependsOn: testClasses) {
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
archiveClassifier.set( '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" )
}
tasks.withType( Test.class ).each { test ->
test.systemProperty 'file.encoding', 'utf-8'
if ( gradle.ext.javaVersions.test.launcher.asInt() >= 9 ) {
// See org.hibernate.boot.model.naming.NamingHelperTest.DefaultCharset.set
test.jvmArgs( ['--add-opens', 'java.base/java.nio.charset=ALL-UNNAMED'] )
// Weld needs this to generate proxies
test.jvmArgs( ['--add-opens', 'java.base/java.security=ALL-UNNAMED'] )
test.jvmArgs( ['--add-opens', 'java.base/java.lang=ALL-UNNAMED'] )
}
test.beforeTest { descriptor ->
//println "Starting test: " + descriptor
}
// Allow to exclude specific tests
if (project.hasProperty('excludeTests')) {
test.filter {
excludeTestsMatching project.property('excludeTests').toString()
}
}
// widen the overall 6.0 filter to include various package-protected tests
test.include 'org/hibernate/bytecode/internal/bytebuddy/**'
test.include 'org/hibernate/event/service/internal/**'
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 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 )
})
}
}
}
abstract 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, 'SqlScriptLexer' ),
new GrammarDescriptor( IMPORT_SQL_PCKG, 'SqlScriptParser' ),
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
}
}
}