583 lines
18 KiB
Groovy
583 lines
18 KiB
Groovy
import org.apache.tools.ant.filters.ReplaceTokens
|
|
|
|
/*
|
|
* 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>.
|
|
*/
|
|
|
|
buildscript {
|
|
repositories {
|
|
mavenCentral()
|
|
mavenLocal()
|
|
jcenter()
|
|
|
|
maven {
|
|
name 'jboss-nexus'
|
|
url "http://repository.jboss.org/nexus/content/groups/public/"
|
|
}
|
|
maven {
|
|
name "jboss-snapshots"
|
|
url "http://snapshots.jboss.org/maven2/"
|
|
}
|
|
}
|
|
dependencies {
|
|
classpath 'org.hibernate.build.gradle:gradle-maven-publish-auth:2.0.1'
|
|
classpath 'org.hibernate.build.gradle:hibernate-matrix-testing:2.0.0-SNAPSHOT'
|
|
classpath 'org.hibernate.build.gradle:version-injection-plugin:1.0.0'
|
|
classpath 'org.hibernate.build.gradle:gradle-xjc-plugin:1.0.2.Final'
|
|
classpath 'com.github.lburgazzoli:lb-karaf-features-gen:1.0.0-SNAPSHOT'
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
id 'com.gradle.build-scan' version '1.9'
|
|
id 'me.champeau.buildscan-recipes' version '0.1.7'
|
|
}
|
|
|
|
apply plugin: 'eclipse'
|
|
apply plugin: 'idea'
|
|
apply from: "./libraries.gradle"
|
|
apply from: "./databases.gradle"
|
|
|
|
allprojects {
|
|
repositories {
|
|
mavenCentral()
|
|
mavenLocal()
|
|
|
|
maven {
|
|
name 'jboss-nexus'
|
|
url "http://repository.jboss.org/nexus/content/groups/public/"
|
|
}
|
|
maven {
|
|
name "jboss-snapshots"
|
|
url "http://snapshots.jboss.org/maven2/"
|
|
}
|
|
}
|
|
}
|
|
|
|
ext {
|
|
hibernateTargetVersion = '5.3.0-SNAPSHOT'
|
|
expectedGradleVersion = '4.4'
|
|
baselineJavaVersion = '1.8'
|
|
|
|
osgiExportVersion = hibernateTargetVersion.replaceAll( '-SNAPSHOT', '.SNAPSHOT' )
|
|
|
|
final String[] versionComponents = hibernateTargetVersion.split( '\\.' );
|
|
hibernateFullVersion = hibernateTargetVersion
|
|
hibernateMajorMinorVersion = versionComponents[0] + '.' + versionComponents[1]
|
|
hibernateMajorVersion = versionComponents[0]
|
|
}
|
|
|
|
idea {
|
|
project {
|
|
jdkName = baselineJavaVersion
|
|
languageLevel = baselineJavaVersion
|
|
|
|
vcs = 'Git'
|
|
}
|
|
module {
|
|
name = "hibernate-orm"
|
|
}
|
|
}
|
|
|
|
// Used in MANIFEST.MF for OSGi Bundles
|
|
def osgiDescription() {
|
|
return "A module of the Hibernate O/RM project"
|
|
}
|
|
|
|
buildDir = "target"
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
subprojects { subProject ->
|
|
apply plugin: 'idea'
|
|
apply plugin: 'eclipse'
|
|
|
|
defaultTasks 'build'
|
|
|
|
if ( subProject.name.startsWith( 'hibernate-gradle-plugin' ) ) {
|
|
apply plugin: 'groovy'
|
|
}
|
|
|
|
group = 'org.hibernate'
|
|
version = rootProject.hibernateTargetVersion
|
|
|
|
ext.exportPackageVersion = rootProject.osgiExportVersion
|
|
|
|
// minimize changes, at least for now (gradle uses 'build' by default)..
|
|
buildDir = "target"
|
|
|
|
if ( subProject.name.startsWith( 'release' ) ) {
|
|
return
|
|
}
|
|
|
|
if ( subProject.name.startsWith( 'hibernate-orm-modules' ) ) {
|
|
return
|
|
}
|
|
|
|
// everything below here in the closure applies to modules with Java code
|
|
apply plugin: 'java'
|
|
apply plugin: 'maven-publish'
|
|
apply plugin: 'maven-publish-auth'
|
|
apply plugin: 'osgi'
|
|
|
|
apply plugin: 'findbugs'
|
|
apply plugin: 'checkstyle'
|
|
apply plugin: 'build-dashboard'
|
|
apply plugin: 'project-report'
|
|
|
|
apply from: "${rootProject.projectDir}/utilities.gradle"
|
|
|
|
apply plugin: org.hibernate.build.HibernateBuildPlugin
|
|
|
|
sourceCompatibility = rootProject.baselineJavaVersion
|
|
targetCompatibility = rootProject.baselineJavaVersion
|
|
|
|
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 tooling.'
|
|
}
|
|
configurations {
|
|
all*.exclude group: 'xml-apis', module: 'xml-apis'
|
|
}
|
|
asciidoclet {
|
|
description = "Dependencies for Asciidoctor Javadoc taglet"
|
|
}
|
|
}
|
|
|
|
// appropriately inject the common dependencies into each sub-project
|
|
dependencies {
|
|
compile libraries.logging
|
|
|
|
provided libraries.logging_annotations
|
|
|
|
jbossLoggingTool( libraries.logging_processor )
|
|
|
|
testCompile( libraries.junit )
|
|
testCompile( libraries.byteman )
|
|
testCompile( libraries.byteman_install )
|
|
testCompile( libraries.byteman_bmunit )
|
|
|
|
testRuntime( libraries.log4j )
|
|
testRuntime( libraries.javassist )
|
|
testRuntime( libraries.byteBuddy )
|
|
testRuntime( libraries.woodstox )
|
|
|
|
//Databases
|
|
testRuntime( libraries.h2 )
|
|
testRuntime( libraries.hsqldb )
|
|
testRuntime( libraries.postgresql )
|
|
testRuntime( libraries.mysql )
|
|
testRuntime( libraries.mariadb )
|
|
testRuntime( libraries.mssql )
|
|
testRuntime( libraries.informix )
|
|
|
|
asciidoclet 'org.asciidoctor:asciidoclet:1.+'
|
|
|
|
if (db.equalsIgnoreCase("oracle")) {
|
|
dependencies {
|
|
testRuntime( libraries.oracle ) {
|
|
exclude group: 'com.oracle.jdbc', module: 'xmlparserv2'
|
|
}
|
|
}
|
|
}
|
|
if (db.equalsIgnoreCase("db2")) {
|
|
dependencies {
|
|
testRuntime( libraries.db2 )
|
|
}
|
|
}
|
|
if (db.equalsIgnoreCase("hana")) {
|
|
dependencies {
|
|
testRuntime( libraries.hana )
|
|
}
|
|
}
|
|
// 6.6 gave me some NPE problems from within checkstyle...
|
|
checkstyle 'com.puppycrawl.tools:checkstyle:6.5'
|
|
}
|
|
|
|
// mac-specific stuff ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// should really use Jvm.current().toolsJar
|
|
ext.toolsJar = file("${System.getProperty('java.home')}/../lib/tools.jar")
|
|
if ( ext.toolsJar.exists() ) {
|
|
dependencies{
|
|
testCompile files( toolsJar )
|
|
}
|
|
}
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// compilation
|
|
compileJava.options.encoding = 'UTF-8'
|
|
|
|
tasks.withType(JavaCompile) {
|
|
options.encoding = 'UTF-8'
|
|
}
|
|
|
|
task compile
|
|
compile.dependsOn compileJava, processResources, compileTestJava, processTestResources
|
|
|
|
sourceSets.main {
|
|
compileClasspath += configurations.provided
|
|
compileClasspath += configurations.jbossLoggingTool
|
|
}
|
|
|
|
subProject.getConvention().findPlugin( JavaPluginConvention.class ).sourceSets.each { sourceSet ->
|
|
JavaCompile javaCompileTask = project.tasks.findByName( sourceSet.compileJavaTaskName ) as JavaCompile
|
|
|
|
// NOTE : this aptDir stuff is needed until we can have IntelliJ run annotation processors for us
|
|
// which cannot happen until we can fold hibernate-testing back into hibernate-core/src/test
|
|
// which cannot happen until... ugh
|
|
File aptDir = subProject.file( "${subProject.buildDir}/generated-src/apt/${sourceSet.name}" )
|
|
sourceSet.allJava.srcDir( aptDir )
|
|
|
|
javaCompileTask.options.compilerArgs += [
|
|
"-nowarn",
|
|
"-encoding", "UTF-8",
|
|
"-s", "${aptDir.absolutePath}"
|
|
]
|
|
javaCompileTask.doFirst {
|
|
aptDir.mkdirs()
|
|
}
|
|
}
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// testing
|
|
subProject.tasks.withType( Test.class ).all { task ->
|
|
if ( JavaVersion.current().isJava9Compatible() ) {
|
|
// Byteman needs this property to be set, https://developer.jboss.org/thread/274997
|
|
task.jvmArgs += ["-Djdk.attach.allowAttachSelf=true"]
|
|
}
|
|
task.jvmArgs += [
|
|
'-XX:+HeapDumpOnOutOfMemoryError',
|
|
"-XX:HeapDumpPath=${project.file( "${project.buildDir}/OOM-dump.hprof" ).absolutePath}",
|
|
'-XX:MetaspaceSize=512M'
|
|
]
|
|
|
|
task.maxHeapSize = '2G'
|
|
|
|
task.systemProperties['hibernate.test.validatefailureexpected'] = true
|
|
task.systemProperties += System.properties.findAll { it.key.startsWith( "hibernate.") }
|
|
|
|
// uncomment to help identify pauses in test executions : where they occur
|
|
// task.beforeTest { descriptor ->
|
|
// println "Starting test: " + descriptor
|
|
// }
|
|
// task.afterTest { descriptor ->
|
|
// println "Completed test: " + descriptor
|
|
// }
|
|
}
|
|
|
|
/*
|
|
The latest versions of IntelliJ copy and use the test resources into out/test/resources
|
|
this occurs before the placeholder in the test config file are substituted
|
|
with the testing values.
|
|
|
|
This behaviour prevents the execution of the hibernate tests from inside the IDE.
|
|
|
|
A solution is to enable the 'After Build' Execution of the copyResourcesToIntelliJOutFolder task
|
|
from the 'Gradle project' IntelliJ tool window ( The task can be found under hibernate-orm > Task > other)
|
|
*/
|
|
task copyResourcesToIntelliJOutFolder(type: Copy) {
|
|
from "$subProject.buildDir/resources/test"
|
|
into 'out/test/resources'
|
|
}
|
|
|
|
processTestResources.doLast( {
|
|
copy {
|
|
from( sourceSets.test.java.srcDirs ) {
|
|
include '**/*.properties'
|
|
include '**/*.xml'
|
|
}
|
|
into sourceSets.test.output.classesDir
|
|
}
|
|
copy {
|
|
from file('src/test/resources')
|
|
into file( "${buildDir}/resources/test" )
|
|
exclude 'src/test/resources/arquillian.xml'
|
|
exclude 'src/test/resources/hibernate.properties'
|
|
}
|
|
copy {
|
|
from file('src/test/resources/hibernate.properties')
|
|
into file( "${buildDir}/resources/test" )
|
|
filter( ReplaceTokens, tokens: dbBundle[db] )
|
|
}
|
|
} )
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// artifact
|
|
|
|
jar {
|
|
manifest = osgiManifest {
|
|
// GRADLE-1411: Even if we override Imports and Exports
|
|
// auto-generation with instructions, classesDir and classpath
|
|
// need to be here (temporarily).
|
|
|
|
if ( subProject.name.startsWith( 'hibernate-gradle-plugin' ) ) {
|
|
classesDir = sourceSets.main.groovy.outputDir
|
|
}
|
|
else {
|
|
classesDir = sourceSets.main.output.classesDir
|
|
}
|
|
classpath = configurations.runtime
|
|
|
|
instruction 'Import-Package',
|
|
// 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)"',
|
|
// Tell Gradle OSGi to still dynamically import the other packages.
|
|
// IMPORTANT: Do not include the * in the modules' .gradle files.
|
|
// If it exists more than once, the manifest will physically contain a *.
|
|
'*'
|
|
|
|
instruction 'Bundle-Vendor', 'Hibernate.org'
|
|
instruction 'Bundle-Description', subProject.osgiDescription()
|
|
instruction 'Implementation-Url', 'http://hibernate.org'
|
|
instruction 'Implementation-Version', version
|
|
instruction 'Implementation-Vendor', 'Hibernate.org'
|
|
instruction 'Implementation-Vendor-Id', 'org.hibernate'
|
|
instruction 'Implementation-Title', name
|
|
instruction 'Specification-Title', name
|
|
instruction 'Specification-Version', version
|
|
instruction 'Specification-Vendor', 'Hibernate.org'
|
|
}
|
|
}
|
|
|
|
task sourcesJar(type: Jar, dependsOn: compileJava) {
|
|
from sourceSets.main.allSource
|
|
manifest = jar.manifest
|
|
classifier = 'sources'
|
|
}
|
|
|
|
javadoc {
|
|
Set<String> apiPackages = new HashSet<>()
|
|
Set<String> spiPackages = new HashSet<>()
|
|
Set<String> internalPackages = new HashSet<>()
|
|
|
|
subProject.sourceSets.main.java.each { javaFile ->
|
|
final String packageName = determinePackageName( subProject.sourceSets.main.java, javaFile );
|
|
if ( packageName.endsWith( ".internal" ) || packageName.contains( ".internal." ) ) {
|
|
internalPackages.add( packageName );
|
|
}
|
|
else if ( packageName.endsWith( ".spi" ) || packageName.contains( ".spi." ) ) {
|
|
spiPackages.add( packageName );
|
|
}
|
|
else if ( packageName.startsWith( "org.hibernate.testing" ) ) {
|
|
// do nothing as testing support is already handled...
|
|
}
|
|
else {
|
|
apiPackages.add( packageName );
|
|
}
|
|
}
|
|
|
|
final int copyrightYear = new GregorianCalendar().get( Calendar.YEAR )
|
|
|
|
configure( options ) {
|
|
docletpath = configurations.asciidoclet.files.asType(List)
|
|
doclet = 'org.asciidoctor.Asciidoclet'
|
|
|
|
windowTitle = "$subProject.name JavaDocs"
|
|
docTitle = "$subProject.name JavaDocs ($project.version)"
|
|
bottom = "Copyright © 2001-$copyrightYear <a href=\"http://redhat.com\">Red Hat, Inc.</a> All Rights Reserved."
|
|
use = true
|
|
encoding = 'UTF-8'
|
|
links += [
|
|
'https://docs.oracle.com/javase/8/docs/api/',
|
|
'https://docs.jboss.org/hibernate/beanvalidation/spec/2.0/api/',
|
|
'http://docs.jboss.org/cdi/api/2.0/',
|
|
'https://docs.oracle.com/javaee/7/api/'
|
|
]
|
|
|
|
group( 'API', apiPackages.asList() )
|
|
group( 'SPI', spiPackages.asList() )
|
|
group( 'Internal', internalPackages.asList() )
|
|
group( 'Testing Support', ['org.hibernate.testing*'] )
|
|
|
|
if ( JavaVersion.current().isJava8Compatible() ) {
|
|
options.addStringOption( 'Xdoclint:none', '-quiet' )
|
|
}
|
|
}
|
|
}
|
|
|
|
task javadocJar(type: Jar, dependsOn: javadoc) {
|
|
from tasks.javadoc.outputs
|
|
classifier = 'javadoc'
|
|
}
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// IDE options
|
|
idea {
|
|
module {
|
|
jdkName = subProject.sourceCompatibility
|
|
|
|
excludeDirs = [file( ".gradle" )]
|
|
excludeDirs += file( "$buildDir/classes" )
|
|
excludeDirs += file( "$buildDir/bundles" )
|
|
excludeDirs += file( "$buildDir/packages" )
|
|
excludeDirs += file( "$buildDir/dependency-cache" )
|
|
excludeDirs += file( "$buildDir/libs" )
|
|
excludeDirs += file( "$buildDir/reports" )
|
|
excludeDirs += file( "$buildDir/test-results" )
|
|
excludeDirs += file( "$buildDir/tmp" )
|
|
excludeDirs += file( "$buildDir/matrix" )
|
|
excludeDirs += file( "$buildDir/resources" )
|
|
|
|
downloadSources = true
|
|
scopes.PROVIDED.plus += [configurations.provided]
|
|
}
|
|
}
|
|
|
|
eclipse {
|
|
jdt {
|
|
sourceCompatibility = subProject.sourceCompatibility
|
|
targetCompatibility = subProject.targetCompatibility
|
|
}
|
|
classpath {
|
|
plusConfigurations.add( configurations.provided )
|
|
}
|
|
}
|
|
|
|
// eclipseClasspath will not add sources to classpath unless the dirs actually exist.
|
|
// TODO: Eclipse's annotation processor handling is also fairly stupid (and completely lacks in the
|
|
// Gradle plugin). For now, just compile first in order to get the logging classes.
|
|
eclipseClasspath.dependsOn compile
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Report configs
|
|
checkstyle {
|
|
sourceSets = [ subProject.sourceSets.main ]
|
|
configFile = rootProject.file( 'shared/config/checkstyle/checkstyle.xml' )
|
|
showViolations = false
|
|
}
|
|
// exclude generated java sources - by explicitly setting the base source dir
|
|
checkstyleMain.source = 'src/main/java'
|
|
|
|
// define a second checkstyle task for checking non-fatal violations
|
|
task nonFatalCheckstyle(type:Checkstyle) {
|
|
source = subProject.sourceSets.main.java
|
|
classpath = subProject.configurations.checkstyle
|
|
showViolations = false
|
|
configFile = rootProject.file( 'shared/config/checkstyle/checkstyle-non-fatal.xml' )
|
|
}
|
|
|
|
if ( JavaVersion.current().isJava9Compatible() ) {
|
|
logger.warn( '[WARN] Disabling findbugs, it does not support JDK 9' )
|
|
findbugs {
|
|
sourceSets = []
|
|
}
|
|
}
|
|
else {
|
|
findbugs {
|
|
sourceSets = [subProject.sourceSets.main, subProject.sourceSets.test]
|
|
ignoreFailures = true
|
|
toolVersion = '3.0.1'
|
|
// for now we need to set this to low so that FindBugs will actually report the DM_CONVERT_CASE warning we care about
|
|
reportLevel = 'low'
|
|
// remove all low level bug warnings except DM_CONVERT_CASE
|
|
excludeFilterConfig = resources.text.fromString( excludeAllLowLevelBugsExcept( 'DM_CONVERT_CASE' ) )
|
|
}
|
|
|
|
// exclude generated java sources and cfg package is a mess mainly from annotation stuff
|
|
findbugsMain.doFirst {
|
|
classes = classes.filter {
|
|
!it.path.contains( 'org/hibernate/hql/internal/antlr' ) &&
|
|
!it.path.contains( 'org/hibernate/boot/jaxb/cfg/spi' ) &&
|
|
!it.path.contains( 'org/hibernate/sql/ordering/antlr/Generated' ) &&
|
|
!it.path.contains( 'org/hibernate/sql/ordering/antlr/OrderByTemplateTokenTypes' ) &&
|
|
!it.path.contains( 'org/hibernate/boot/jaxb/hbm/spi/Jaxb' ) &&
|
|
!it.path.contains( 'org/hibernate/boot/jaxb/hbm/spi/Adapter' ) &&
|
|
!it.path.contains( 'org/hibernate/boot/jaxb/hbm/spi/ObjectFactory' ) &&
|
|
!it.path.contains( 'org/hibernate/cfg' ) &&
|
|
!it.path.contains( '_\$logger' )
|
|
}
|
|
}
|
|
}
|
|
// because cfg package is a mess mainly from annotation stuff
|
|
checkstyleMain.exclude '**/org/hibernate/cfg/**'
|
|
checkstyleMain.exclude '**/org/hibernate/cfg/*'
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Publishing
|
|
if ( !subProject.name.equals( 'documentation' ) && !subProject.name.equals( 'hibernate-infinispan' ) ) {
|
|
// do not configure publishing for the documentation module
|
|
publishing {
|
|
publications {
|
|
mavenJava(MavenPublication) {
|
|
from components.java
|
|
|
|
artifact( sourcesJar ) {
|
|
classifier 'sources'
|
|
}
|
|
|
|
artifact(javadocJar) {
|
|
classifier "javadoc"
|
|
}
|
|
}
|
|
// http://issues.gradle.org/browse/GRADLE-2966
|
|
// Once ^^ is resolved:
|
|
// 1) Move hibernate-testing module into hibernate-core tests
|
|
// 2) Define a second publication on hibernate-core for publishing the testing jar
|
|
// We could kind of do this now, but it would just be the jar. Every module would still need
|
|
// to duplicate the testing dependencies. Well, on second thought, we could centralize the
|
|
// testing dependencies here within the subprojects block
|
|
}
|
|
}
|
|
|
|
model {
|
|
tasks.generatePomFileForMavenJavaPublication {
|
|
destination = file( "$subProject.buildDir/generated-pom.xml" )
|
|
}
|
|
}
|
|
}
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
}
|
|
|
|
task release(type: Task, dependsOn: 'release:release')
|
|
|
|
task wrapper(type: Wrapper) {
|
|
gradleVersion = expectedGradleVersion
|
|
}
|
|
|
|
buildScan {
|
|
licenseAgreementUrl = 'https://gradle.com/terms-of-service'
|
|
licenseAgree = 'yes'
|
|
|
|
recipe 'git-commit', baseUrl: 'https://github.com/hibernate/hibernate-orm/tree'
|
|
}
|
|
|
|
|
|
|
|
def excludeAllLowLevelBugsExcept(String[] bugTypes){
|
|
def writer = new StringWriter()
|
|
def xml = new groovy.xml.MarkupBuilder(writer);
|
|
xml.FindBugsFilter {
|
|
Match {
|
|
Confidence( value: '3' )
|
|
bugTypes.each { bug ->
|
|
Not {
|
|
Bug( pattern: "${bug}" )
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return writer.toString( )
|
|
}
|