2010-10-08 21:20:10 -04:00
|
|
|
apply plugin: 'eclipse'
|
|
|
|
apply plugin: 'idea'
|
2012-08-08 05:09:11 -04:00
|
|
|
apply from: "./libraries.gradle"
|
2012-08-22 14:41:16 -04:00
|
|
|
|
2010-10-08 21:20:10 -04:00
|
|
|
allprojects {
|
|
|
|
repositories {
|
2013-04-05 15:30:56 -04:00
|
|
|
mavenCentral()
|
|
|
|
mavenLocal()
|
|
|
|
|
2013-11-21 14:46:03 -05:00
|
|
|
maven {
|
|
|
|
name 'jboss-nexus'
|
|
|
|
url "http://repository.jboss.org/nexus/content/groups/public/"
|
|
|
|
}
|
|
|
|
maven {
|
|
|
|
name "jboss-snapshots"
|
|
|
|
url "http://snapshots.jboss.org/maven2/"
|
|
|
|
}
|
2010-10-08 21:20:10 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-22 09:29:49 -04:00
|
|
|
buildscript {
|
|
|
|
repositories {
|
2013-04-05 15:30:56 -04:00
|
|
|
mavenCentral()
|
|
|
|
mavenLocal()
|
|
|
|
|
2013-11-21 14:46:03 -05:00
|
|
|
maven {
|
|
|
|
name 'jboss-nexus'
|
|
|
|
url "http://repository.jboss.org/nexus/content/groups/public/"
|
|
|
|
}
|
|
|
|
maven {
|
|
|
|
name "jboss-snapshots"
|
|
|
|
url "http://snapshots.jboss.org/maven2/"
|
|
|
|
}
|
2011-03-22 09:29:49 -04:00
|
|
|
}
|
|
|
|
dependencies {
|
2013-04-18 14:40:56 -04:00
|
|
|
classpath 'org.hibernate.build.gradle:gradle-maven-publish-auth:2.0.1'
|
2013-05-10 16:28:03 -04:00
|
|
|
classpath 'org.hibernate.build.gradle:hibernate-matrix-testing:1.0.0-SNAPSHOT'
|
2013-09-12 12:32:51 -04:00
|
|
|
classpath 'org.hibernate.build.gradle:version-injection-plugin:1.0.0'
|
2011-03-22 09:29:49 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-21 14:46:03 -05:00
|
|
|
ext {
|
|
|
|
expectedGradleVersion = '1.9'
|
|
|
|
hibernateTargetVersion = '4.3.0-SNAPSHOT'
|
|
|
|
javaLanguageLevel = '1.6'
|
|
|
|
|
2013-11-26 11:43:50 -05:00
|
|
|
osgiExportVersion = hibernateTargetVersion.replaceAll( "-SNAPSHOT", ".SNAPSHOT" )
|
2013-11-21 14:46:03 -05:00
|
|
|
}
|
2012-07-19 09:56:31 -04:00
|
|
|
|
2012-02-15 17:31:29 -05:00
|
|
|
idea {
|
2012-02-16 21:52:26 -05:00
|
|
|
project {
|
2013-04-05 15:38:23 -04:00
|
|
|
languageLevel = javaLanguageLevel
|
2012-02-16 21:52:26 -05:00
|
|
|
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"
|
|
|
|
}
|
2010-10-11 10:30:26 -04:00
|
|
|
}
|
|
|
|
|
2013-04-16 19:25:20 -04:00
|
|
|
// Used in POM customization. Each sub-project overrides ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
def pomName() {
|
|
|
|
return "A Hibernate O/RM module"
|
|
|
|
}
|
|
|
|
def pomDescription() {
|
|
|
|
return "A module of the Hibernate O/RM project"
|
|
|
|
}
|
2013-11-26 11:43:50 -05:00
|
|
|
// Used in MANIFEST.MF for OSGi Bundles
|
|
|
|
def osgiDescription() {
|
|
|
|
// by default just reuse the pomDescription
|
|
|
|
return pomDescription()
|
|
|
|
}
|
2013-12-02 21:53:19 -05:00
|
|
|
|
|
|
|
|
2013-04-16 19:25:20 -04:00
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
2010-10-08 21:20:10 -04:00
|
|
|
|
|
|
|
subprojects { subProject ->
|
2010-10-10 16:06:06 -04:00
|
|
|
apply plugin: 'idea'
|
2012-02-16 21:52:26 -05:00
|
|
|
apply plugin: 'eclipse'
|
2010-10-12 16:39:33 -04:00
|
|
|
|
|
|
|
defaultTasks 'build'
|
2010-10-10 16:06:06 -04:00
|
|
|
|
2010-10-08 21:20:10 -04:00
|
|
|
group = 'org.hibernate'
|
2012-07-19 09:56:31 -04:00
|
|
|
version = rootProject.hibernateTargetVersion
|
2013-11-21 14:46:03 -05:00
|
|
|
ext.exportPackageVersion = rootProject.osgiExportVersion
|
2010-10-08 21:20:10 -04:00
|
|
|
|
|
|
|
// minimize changes, at least for now (gradle uses 'build' by default)..
|
2010-10-10 16:06:06 -04:00
|
|
|
buildDir = "target"
|
2010-10-10 09:17:52 -04:00
|
|
|
|
2013-12-02 21:53:19 -05:00
|
|
|
if ( subProject.name.startsWith( 'release' ) || subProject.name.startsWith( 'documentation' ) ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// everything below here in the closure applies to java projects
|
|
|
|
apply plugin: 'java'
|
|
|
|
apply plugin: 'maven-publish'
|
|
|
|
apply plugin: 'maven-publish-auth'
|
|
|
|
apply plugin: 'osgi'
|
|
|
|
|
|
|
|
apply from: "${rootProject.projectDir}/source-generation.gradle"
|
|
|
|
|
|
|
|
apply plugin: 'findbugs'
|
|
|
|
apply plugin: 'checkstyle'
|
|
|
|
apply plugin: 'build-dashboard'
|
|
|
|
apply plugin: 'project-report'
|
|
|
|
|
|
|
|
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"
|
|
|
|
}
|
|
|
|
jaxb {
|
|
|
|
description = 'Dependencies for running ant xjc (jaxb class generation)'
|
|
|
|
}
|
|
|
|
configurations {
|
|
|
|
all*.exclude group: 'xml-apis', module: 'xml-apis'
|
|
|
|
}
|
|
|
|
animalSniffer
|
|
|
|
javaApiSignature
|
|
|
|
}
|
|
|
|
|
|
|
|
// appropriately inject the common dependencies into each sub-project
|
|
|
|
dependencies {
|
|
|
|
compile( libraries.logging )
|
|
|
|
compile( libraries.logging_annotations )
|
|
|
|
|
|
|
|
testCompile( libraries.junit )
|
|
|
|
testCompile( libraries.byteman )
|
|
|
|
testCompile( libraries.byteman_install )
|
|
|
|
testCompile( libraries.byteman_bmunit )
|
|
|
|
|
|
|
|
testRuntime( libraries.log4j )
|
|
|
|
testRuntime( libraries.javassist )
|
|
|
|
testRuntime( libraries.h2 )
|
|
|
|
|
|
|
|
jbossLoggingTool( libraries.logging_processor )
|
|
|
|
|
|
|
|
jaxb( libraries.jaxb ){
|
|
|
|
exclude group: "javax.xml.stream"
|
|
|
|
}
|
|
|
|
jaxb( libraries.jaxb2_basics )
|
|
|
|
jaxb( libraries.jaxb2_ant )
|
|
|
|
|
|
|
|
animalSniffer ( libraries.animal_sniffer )
|
|
|
|
javaApiSignature ( libraries.java16_signature )
|
|
|
|
}
|
|
|
|
|
|
|
|
// mac-specific stuff ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
ext.toolsJar = file("${System.getProperty('java.home')}/../lib/tools.jar")
|
|
|
|
if ( ext.toolsJar.exists() ) {
|
|
|
|
dependencies{
|
|
|
|
testCompile files( toolsJar )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
targetCompatibility = rootProject.javaLanguageLevel
|
|
|
|
sourceCompatibility = rootProject.javaLanguageLevel
|
|
|
|
|
|
|
|
task compile
|
|
|
|
compile.dependsOn compileJava, processResources, compileTestJava, processTestResources
|
|
|
|
|
|
|
|
sourceSets.main {
|
|
|
|
compileClasspath += configurations.provided
|
|
|
|
}
|
|
|
|
|
|
|
|
tasks.withType( JavaCompile.class ).all { task->
|
|
|
|
task.options.compilerArgs += [
|
|
|
|
"-nowarn",
|
|
|
|
"-proc:none",
|
|
|
|
"-encoding", "UTF-8",
|
|
|
|
"-source", rootProject.javaLanguageLevel,
|
|
|
|
"-target", rootProject.javaLanguageLevel
|
|
|
|
]
|
|
|
|
}
|
|
|
|
|
2013-12-02 23:11:00 -05:00
|
|
|
addLoggingProcessor( sourceSets.main )
|
2013-12-02 21:53:19 -05:00
|
|
|
|
|
|
|
jar {
|
|
|
|
manifest = osgiManifest {
|
|
|
|
// GRADLE-1411: Even if we override Imports and Exports
|
|
|
|
// auto-generation with instructions, classesDir and classpath
|
|
|
|
// need to be here (temporarily).
|
|
|
|
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'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
test {
|
|
|
|
systemProperties['hibernate.test.validatefailureexpected'] = true
|
|
|
|
systemProperties += System.properties.findAll { it.key.startsWith( "hibernate.") }
|
|
|
|
maxHeapSize = "1024m"
|
|
|
|
// Not strictly needed but useful to attach a profiler:
|
|
|
|
jvmArgs '-XX:MaxPermSize=256m'
|
|
|
|
}
|
|
|
|
|
|
|
|
processTestResources.doLast( {
|
|
|
|
copy {
|
|
|
|
from( sourceSets.test.java.srcDirs ) {
|
|
|
|
include '**/*.properties'
|
|
|
|
include '**/*.xml'
|
|
|
|
}
|
|
|
|
into sourceSets.test.output.classesDir
|
|
|
|
}
|
|
|
|
} )
|
|
|
|
|
|
|
|
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 )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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 generateSources
|
|
|
|
|
|
|
|
|
|
|
|
// Animal Sniffer ~~~~~~~~~~~~~~~~~~
|
|
|
|
// add animal sniffer Java API checking to the main compile tasks
|
|
|
|
|
|
|
|
// copy the resolved Animal Sniffer signature dependency artifact to a known location and name
|
|
|
|
task copyJavaApiSignature(type: Copy) {
|
|
|
|
from configurations.javaApiSignature
|
|
|
|
into "$buildDir/javaApiSignature/"
|
|
|
|
rename '.*signature', 'javaApi.signature'
|
|
|
|
}
|
|
|
|
|
|
|
|
// prepare the Animal Sniffer signature copy every time (before) we compile
|
|
|
|
compileJava.dependsOn copyJavaApiSignature
|
|
|
|
|
|
|
|
// and then after compilation, run the Animal Sniffer tool
|
|
|
|
compileJava.doLast {
|
|
|
|
ant.taskdef(
|
|
|
|
name: 'animalSniffer',
|
|
|
|
classname: 'org.codehaus.mojo.animal_sniffer.ant.CheckSignatureTask',
|
|
|
|
classpath: configurations.animalSniffer.asPath
|
|
|
|
)
|
|
|
|
|
|
|
|
ant.animalSniffer(
|
|
|
|
signature: "$buildDir/javaApiSignature/javaApi.signature",
|
|
|
|
classpath: sourceSets.main.compileClasspath.asPath) {
|
|
|
|
path( path: sourceSets.main.output.classesDir )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// specialized API/SPI checkstyle tasks ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
task checkstylePublicSources(type: Checkstyle) {
|
|
|
|
checkstyleClasspath = checkstyleMain.checkstyleClasspath
|
|
|
|
classpath = checkstyleMain.classpath
|
|
|
|
configFile = rootProject.file( 'shared/config/checkstyle/checkstyle.xml' )
|
|
|
|
source subProject.sourceSets.main.java.srcDirs
|
|
|
|
// exclude generated sources
|
|
|
|
exclude '**/generated-src/**'
|
|
|
|
// because cfg package is a mess mainly from annotation stuff
|
|
|
|
exclude '**/org/hibernate/cfg/**'
|
|
|
|
exclude '**/org/hibernate/cfg/*'
|
|
|
|
// because this should only report on api/spi
|
|
|
|
exclude '**/internal/**'
|
|
|
|
exclude '**/internal/*'
|
|
|
|
ignoreFailures = false
|
|
|
|
showViolations = true
|
|
|
|
reports {
|
|
|
|
xml {
|
|
|
|
destination "$buildDir/reports/checkstyle/public.xml"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
// Report configs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
checkstyle {
|
|
|
|
sourceSets = [ subProject.sourceSets.main ]
|
|
|
|
configFile = rootProject.file( 'shared/config/checkstyle/checkstyle.xml' )
|
|
|
|
showViolations = false
|
|
|
|
ignoreFailures = true
|
|
|
|
}
|
|
|
|
// exclude generated sources
|
|
|
|
// unfortunately this nice easy approach does not seem to work : http://forums.gradle.org/gradle/topics/specify_excludes_to_checkstyle_task
|
|
|
|
//checkstyleMain.exclude '**/generated-src/**'
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/hql/internal/antlr/**'
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/hql/internal/antlr/*'
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/sql/ordering/antlr/*'
|
|
|
|
checkstyleMain.exclude '**/*_$logger*'
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/internal/jaxb/**'
|
|
|
|
// because cfg package is a mess mainly from annotation stuff
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/cfg/**'
|
|
|
|
checkstyleMain.exclude '**/org/hibernate/cfg/*'
|
|
|
|
|
|
|
|
findbugs {
|
|
|
|
sourceSets = [ subProject.sourceSets.main, subProject.sourceSets.test ]
|
|
|
|
ignoreFailures = true
|
|
|
|
}
|
|
|
|
// exclude generated sources
|
|
|
|
// unfortunately this nice easy approach does not seem to work : http://forums.gradle.org/gradle/topics/specify_excludes_to_checkstyle_task
|
|
|
|
//findbugsMain.exclude '**/generated-src/**'
|
|
|
|
findbugsMain.exclude '**/org/hibernate/hql/internal/antlr/**'
|
|
|
|
findbugsMain.exclude '**/org/hibernate/hql/internal/antlr/*'
|
|
|
|
findbugsMain.exclude '**/org/hibernate/sql/ordering/antlr/*'
|
|
|
|
findbugsMain.exclude '**/*_$logger*'
|
|
|
|
findbugsMain.exclude '**/org/hibernate/internal/jaxb/**'
|
|
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
publishing {
|
|
|
|
publications {
|
|
|
|
mavenJava(MavenPublication) {
|
|
|
|
from components.java
|
|
|
|
|
|
|
|
artifact sourcesJar {
|
|
|
|
classifier "sources"
|
|
|
|
}
|
|
|
|
|
|
|
|
pom.withXml {
|
|
|
|
// append additional metadata
|
|
|
|
asNode().children().last() + {
|
|
|
|
resolveStrategy = Closure.DELEGATE_FIRST
|
|
|
|
|
|
|
|
name subProject.pomName()
|
|
|
|
description subProject.pomDescription()
|
|
|
|
url 'http://hibernate.org'
|
|
|
|
organization {
|
|
|
|
name 'Hibernate.org'
|
|
|
|
url 'http://hibernate.org'
|
|
|
|
}
|
|
|
|
issueManagement {
|
|
|
|
system 'jira'
|
|
|
|
url 'https://hibernate.atlassian.net/browse/HHH'
|
|
|
|
}
|
|
|
|
scm {
|
|
|
|
url 'http://github.com/hibernate/hibernate-orm'
|
|
|
|
connection 'scm:git:http://github.com/hibernate/hibernate-orm.git'
|
|
|
|
developerConnection 'scm:git:git@github.com:hibernate/hibernate-orm.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'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TEMPORARY : currently Gradle Publishing feature is exporting dependencies as 'runtime' scope,
|
|
|
|
// rather than 'compile'; fix that.
|
|
|
|
asNode().dependencies[0].dependency.each {
|
|
|
|
it.scope[0].value = 'compile'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
repositories {
|
|
|
|
maven {
|
|
|
|
if ( subProject.version.endsWith( 'SNAPSHOT' ) ) {
|
|
|
|
name 'jboss-snapshots-repository'
|
|
|
|
url 'https://repository.jboss.org/nexus/content/repositories/snapshots'
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
name 'jboss-releases-repository'
|
|
|
|
url 'https://repository.jboss.org/nexus/service/local/staging/deploy/maven2/'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
model {
|
|
|
|
tasks.generatePomFileForMavenJavaPublication {
|
|
|
|
destination = file( "$project.buildDir/generated-pom.xml" )
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
task sourcesJar(type: Jar, dependsOn: compileJava) {
|
|
|
|
from sourceSets.main.allSource
|
|
|
|
classifier = 'sources'
|
|
|
|
}
|
2010-10-08 21:20:10 -04:00
|
|
|
}
|
2013-05-16 19:51:53 -04:00
|
|
|
|
|
|
|
task release(type: Task, dependsOn: 'release:release')
|
2013-11-21 14:46:03 -05:00
|
|
|
|
|
|
|
task wrapper(type: Wrapper) {
|
|
|
|
gradleVersion = expectedGradleVersion
|
|
|
|
}
|