build.gradle

buildscript {
	repositories {
		maven { url "https://repo.spring.io/plugins-release" }
	}
	dependencies {
		classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7")
		classpath("org.asciidoctor:asciidoctor-gradle-plugin:1.5.2")
		classpath("io.spring.gradle:docbook-reference-plugin:0.3.1")
		classpath("ws.antonov.gradle.plugins:gradle-plugin-protobuf:0.9.1")
	}
}

plugins {
	id "org.sonarqube" version "2.1-rc1"
}

ext {
	linkHomepage = 'https://projects.spring.io/spring-framework'
	linkCi = 'https://build.spring.io/browse/SPR'
	linkIssue = 'https://jira.spring.io/browse/SPR'
	linkScmUrl = 'https://github.com/spring-projects/spring-framework'
	linkScmConnection = 'scm:git:git://github.com/spring-projects/spring-framework.git'
	linkScmDevConnection = 'scm:git:ssh://git@github.com:spring-projects/spring-framework.git'

	moduleProjects = subprojects.findAll {
		!it.name.equals('spring-build-src') && !it.name.equals('spring-framework-bom')
	}
}

configure(allprojects) { project ->
	group = "org.springframework"
	version = qualifyVersionIfNecessary(version)

	ext.activationApiVersion   = "1.1.1"
	ext.annotationApiVersion   = "1.2"
	ext.aspectjVersion         = "1.9.0.BETA-5"
	ext.beanvalVersion         = "1.1.0.Final"
	ext.caffeineVersion        = "2.3.2"
	ext.eclipselinkVersion     = "2.6.3"
	ext.ehcacheVersion         = "2.10.2"
	ext.ehcachejcacheVersion   = "1.0.1"
	ext.ehcache3Version        = "3.1.1"
	ext.ejbApiVersion          = "3.2"
	ext.elApiVersion           = "3.0.1-b04"
	ext.fileuploadVersion      = "1.3.2"
	ext.freemarkerVersion      = "2.3.25-incubating"
	ext.groovyVersion          = "2.4.7"
	ext.gsonVersion            = "2.7"
	ext.hamcrestVersion        = "1.3"
	ext.hibernate5Version      = "5.2.2.Final"
	ext.hibval5Version         = "5.2.4.Final"
	ext.hsqldbVersion          = "2.3.4"
	ext.httpasyncVersion       = "4.1.2"
	ext.httpclientVersion      = "4.5.2"
	ext.interceptorApiVersion  = "1.2"
	ext.jackson2Version        = "2.8.1"
	ext.javamailVersion        = "1.5.5"
	ext.jaxbVersion            = "2.2.11"
	ext.jaxwsVersion           = "2.2.11"
	ext.jcaVersion             = "1.7"
	ext.jettyVersion           = "9.4.0.M1"
	ext.jodaVersion            = "2.9.4"
	ext.jpaVersion             = "2.1.1"
	ext.jspVersion             = "2.3.2-b02"
	ext.jtaVersion             = "1.2"
	ext.junitVersion           = "4.12"
	ext.junitJupiterVersion    = '5.0.0-M2'
	ext.junitPlatformVersion   = '1.0.0-M2'
	ext.log4jVersion           = '2.6.2'
	ext.nettyVersion           = "4.1.4.Final"
	ext.okhttpVersion          = "2.7.5"
	ext.okhttp3Version         = "3.4.1"
	ext.poiVersion             = "3.14"
	ext.protobufVersion        = "3.0.0"
	ext.reactivestreamsVersion = "1.0.0"
	ext.reactorVersion         = "2.0.8.RELEASE"
	ext.reactorCoreVersion     = '3.0.1.BUILD-SNAPSHOT'
	ext.reactorNettyVersion    = '0.6.0.BUILD-SNAPSHOT'
	ext.romeVersion            = "1.6.0"
	ext.rxjavaVersion          = '1.1.9'
	ext.rxnettyVersion         = '0.5.2-rc.3'
	ext.servletVersion         = "3.1.0"
	ext.slf4jVersion           = "1.7.21"
	ext.snakeyamlVersion       = "1.17"
	ext.snifferVersion         = "1.15"
	ext.testngVersion          = "6.9.10"
	ext.tiles3Version          = "3.0.5"
	ext.tomcatVersion          = "8.5.4"
	ext.tyrusVersion           = "1.13"
	ext.undertowVersion        = "1.4.0.Final"
	ext.websocketVersion       = "1.1"
	ext.woodstoxVersion        = "5.0.2"
	ext.xmlunitVersion         = "2.2.1"
	ext.xnioVersion            = "3.4.0.Final"
	ext.xstreamVersion         = "1.4.9"

	ext.gradleScriptDir = "${rootProject.projectDir}/gradle"

	apply plugin: "propdeps"
	apply plugin: "java"
	apply plugin: "test-source-set-dependencies"
	apply from: "${gradleScriptDir}/ide.gradle"

	configurations {
		sniffer
		javaApiSignature
	}

	configurations.all {
		// check for updates every build
		resolutionStrategy.cacheChangingModulesFor 0, 'seconds'

		// consistent netty version (e.g. clashes between netty-all vs netty-common)
		resolutionStrategy.eachDependency { DependencyResolveDetails details ->
			if (details.requested.group == 'io.netty') {
				details.useVersion nettyVersion
			}
		}
		resolutionStrategy.eachDependency { DependencyResolveDetails details ->
			if (details.requested.name == 'reactor-core' && details.requested.version.startsWith('3.')) {
				details.useVersion reactorCoreVersion
			}
		}
	}

	compileJava.options*.compilerArgs = [
		"-Xlint:serial", "-Xlint:varargs", "-Xlint:cast", "-Xlint:classfile",
		"-Xlint:dep-ann", "-Xlint:divzero", "-Xlint:empty", "-Xlint:finally",
		"-Xlint:overrides", "-Xlint:path", "-Xlint:processing", "-Xlint:static",
		"-Xlint:try", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
		"-Xlint:unchecked", "-Xlint:-options", "-Werror"
	]

	compileTestJava.options*.compilerArgs = [
		"-Xlint:serial", "-Xlint:-varargs", "-Xlint:cast", "-Xlint:classfile",
		"-Xlint:dep-ann", "-Xlint:divzero", "-Xlint:empty", "-Xlint:finally",
		"-Xlint:overrides", "-Xlint:path", "-Xlint:processing", "-Xlint:static",
		"-Xlint:try", "-Xlint:-fallthrough", "-Xlint:-rawtypes", "-Xlint:-deprecation",
		"-Xlint:-unchecked", "-Xlint:-options"]

	compileJava {
		sourceCompatibility = 1.8
		targetCompatibility = 1.8
		options.encoding = 'UTF-8'
	}

	compileTestJava {
		sourceCompatibility = 1.8
		targetCompatibility = 1.8
		options.encoding = 'UTF-8'
		options.compilerArgs += "-parameters"
	}

	test {
		systemProperty("java.awt.headless", "true")
		systemProperty("testGroups", project.properties.get("testGroups"))
		scanForTestClasses = false
		include(["**/*Tests.class", "**/*Test.class"])
		// Since we set scanForTestClasses to false, we need to filter out inner
		// classes with the "$" pattern; otherwise, using -Dtest.single=MyTests to
		// run MyTests by itself will fail if MyTests contains any inner classes.
		exclude(["**/Abstract*.class", '**/*$*'])
		reports.junitXml.destination = file("$buildDir/test-results")
	}

	repositories {
		maven { url "https://repo.spring.io/libs-release" }
		maven { url "https://repo.spring.io/milestone" }
		maven { url "https://repo.spring.io/snapshot" }	// Reactor 3 snapshots
	}

	dependencies {
		testCompile("junit:junit:${junitVersion}") {
			exclude group:'org.hamcrest', module:'hamcrest-core'
		}
		testCompile("org.mockito:mockito-core:1.10.19") {
			exclude group:'org.hamcrest', module:'hamcrest-core'
		}
		testCompile("org.hamcrest:hamcrest-all:${hamcrestVersion}")
		testRuntime("org.apache.logging.log4j:log4j-core:${log4jVersion}")
		testRuntime("org.apache.logging.log4j:log4j-jcl:${log4jVersion}")

		sniffer("org.codehaus.mojo:animal-sniffer-ant-tasks:${snifferVersion}")
		javaApiSignature("org.codehaus.mojo.signature:java18:1.0@signature")
	}

	task copyJavaApiSignature(type: Copy) {
		ext.to = file("$buildDir/javaApiSignature/")
		description "Copy the resolved Animal Sniffer signature dependency artifact to a known location and name"
		from configurations.javaApiSignature
		into to
		rename '.*signature', 'javaApi.signature'
	}

	task sniff {
		group = "Verification"
		description = "Checks the Java API signatures"

		dependsOn compileJava
		dependsOn copyJavaApiSignature

		inputs.dir sourceSets.main.output.classesDir
		inputs.dir copyJavaApiSignature.to

		doLast {
			ant.taskdef(
				name: 'animalSniffer',
				classname: 'org.codehaus.mojo.animal_sniffer.ant.CheckSignatureTask',
				classpath: configurations.sniffer.asPath
			)

			// TODO: Animal Sniffer currently chokes on optional JDK 9 bytecode in AspectJ 1.9 beta 5
			// ant.animalSniffer(
			// 		signature: "$buildDir/javaApiSignature/javaApi.signature",
			// 		classpath: sourceSets.main.compileClasspath.asPath) {
			// 	path(path: sourceSets.main.output.classesDir)
			// 	annotation(className: "org.springframework.lang.UsesSunHttpServer")
			// }
		}
	}

	ext.javadocLinks = [
		"http://docs.oracle.com/javase/8/docs/api/",
		"http://docs.oracle.com/javaee/7/api/",
		"http://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ
		"http://pic.dhe.ibm.com/infocenter/wasinfo/v7r0/topic/com.ibm.websphere.javadoc.doc/web/apidocs/",
		"http://glassfish.java.net/nonav/docs/v3/api/",
		"http://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
		"http://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
		"http://tiles.apache.org/tiles-request/apidocs/",
		"http://tiles.apache.org/framework/apidocs/",
		"http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
		"http://ehcache.org/apidocs/${ehcacheVersion}",
		"http://ehcache.org/apidocs/${ehcache3Version}",
		"http://quartz-scheduler.org/api/2.2.1/",
		"http://fasterxml.github.io/jackson-core/javadoc/2.7/",
		"http://fasterxml.github.io/jackson-databind/javadoc/2.7/",
		"http://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.7/",
		"http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/"
	] as String[]
}

configure(subprojects - project(":spring-build-src")) { subproject ->
	apply plugin: "merge"
	apply from: "${gradleScriptDir}/publish-maven.gradle"

	configurations {
		jacoco
	}

	dependencies {
		jacoco("org.jacoco:org.jacoco.agent:0.7.5.201505241946:runtime")
	}

	gradle.taskGraph.whenReady {taskGraph ->
		if (taskGraph.hasTask(':sonarqube')) {
			test.jvmArgs "-javaagent:${configurations.jacoco.asPath}=destfile=${buildDir}/jacoco.exec,includes=org.springframework.*"
		}
	}

	jar {
		manifest.attributes["Created-By"] =
			"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
		manifest.attributes["Implementation-Title"] = subproject.name
		manifest.attributes["Implementation-Version"] = subproject.version

		from("${rootProject.projectDir}/src/dist") {
			include "license.txt"
			include "notice.txt"
			into "META-INF"
			expand(copyright: new Date().format("yyyy"), version: project.version)
		}
	}

	javadoc {
		description = "Generates project-level javadoc for use in -javadoc jar"

		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = project.name
		options.links(project.ext.javadocLinks)
		options.addStringOption('Xdoclint:none', '-quiet')

		// suppress warnings due to cross-module @see and @link references;
		// note that global 'api' task does display all warnings.
		logging.captureStandardError LogLevel.INFO
		logging.captureStandardOutput LogLevel.INFO // suppress "## warnings" message
	}

	task sourcesJar(type: Jar, dependsOn: classes) {
		classifier = 'sources'
		from sourceSets.main.allSource
		// don't include or exclude anything explicitly by default. See SPR-12085.
	}

	task javadocJar(type: Jar) {
		classifier = "javadoc"
		from javadoc
	}

	artifacts {
		archives sourcesJar
		archives javadocJar
	}
}

project("spring-build-src") {
	description = "Exposes gradle buildSrc for IDE support"
	apply plugin: "groovy"

	dependencies {
		compile gradleApi()
		compile localGroovy()
	}

	configurations.archives.artifacts.clear()
}

project("spring-core") {
	description = "Spring Core"

	// As of Spring 4.0.3, spring-core includes asm 5.x and repackages cglib 3.2, inlining
	// both into the spring-core jar. cglib 3.2 itself depends on asm 5.x and is therefore
	// further transformed by the JarJar task to depend on org.springframework.asm; this
	// avoids including two different copies of asm unnecessarily.
	def cglibVersion = "3.2.4"
	def objenesisVersion = "2.4"

	configurations {
		jarjar
		cglib
		objenesis
	}

	task cglibRepackJar(type: Jar) { repackJar ->
		repackJar.baseName = "spring-cglib-repack"
		repackJar.version = cglibVersion

		doLast() {
			project.ant {
				taskdef name: "jarjar", classname: "com.tonicsystems.jarjar.JarJarTask",
					classpath: configurations.jarjar.asPath
				jarjar(destfile: repackJar.archivePath) {
					configurations.cglib.each { originalJar ->
						zipfileset(src: originalJar)
					}
					// repackage net.sf.cglib => org.springframework.cglib
					rule(pattern: "net.sf.cglib.**", result: "org.springframework.cglib.@1")
					// as mentioned above, transform cglib"s internal asm dependencies from
					// org.objectweb.asm => org.springframework.asm. Doing this counts on the
					// the fact that Spring and cglib depend on the same version of asm!
					rule(pattern: "org.objectweb.asm.**", result: "org.springframework.asm.@1")
				}
			}
		}
	}

	task objenesisRepackJar(type: Jar) { repackJar ->
		repackJar.baseName = "spring-objenesis-repack"
		repackJar.version = objenesisVersion

		doLast() {
			project.ant {
				taskdef name: "jarjar", classname: "com.tonicsystems.jarjar.JarJarTask",
					classpath: configurations.jarjar.asPath
				jarjar(destfile: repackJar.archivePath) {
					configurations.objenesis.each { originalJar ->
						zipfileset(src: originalJar)
					}
					// repackage org.objenesis => org.springframework.objenesis
					rule(pattern: "org.objenesis.**", result: "org.springframework.objenesis.@1")
				}
			}
		}
	}

	dependencies {
		cglib("cglib:cglib:${cglibVersion}@jar")
		objenesis("org.objenesis:objenesis:${objenesisVersion}@jar")
		jarjar("com.googlecode.jarjar:jarjar:1.3")

		compile(files(cglibRepackJar))
		compile(files(objenesisRepackJar))
		compile("commons-logging:commons-logging:1.2")
		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
		optional("net.sf.jopt-simple:jopt-simple:5.0.2")
		optional("org.reactivestreams:reactive-streams:${reactivestreamsVersion}")
		optional("io.projectreactor:reactor-core:${reactorCoreVersion}")
		optional "io.reactivex:rxjava:${rxjavaVersion}"
		optional("io.netty:netty-buffer:${nettyVersion}")
		testCompile("javax.xml.bind:jaxb-api:${jaxbVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		testCompile("com.fasterxml.woodstox:woodstox-core:${woodstoxVersion}") {
			exclude group: "stax", module: "stax-api"
		}
	}

	jar {
		// inline repackaged cglib classes directly into the spring-core jar
		dependsOn cglibRepackJar
		from(zipTree(cglibRepackJar.archivePath)) {
			include "org/springframework/cglib/**"
		}

		dependsOn objenesisRepackJar
		from(zipTree(objenesisRepackJar.archivePath)) {
			include "org/springframework/objenesis/**"
		}
	}
}

project("spring-beans") {
	description = "Spring Beans"

	dependencies {
		compile(project(":spring-core"))
		compile(files(project(":spring-core").cglibRepackJar))
		optional("javax.inject:javax.inject:1")
		optional("javax.el:javax.el-api:${elApiVersion}")
		optional("org.yaml:snakeyaml:${snakeyamlVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
	}
}

project("spring-beans-groovy") {
	description "Groovy Bean Definitions"
	merge.into = project(":spring-beans")
	apply plugin: "groovy"

	dependencies {
		compile(project(":spring-core"))
		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
	}

	// this module's Java and Groovy sources need to be compiled together
	compileJava.enabled=false
	sourceSets {
		main {
			groovy {
				srcDir "src/main/java"
			}
		}
	}

	compileGroovy {
		sourceCompatibility = 1.8
		targetCompatibility = 1.8
	}
}

project("spring-aop") {
	description = "Spring AOP"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		compile(files(project(":spring-core").cglibRepackJar))
		compile(files(project(":spring-core").objenesisRepackJar))
		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
		optional("org.apache.commons:commons-pool2:2.4.2")
		optional("com.jamonapi:jamon:2.81")
	}
}

project("spring-expression") {
	description = "Spring Expression Language (SpEL)"

	dependencies {
		compile(project(":spring-core"))
	}
}

project("spring-instrument") {
	description = "Spring Instrument"

	jar {
		manifest.attributes["Premain-Class"] =
			"org.springframework.instrument.InstrumentationSavingAgent"
		manifest.attributes["Agent-Class"] =
			"org.springframework.instrument.InstrumentationSavingAgent"
		manifest.attributes["Can-Redefine-Classes"] = "true"
		manifest.attributes["Can-Retransform-Classes"] = "true"
		manifest.attributes["Can-Set-Native-Method-Prefix"] = "false"
	}
}

project("spring-context") {
	description = "Spring Context"
	apply plugin: "groovy"

	dependencies {
		compile(project(":spring-aop"))
		compile(project(":spring-beans"))
		compile(project(":spring-expression"))
		compile(project(":spring-core"))
		compile(files(project(":spring-core").cglibRepackJar))
		optional(project(":spring-instrument"))
		optional("javax.inject:javax.inject:1")
		optional("javax.annotation:javax.annotation-api:${annotationApiVersion}")
		optional("javax.xml.ws:jaxws-api:${jaxwsVersion}")
		optional("javax.ejb:javax.ejb-api:${ejbApiVersion}")
		optional("javax.interceptor:javax.interceptor-api:${interceptorApiVersion}")
		optional("javax.enterprise.concurrent:javax.enterprise.concurrent-api:1.0")
		optional("javax.money:money-api:1.0")
		optional("org.eclipse.persistence:javax.persistence:${jpaVersion}")
		optional("javax.validation:validation-api:${beanvalVersion}")
		optional("org.hibernate:hibernate-validator:${hibval5Version}")
		optional("joda-time:joda-time:${jodaVersion}")
		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
		optional("org.beanshell:bsh:2.0b4")
		testCompile("javax.inject:javax.inject-tck:1")
		testCompile("javax.el:javax.el-api:${elApiVersion}")
		testCompile("org.glassfish:javax.el:3.0.1-b08")
		testCompile("org.javamoney:moneta:1.1")
		testCompile("org.apache.commons:commons-pool2:2.4.2")
		testCompile("org.slf4j:slf4j-api:${slf4jVersion}")
		testRuntime("javax.xml.bind:jaxb-api:${jaxbVersion}")
	}
}

project("spring-oxm") {
	description = "Spring Object/XML Marshalling"
	apply from: "oxm.gradle"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		optional("javax.activation:activation:${activationApiVersion}")
		optional("org.codehaus.castor:castor-xml:1.4.1")  {
			exclude group: 'stax', module: 'stax-api'
			exclude group: "org.springframework", module: "spring-context"
		}
		optional("com.thoughtworks.xstream:xstream:${xstreamVersion}") {
			exclude group: 'xpp3', module: 'xpp3_min'
			exclude group: 'xmlpull', module: 'xmlpull'
		}
		optional("org.jibx:jibx-run:1.2.6")
		testCompile(project(":spring-context"))
		testCompile("xpp3:xpp3:1.1.4c")
		testCompile("org.codehaus.jettison:jettison:1.3.7") {
			exclude group: 'stax', module: 'stax-api'
		}
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
        testCompile(files(genCastor.classesDir).builtBy(genCastor))
        testCompile(files(genJaxb.classesDir).builtBy(genJaxb))
		testRuntime("xerces:xercesImpl:2.11.0")  // for Castor
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
	}
}

project("spring-messaging") {
	description = "Spring Messaging"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		compile(project(":spring-context"))
		optional(project(":spring-oxm"))
		optional("io.projectreactor:reactor-core:${reactorVersion}") {
			force = true  // enforce 2.0.x
		}
		optional("io.projectreactor:reactor-net:${reactorVersion}") {
			exclude group: "io.netty", module: "netty-all"
		}
		optional("io.netty:netty-all:${nettyVersion}")
		optional("org.eclipse.jetty.websocket:websocket-server:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet-api"
		}
		optional("org.eclipse.jetty.websocket:websocket-client:${jettyVersion}")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		testCompile("javax.inject:javax.inject-tck:1")
		testCompile("javax.servlet:javax.servlet-api:${servletVersion}")
		testCompile("javax.validation:validation-api:${beanvalVersion}")
		testCompile("com.thoughtworks.xstream:xstream:${xstreamVersion}")
		testCompile("org.apache.activemq:activemq-broker:5.8.0")
		testCompile("org.apache.activemq:activemq-kahadb-store:5.8.0") {
			exclude group: "org.springframework", module: "spring-context"
		}
		testCompile("org.apache.activemq:activemq-stomp:5.8.0")
		testCompile("org.eclipse.jetty:jetty-webapp:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet-api"
		}
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-websocket:${tomcatVersion}")
		testCompile("io.netty:netty-all:${nettyVersion}")
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testRuntime("javax.activation:activation:${activationApiVersion}")
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
	}
}

project("spring-tx") {
	description = "Spring Transaction"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		optional(project(":spring-aop"))
		optional(project(":spring-context"))  // for JCA, @EnableTransactionManagement
		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
		optional("javax.resource:javax.resource-api:${jcaVersion}")
		optional("javax.ejb:javax.ejb-api:${ejbApiVersion}")
		optional("javax.interceptor:javax.interceptor-api:${interceptorApiVersion}")
		optional("com.ibm.websphere:uow:6.0.2.17")
		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
		testCompile("org.eclipse.persistence:javax.persistence:${jpaVersion}")
		testCompile("org.codehaus.groovy:groovy-all:${groovyVersion}")
	}
}

project("spring-jms") {
	description = "Spring JMS"

	dependencies {
		compile(project(":spring-core"))
		compile(project(":spring-beans"))
		compile(project(":spring-aop"))
		compile(project(":spring-context"))
		compile(project(":spring-messaging"))
		compile(project(":spring-tx"))
		provided("javax.jms:javax.jms-api:2.0.1")
		optional(project(":spring-oxm"))
		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
		optional("javax.resource:javax.resource-api:${jcaVersion}")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		testRuntime("javax.activation:activation:${activationApiVersion}")
	}
}

project("spring-jdbc") {
	description = "Spring JDBC"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		compile(project(":spring-tx"))
		optional(project(":spring-context"))  // for JndiDataSourceLookup
		optional("javax.transaction:javax.transaction-api:${jtaVersion}")
		optional("com.mchange:c3p0:0.9.5.2")
		optional("org.hsqldb:hsqldb:${hsqldbVersion}")
		optional("com.h2database:h2:1.4.192")
		optional("org.apache.derby:derby:10.12.1.1")
		optional("org.apache.derby:derbyclient:10.12.1.1")
	}
}

project("spring-context-support") {
	description = "Spring Context Support"

	dependencies {
		compile(project(":spring-core"))
		compile(project(":spring-beans"))
		compile(project(":spring-context"))
		optional(project(":spring-jdbc"))  // for Quartz support
		optional(project(":spring-tx"))  // for Quartz support
		optional("javax.activation:activation:${activationApiVersion}")
		optional("javax.mail:javax.mail-api:${javamailVersion}")
		optional("javax.cache:cache-api:1.0.0")
		optional("com.github.ben-manes.caffeine:caffeine:${caffeineVersion}")
		optional("net.sf.ehcache:ehcache:${ehcacheVersion}")
		optional("org.quartz-scheduler:quartz:2.2.3")
		optional("org.codehaus.fabric3.api:commonj:1.1.0")
		optional("org.freemarker:freemarker:${freemarkerVersion}")
		optional("com.lowagie:itext:2.1.7")
		testCompile(project(":spring-context"))
		testCompile("org.apache.poi:poi:${poiVersion}")
		testCompile("org.hsqldb:hsqldb:${hsqldbVersion}")
		testCompile("org.slf4j:slf4j-api:${slf4jVersion}")
		testRuntime("com.sun.mail:javax.mail:${javamailVersion}")
		testRuntime("org.ehcache:jcache:${ehcachejcacheVersion}")
	}
}

project("spring-web") {
	description = "Spring Web"
	apply plugin: "groovy"

	// Re-generate Protobuf classes from *.proto files and move them in test sources
	if (project.hasProperty('genProtobuf')) {
		apply plugin: 'protobuf'

		task updateGenProtobuf(type:Copy, dependsOn: ":spring-web:generateTestProto") {
			from "${project.buildDir}/generated-sources/test/"
			into "${projectDir}/src/test/java"
			doLast {
				project.delete "${project.buildDir}/generated-sources/test"
			}
		}

		tasks.getByPath("compileTestJava").dependsOn "updateGenProtobuf"
	}

	dependencies {
		compile(project(":spring-aop"))  // for JaxWsPortProxyFactoryBean
		compile(project(":spring-beans"))  // for MultipartFilter
		compile(project(":spring-context"))
		compile(project(":spring-core"))
		provided "javax.servlet:javax.servlet-api:${servletVersion}"
		optional(project(":spring-oxm"))  // for MarshallingHttpMessageConverter
		optional("javax.servlet.jsp:javax.servlet.jsp-api:${jspVersion}")
		optional("javax.el:javax.el-api:${elApiVersion}")
		optional("javax.faces:javax.faces-api:2.2")
		optional("javax.validation:validation-api:${beanvalVersion}")
		optional("javax.activation:activation:${activationApiVersion}")
		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
		optional("com.caucho:hessian:4.0.38")
		optional("commons-fileupload:commons-fileupload:${fileuploadVersion}")
		optional("org.reactivestreams:reactive-streams:${reactivestreamsVersion}")
		optional("io.projectreactor:reactor-core:${reactorCoreVersion}")
		optional("io.projectreactor.ipc:reactor-netty:${reactorNettyVersion}")
		optional("io.reactivex:rxnetty-http:${rxnettyVersion}") {
			exclude group: 'io.reactivex', module: 'rxjava'
		}
		optional("io.reactivex:rxjava:${rxjavaVersion}")
		optional("io.undertow:undertow-core:${undertowVersion}")
		optional("org.jboss.xnio:xnio-api:${xnioVersion}")
		optional("io.netty:netty-buffer:${nettyVersion}") // Temporarily for JsonObjectDecoder
	  	optional("com.fasterxml.woodstox:woodstox-core:${woodstoxVersion}") { // woodstox before aalto
			exclude group: "stax", module: "stax-api"
		}
		optional("com.fasterxml:aalto-xml:1.0.0")
		optional("org.apache.httpcomponents:httpclient:${httpclientVersion}")
		optional("org.apache.httpcomponents:httpasyncclient:${httpasyncVersion}")
		optional("io.netty:netty-all:${nettyVersion}")
		optional("com.squareup.okhttp:okhttp:${okhttpVersion}")
		optional("com.squareup.okhttp3:okhttp:${okhttp3Version}")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		optional("com.fasterxml.jackson.dataformat:jackson-dataformat-xml:${jackson2Version}")
		optional("com.google.code.gson:gson:${gsonVersion}")
		optional("com.rometools:rome:${romeVersion}")
		optional("org.eclipse.jetty:jetty-servlet:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet-api"
		}
		optional("org.eclipse.jetty:jetty-server:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet-api"
		}
		optional("com.google.protobuf:protobuf-java:${protobufVersion}")
		optional("com.google.protobuf:protobuf-java-util:${protobufVersion}")
		optional("com.googlecode.protobuf-java-format:protobuf-java-format:1.4")
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		optional("javax.xml.ws:jaxws-api:${jaxwsVersion}")
		optional("javax.mail:javax.mail-api:${javamailVersion}")
		testCompile(project(":spring-context-support"))  // for JafMediaTypeFactory
		testCompile("org.apache.taglibs:taglibs-standard-jstlel:1.2.1") {
			exclude group: "org.apache.taglibs", module: "taglibs-standard-spec"
		}
		testCompile("com.fasterxml.jackson.datatype:jackson-datatype-joda:${jackson2Version}")
		testCompile("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:${jackson2Version}")
		testCompile("com.fasterxml.jackson.module:jackson-module-kotlin:${jackson2Version}")
		testCompile("org.apache.tomcat:tomcat-util:${tomcatVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
		testCompile("org.eclipse.jetty:jetty-server:${jettyVersion}")
		testCompile("org.eclipse.jetty:jetty-servlet:${jettyVersion}")
		testCompile("com.squareup.okhttp3:mockwebserver:${okhttp3Version}")
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testRuntime("com.sun.mail:javax.mail:${javamailVersion}")
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
		testRuntime("org.jboss.xnio:xnio-nio:${xnioVersion}")
		testRuntime("org.jboss.logging:jboss-logging:3.3.0.Final")
	}
}

project("spring-web-reactive") {
	description = "Spring Web Reactive"

	dependencies {
		compile(project(":spring-core"))
		compile(project(":spring-web"))
		compile "org.reactivestreams:reactive-streams:${reactivestreamsVersion}"
		compile "io.projectreactor:reactor-core:${reactorCoreVersion}"
		optional(project(":spring-context-support"))  // for FreeMarker support
		provided "javax.servlet:javax.servlet-api:${servletVersion}"
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		optional("org.freemarker:freemarker:${freemarkerVersion}")
		optional "org.apache.httpcomponents:httpclient:${httpclientVersion}"
		testCompile("javax.validation:validation-api:${beanvalVersion}")
		testCompile("org.apache.tomcat:tomcat-util:${tomcatVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
		testCompile("org.eclipse.jetty:jetty-server:${jettyVersion}")
		testCompile("org.eclipse.jetty:jetty-servlet:${jettyVersion}")
		testCompile("io.projectreactor.ipc:reactor-netty:${reactorNettyVersion}")
		testCompile("io.reactivex:rxnetty-http:${rxnettyVersion}") {
			exclude group: 'io.reactivex', module: 'rxjava'
		}
		testCompile("io.reactivex:rxjava:${rxjavaVersion}")
		testCompile("io.undertow:undertow-core:${undertowVersion}")
		testCompile("org.jboss.xnio:xnio-api:${xnioVersion}")
		testCompile("com.fasterxml:aalto-xml:1.0.0")
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
		testRuntime("javax.activation:activation:${activationApiVersion}")
		testRuntime("org.jboss.xnio:xnio-nio:${xnioVersion}")
		testRuntime("org.jboss.logging:jboss-logging:3.3.0.Final")
	}
}

project("spring-orm") {
	description = "Spring Object/Relational Mapping"

	dependencies {
		compile(project(":spring-beans"))
		compile(project(":spring-core"))
		compile(project(":spring-jdbc"))
		compile(project(":spring-tx"))
		optional(project(":spring-aop"))
		optional(project(":spring-context"))
		optional(project(":spring-web"))
		optional("org.eclipse.persistence:javax.persistence:${jpaVersion}")
		optional("org.eclipse.persistence:org.eclipse.persistence.core:${eclipselinkVersion}")
		optional("org.eclipse.persistence:org.eclipse.persistence.jpa:${eclipselinkVersion}") {
			exclude group: 'org.eclipse.persistence', module: 'javax.persistence'
		}
		optional("org.hibernate:hibernate-core:${hibernate5Version}")
		optional("javax.servlet:javax.servlet-api:${servletVersion}")
		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
		testCompile("org.hsqldb:hsqldb:${hsqldbVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testRuntime("javax.xml.bind:jaxb-api:${jaxbVersion}")
	}
}

project("spring-webmvc") {
	description = "Spring Web MVC"

	dependencies {
		compile(project(":spring-aop"))
		compile(project(":spring-beans"))
		compile(project(":spring-context"))
		compile(project(":spring-core"))
		compile(files(project(":spring-core").objenesisRepackJar))
		compile(project(":spring-expression"))
		compile(project(":spring-web"))
		provided("javax.servlet:javax.servlet-api:${servletVersion}")
		optional(project(":spring-context-support"))  // for FreeMarker support
		optional(project(":spring-oxm"))  // for MarshallingView
		optional("javax.servlet.jsp:javax.servlet.jsp-api:${jspVersion}")
		optional("javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1")
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		optional("org.apache.poi:poi:${poiVersion}")
		optional("org.apache.poi:poi-ooxml:${poiVersion}")
		optional("org.freemarker:freemarker:${freemarkerVersion}")
		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
		optional("com.lowagie:itext:2.1.7")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		optional("com.fasterxml.jackson.dataformat:jackson-dataformat-xml:${jackson2Version}")
		optional("com.rometools:rome:${romeVersion}")
		optional("javax.el:javax.el-api:${elApiVersion}")
		optional("org.apache.tiles:tiles-api:${tiles3Version}")
		optional("org.apache.tiles:tiles-core:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		optional("org.apache.tiles:tiles-servlet:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		optional("org.apache.tiles:tiles-jsp:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		optional("org.apache.tiles:tiles-el:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		optional("org.apache.tiles:tiles-extras:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
			exclude group: "org.springframework", module: "spring-web"
		}
		optional('org.webjars:webjars-locator:0.32')
		testCompile("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		testCompile("dom4j:dom4j:1.6.1") {
			exclude group: "xml-apis", module: "xml-apis"
		}
		testCompile("jaxen:jaxen:1.1.1") {
			exclude group: "xml-apis", module: "xml-apis"
			exclude group: "xom", module: "xom"
			exclude group: "xerces", module: "xercesImpl"
		}
		testCompile("org.eclipse.jetty:jetty-servlet:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet"
		}
		testCompile("org.eclipse.jetty:jetty-server:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet"
		}
		testCompile("javax.validation:validation-api:${beanvalVersion}")
		testCompile("org.hibernate:hibernate-validator:${hibval5Version}")
		testCompile("org.apache.httpcomponents:httpclient:${httpclientVersion}")
		testCompile("commons-fileupload:commons-fileupload:${fileuploadVersion}")
		testCompile("commons-io:commons-io:1.3")
		testCompile("joda-time:joda-time:${jodaVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testCompile("org.mozilla:rhino:1.7.7.1")
		testRuntime("org.jruby:jruby:9.1.2.0")
		testRuntime("org.python:jython-standalone:2.5.3")
		testRuntime("org.webjars:underscorejs:1.8.3")
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
		testRuntime("javax.activation:activation:${activationApiVersion}")
	}
}

project("spring-websocket") {
	description = "Spring WebSocket"

	dependencies {
		compile(project(":spring-core"))
		compile(project(":spring-context"))
		compile(project(":spring-web"))
		optional(project(":spring-messaging"))
		optional(project(":spring-webmvc"))
		optional("javax.servlet:javax.servlet-api:${servletVersion}")
		optional("javax.websocket:javax.websocket-api:${websocketVersion}")
		optional("org.apache.tomcat:tomcat-websocket:${tomcatVersion}") {
			exclude group: "org.apache.tomcat", module: "tomcat-websocket-api"
			exclude group: "org.apache.tomcat", module: "tomcat-servlet-api"
		}
		optional("org.glassfish.tyrus:tyrus-spi:${tyrusVersion}")
		optional("org.glassfish.tyrus:tyrus-core:${tyrusVersion}")
		optional("org.glassfish.tyrus:tyrus-server:${tyrusVersion}")
		optional("org.glassfish.tyrus:tyrus-container-servlet:${tyrusVersion}")
		optional("org.eclipse.jetty:jetty-webapp:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet"
		}
		optional("org.eclipse.jetty.websocket:websocket-server:${jettyVersion}") {
			exclude group: "javax.servlet", module: "javax.servlet"
		}
		optional("org.eclipse.jetty.websocket:websocket-client:${jettyVersion}")
		optional("org.eclipse.jetty:jetty-client:${jettyVersion}")
		optional("io.undertow:undertow-core:${undertowVersion}")
		optional("io.undertow:undertow-servlet:${undertowVersion}") {
			exclude group: "org.jboss.spec.javax.servlet", module: "jboss-servlet-api_3.1_spec"
			exclude group: "org.jboss.spec.javax.annotation", module: "jboss-annotations-api_1.2_spec"
		}
		optional("io.undertow:undertow-websockets-jsr:${undertowVersion}") {
			exclude group: "org.jboss.spec.javax.websocket", module: "jboss-websocket-api_1.1_spec"
		}
		optional("org.jboss.xnio:xnio-api:${xnioVersion}")
		optional("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}")
		testCompile("org.apache.tomcat.embed:tomcat-embed-websocket:${tomcatVersion}")
		testCompile("io.projectreactor:reactor-core:${reactorVersion}") {
			force = true  // enforce 2.0.x
		}
		testCompile("io.projectreactor:reactor-net:${reactorVersion}")
		testCompile("io.netty:netty-all:${nettyVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testRuntime("org.jboss.xnio:xnio-nio:${xnioVersion}")
		testRuntime("org.jboss.logging:jboss-logging:3.3.0.Final")
	}
}

project("spring-test") {
	description = "Spring TestContext Framework"

	dependencies {
		compile(project(":spring-core"))
		optional(project(":spring-beans"))
		optional(project(":spring-context"))
		optional(project(":spring-jdbc"))
		optional(project(":spring-tx"))
		optional(project(":spring-orm"))
		optional(project(":spring-web"))
		optional(project(":spring-webmvc"))
		optional(project(":spring-websocket"))
		optional("junit:junit:${junitVersion}")
		optional("org.junit.jupiter:junit-jupiter-api:${junitJupiterVersion}")
		optional("org.testng:testng:${testngVersion}")
		optional("javax.inject:javax.inject:1")
		optional("javax.servlet:javax.servlet-api:${servletVersion}")
		optional("javax.servlet.jsp:javax.servlet.jsp-api:${jspVersion}")
		optional("javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1")
		optional("org.apache.taglibs:taglibs-standard-jstlel:1.2.1") {
			exclude group: "org.apache.taglibs", module: "taglibs-standard-spec"
		}
		optional("javax.el:javax.el-api:${elApiVersion}")
		optional("javax.websocket:javax.websocket-api:${websocketVersion}")
		optional("javax.activation:activation:${activationApiVersion}")
		optional("javax.xml.bind:jaxb-api:${jaxbVersion}")
		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
		optional("org.codehaus.groovy:groovy-all:${groovyVersion}")
		optional("org.hamcrest:hamcrest-core:${hamcrestVersion}")
		optional("org.xmlunit:xmlunit-matchers:${xmlunitVersion}")
		optional("net.sourceforge.htmlunit:htmlunit:2.22")
		optional("org.seleniumhq.selenium:htmlunit-driver:2.21")
		optional("org.seleniumhq.selenium:selenium-java:2.53.1") {
			exclude group: "io.netty", module: "netty"
		}
		optional("org.skyscreamer:jsonassert:1.3.0")
		optional("com.jayway.jsonpath:json-path:2.2.0")
		testCompile(project(":spring-context-support"))
		testCompile(project(":spring-oxm"))
		testCompile("javax.mail:javax.mail-api:${javamailVersion}")
		testCompile("javax.ejb:javax.ejb-api:${ejbApiVersion}")
		testCompile("javax.interceptor:javax.interceptor-api:${interceptorApiVersion}")
		testCompile("org.hibernate:hibernate-core:${hibernate5Version}")
		testCompile("org.hibernate:hibernate-validator:${hibval5Version}")
		// Enable use of the JUnitPlatform Runner
		testCompile("org.junit.platform:junit-platform-runner:${junitPlatformVersion}")
		testCompile("com.thoughtworks.xstream:xstream:${xstreamVersion}")
		testCompile("com.fasterxml.jackson.core:jackson-databind:${jackson2Version}")
		testCompile("com.rometools:rome:${romeVersion}")
		testCompile("org.apache.tiles:tiles-api:${tiles3Version}")
		testCompile("org.apache.tiles:tiles-core:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		testCompile("org.apache.tiles:tiles-servlet:${tiles3Version}") {
			exclude group: "org.slf4j", module: "jcl-over-slf4j"
		}
		testCompile("org.hsqldb:hsqldb:${hsqldbVersion}")
		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
		testCompile("org.apache.httpcomponents:httpclient:${httpclientVersion}")
		testCompile("javax.cache:cache-api:1.0.0")
		testRuntime("org.junit.jupiter:junit-jupiter-engine:${junitJupiterVersion}")
		testRuntime("org.apache.logging.log4j:log4j-jul:${log4jVersion}")  // Java Util Logging for JUnit 5
		testRuntime("org.ehcache:ehcache:${ehcache3Version}")
		testRuntime("org.terracotta:management-model:2.0.0")
		testRuntime("com.sun.xml.bind:jaxb-core:${jaxbVersion}")
		testRuntime("com.sun.xml.bind:jaxb-impl:${jaxbVersion}")
	}

	task testNG(type: Test) {
		description = 'Runs TestNG tests.'
		useTestNG()
		scanForTestClasses = false
		include(["**/testng/**/*Tests.class", "**/testng/**/*Test.class"])
		// Show STD_OUT & STD_ERR of the test JVM(s) on the console:
		// testLogging.showStandardStreams = true
		// forkEvery 1
		reports.junitXml.destination = file("$buildDir/test-results")
	}

	test {
		description = 'Runs JUnit tests.'
		dependsOn testNG
		useJUnit()
		scanForTestClasses = false
		include(['**/*Tests.class', '**/*Test.class', '**/SpringJUnitJupiterTestSuite.class'])
		exclude(['**/testng/**/*.*'])
		// Java Util Logging for JUnit 5.
		// systemProperty('java.util.logging.manager', 'org.apache.logging.log4j.jul.LogManager')
		reports.junitXml.destination = file("$buildDir/test-results")
	}

	task aggregateTestReports(type: TestReport) {
		description = 'Aggregates JUnit and TestNG test reports.'
		destinationDir = test.reports.html.destination
		reportOn test, testNG
	}

	check.dependsOn aggregateTestReports
}

project("spring-aspects") {
	description = "Spring Aspects"
	apply from: "aspects.gradle"

	dependencies {
		aspects(project(":spring-orm"))
		ajc("org.aspectj:aspectjtools:${aspectjVersion}")
		rt("org.aspectj:aspectjrt:${aspectjVersion}")
		compile("org.aspectj:aspectjweaver:${aspectjVersion}")
		provided("org.eclipse.persistence:javax.persistence:${jpaVersion}")
		optional(project(":spring-aop"))  // for @Async support
		optional(project(":spring-beans"))  // for @Configurable support
		optional(project(":spring-context"))  // for @Enable* support
		optional(project(":spring-context-support"))  // for JavaMail and JSR-107 support
		optional(project(":spring-orm"))  // for JPA exception translation support
		optional(project(":spring-tx"))  // for JPA, @Transactional support
		optional("javax.transaction:javax.transaction-api:${jtaVersion}")  // for @javax.transaction.Transactional support
		optional("javax.cache:cache-api:1.0.0")
		testCompile(project(":spring-core"))  // for CodeStyleAspect
		testCompile(project(":spring-test"))
		testCompile("javax.mail:javax.mail-api:${javamailVersion}")
	}

	eclipse.project {
		natures += "org.eclipse.ajdt.ui.ajnature"
		buildCommands = [new org.gradle.plugins.ide.eclipse.model.BuildCommand("org.eclipse.ajdt.core.ajbuilder")]
	}
}

project("spring-framework-bom") {
	description = "Spring Framework (Bill of Materials)"

	configurations.archives.artifacts.clear()
	artifacts {
		// work around GRADLE-2406 by attaching text artifact
		archives(file("spring-framework-bom.txt"))
	}

	install {
		repositories.mavenInstaller {
			pom.whenConfigured {
				packaging = "pom"
				withXml {
					asNode().children().last() + {
						delegate.dependencyManagement {
							delegate.dependencies {
								parent.subprojects.sort { "$it.name" }.each { p ->
									if (p.hasProperty("merge") && p.merge.into == null && p != project) {
										delegate.dependency {
											delegate.groupId(p.group)
											delegate.artifactId(p.name)
											delegate.version(p.version)
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

sonarqube {
	properties {
		property "sonar.projectName", "Spring Framework"
		property "sonar.profile", "Spring Framework"
		property "sonar.jacoco.reportPath", "${buildDir.name}/jacoco.exec"
		property "sonar.links.homepage", linkHomepage
		property "sonar.links.ci", linkCi
		property "sonar.links.issue", linkIssue
		property "sonar.links.scm", linkScmUrl
		property "sonar.links.scm_dev", linkScmDevConnection
		property "sonar.java.coveragePlugin", "jacoco"
	}
}

configure(rootProject) {
	description = "Spring Framework"

	apply plugin: "org.asciidoctor.convert"
	apply plugin: "docbook-reference"
	apply plugin: "groovy"

	// apply plugin: "detect-split-packages"
	apply from: "${gradleScriptDir}/jdiff.gradle"

	asciidoctor {
		sourceDir project.file('src/asciidoc')
		separateOutputDirs = false
		backends = ['docbook']
		options doctype: 'book', eruby: 'erubis'
		attributes 'spring-version': project.version, 'revnumber': project.version, 'docinfo': ""
	}

	reference {
		sourceDir = asciidoctor.outputDir
		pdfFilename = "spring-framework-reference.pdf"
		epubFilename = "spring-framework-reference.epub"
		expandPlaceholders = ""
	}

	afterEvaluate {
		tasks.findAll { it.name.startsWith("reference") }.each{ it.dependsOn.add("asciidoctor") }
	}

	// TODO: DetectSplitPackagesPlugin fails in line 154 due to method not found on java.io.File.
	// TODO: Possibly related to user rights or OS differences; passes on local Windows machine.
	// detectSplitPackages {
	//	projectsToScan -= project(":spring-instrument-tomcat")
	// }

	// don't publish the default jar for the root project
	configurations.archives.artifacts.clear()

	dependencies {  // for integration tests
		testCompile(project(":spring-aop"))
		testCompile(project(":spring-beans"))
		testCompile(project(":spring-context"))
		testCompile(project(":spring-core"))
		testCompile(project(":spring-expression"))
		testCompile(project(":spring-jdbc"))
		testCompile(project(":spring-orm"))
		testCompile(project(":spring-test"))
		testCompile(project(":spring-tx"))
		testCompile(project(":spring-web"))
		testCompile("javax.servlet:javax.servlet-api:${servletVersion}")
		testCompile("javax.inject:javax.inject:1")
		testCompile("javax.resource:javax.resource-api:${jcaVersion}")
		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
		testCompile("org.hibernate:hibernate-core:${hibernate5Version}")
		testCompile("org.hsqldb:hsqldb:${hsqldbVersion}")
	}

	task api(type: Javadoc) {
		group = "Documentation"
		description = "Generates aggregated Javadoc API documentation."
		title = "${rootProject.description} ${version} API"

		dependsOn {
			subprojects.collect {
				it.tasks.getByName("jar")
			}
		}
		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = rootProject.description
		options.overview = "src/api/overview.html"
		options.stylesheetFile = file("src/api/stylesheet.css")
		options.splitIndex = true
		options.links(project.ext.javadocLinks)
		options.addStringOption('Xdoclint:none', '-quiet')

		source subprojects.collect { project ->
			project.sourceSets.main.allJava
		}

		maxMemory = "1024m"
		destinationDir = new File(buildDir, "api")

		doFirst {
			classpath = files(
                // ensure Servlet 3.x has precedence on the javadoc classpath
                project(":spring-webmvc").sourceSets.main.compileClasspath.files.find { it =~ "servlet-api" },
				// ensure the javadoc process can resolve types compiled from .aj sources
				project(":spring-aspects").sourceSets.main.output
			)
			classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
		}
	}

	task docsZip(type: Zip, dependsOn: 'reference') {
		group = "Distribution"
		baseName = "spring-framework"
		classifier = "docs"
		description = "Builds -${classifier} archive containing api and reference " +
			"for deployment at http://static.springframework.org/spring-framework/docs."

		from("src/dist") {
			include "changelog.txt"
		}

		from (api) {
			into "javadoc-api"
		}

		from (reference) {
			into "spring-framework-reference"
		}
	}

	task schemaZip(type: Zip) {
		group = "Distribution"
		baseName = "spring-framework"
		classifier = "schema"
		description = "Builds -${classifier} archive containing all " +
			"XSDs for deployment at http://springframework.org/schema."
		duplicatesStrategy 'exclude'
		moduleProjects.each { subproject ->
			def Properties schemas = new Properties();

			subproject.sourceSets.main.resources.find {
				it.path.endsWith("META-INF/spring.schemas")
			}?.withInputStream { schemas.load(it) }

			for (def key : schemas.keySet()) {
				def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
				assert shortName != key
				File xsdFile = subproject.sourceSets.main.resources.find {
					it.path.endsWith(schemas.get(key))
				}
				assert xsdFile != null
				into (shortName) {
					from xsdFile.path
				}
			}
		}
	}

	task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
		group = "Distribution"
		baseName = "spring-framework"
		classifier = "dist"
		description = "Builds -${classifier} archive, containing all jars and docs, " +
			"suitable for community download page."

		ext.baseDir = "${baseName}-${project.version}";

		from("src/dist") {
			include "readme.txt"
			include "license.txt"
			include "notice.txt"
			into "${baseDir}"
			expand(copyright: new Date().format("yyyy"), version: project.version)
		}

		from(zipTree(docsZip.archivePath)) {
			into "${baseDir}/docs"
		}

		from(zipTree(schemaZip.archivePath)) {
			into "${baseDir}/schema"
		}

		moduleProjects.each { subproject ->
			into ("${baseDir}/libs") {
				from subproject.jar
				if (subproject.tasks.findByPath("sourcesJar")) {
					from subproject.sourcesJar
				}
				if (subproject.tasks.findByPath("javadocJar")) {
					from subproject.javadocJar
				}
			}
		}
	}

	// Create a distribution that contains all dependencies (required and optional).
	// Not published by default; only for use when building from source.
	task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
		group = "Distribution"
		baseName = "spring-framework"
		classifier = "dist-with-deps"
		description = "Builds -${classifier} archive, containing everything " +
			"in the -${distZip.classifier} archive plus all runtime dependencies."

		from zipTree(distZip.archivePath)

		gradle.taskGraph.whenReady { taskGraph ->
			if (taskGraph.hasTask(":${zipTask.name}")) {
				def projectNames = rootProject.subprojects*.name
				def artifacts = new HashSet()
				subprojects.each { subproject ->
					(subproject.configurations.runtime.resolvedConfiguration.resolvedArtifacts +
					subproject.configurations.optional.resolvedConfiguration.resolvedArtifacts).each { artifact ->
						def dependency = artifact.moduleVersion.id
						if (!projectNames.contains(dependency.name)) {
							artifacts << artifact.file
						}
					}
				}

				zipTask.from(artifacts) {
					into "${distZip.baseDir}/deps"
				}
			}
		}
	}

	artifacts {
		archives docsZip
		archives schemaZip
		archives distZip
	}

	task wrapper(type: Wrapper) {
		description = "Generates gradlew[.bat] scripts"
		gradleVersion = '3.0'

		doLast() {
			def gradleOpts = "-XX:MaxMetaspaceSize=1024m -Xmx1024m"
			def gradleBatOpts = "$gradleOpts -XX:MaxHeapSize=256m"
			File wrapperFile = file("gradlew")
			wrapperFile.text = wrapperFile.text.replace("DEFAULT_JVM_OPTS=",
				"GRADLE_OPTS=\"$gradleOpts \$GRADLE_OPTS\"\nDEFAULT_JVM_OPTS=")
			File wrapperBatFile = file("gradlew.bat")
			wrapperBatFile.text = wrapperBatFile.text.replace("set DEFAULT_JVM_OPTS=",
				"set GRADLE_OPTS=$gradleBatOpts %GRADLE_OPTS%\nset DEFAULT_JVM_OPTS=")
		}
	}

}

configure([project(':spring-build-src'), project(':spring-framework-bom')]) {
	sonarqube {
		skipProject = true
	}
}

configure(project(':spring-core')) {
	sonarqube {
		properties {
			property "sonar.exclusions",
					"src/main/java/org/springframework/cglib/**/*,src/main/java/org/springframework/asm/**/*"
		}
	}
}

/*
 * Support publication of artifacts versioned by topic branch.
 * CI builds supply `-P BRANCH_NAME=<TOPIC>` to gradle at build time.
 * If <TOPIC> starts with 'SPR-', change version
 *     from BUILD-SNAPSHOT => <TOPIC>-SNAPSHOT
 *     e.g. 3.2.1.BUILD-SNAPSHOT => 3.2.1.SPR-1234-SNAPSHOT
 */
def qualifyVersionIfNecessary(version) {
	if (rootProject.hasProperty("BRANCH_NAME")) {
		def qualifier = rootProject.getProperty("BRANCH_NAME")
		if (qualifier.startsWith("SPR-")) {
			return version.replace('BUILD', qualifier)
		}
	}
	return version
}