Revert "Refactor Gradle tasks in Spring Framework build"

This reverts commit 1539ba89.

build.gradle

@@ -14,13 +14,20 @@ plugins {
 	id 'org.springframework.build.test-sources' apply false
 	id "io.spring.dependency-management" version "1.0.7.RELEASE" apply false
 	id "org.jetbrains.kotlin.jvm" version "1.3.41" apply false
-	id "org.jetbrains.dokka" version "0.9.18" apply false
+	id "org.jetbrains.dokka" version "0.9.18"
 	id "org.asciidoctor.convert" version "1.5.8"
 }
 
 ext {
+	linkHomepage = "https://spring.io/projects/spring-framework"
+	linkCi = "https://build.spring.io/browse/SPR"
+	linkIssue = "https://github.com/spring-projects/spring-framework/issues"
+	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 != "spring-framework-bom") && (it.name != "spring-core-coroutines") && (it.name != "integration-tests")
+		(it.name != "spring-framework-bom") && (it.name != "spring-core-coroutines")
 	}
 
 	aspectjVersion       = "1.9.4"
@@ -44,6 +51,7 @@ ext {
 	tomcatVersion        = "9.0.22"
 	undertowVersion      = "2.0.23.Final"
 
+	gradleScriptDir = "${rootProject.projectDir}/gradle"
 	withoutJclOverSlf4j = {
 		exclude group: "org.slf4j", module: "jcl-over-slf4j"
 	}
@@ -53,10 +61,13 @@ configure(allprojects) { project ->
 	group = "org.springframework"
 
 	apply plugin: "java"
+	apply plugin: "kotlin"
 	apply plugin: "checkstyle"
 	apply plugin: 'org.springframework.build.compile'
+	apply plugin: 'org.springframework.build.optional-dependencies'
+	apply plugin: 'org.springframework.build.test-sources'
 	apply plugin: "io.spring.dependency-management"
-	apply from: "${rootDir}/gradle/ide.gradle"
+	apply from: "${gradleScriptDir}/ide.gradle"
 
 	dependencyManagement {
 		resolutionStrategy {
@@ -85,19 +96,17 @@ configure(allprojects) { project ->
 		}
 	}
 
-	pluginManager.withPlugin("kotlin") {
-		apply plugin: "org.jetbrains.dokka"
-		compileKotlin {
-			kotlinOptions {
-				jvmTarget = "1.8"
-				freeCompilerArgs = ["-Xjsr305=strict"]
-			}
+	compileKotlin {
+		kotlinOptions {
+			jvmTarget = "1.8"
+			freeCompilerArgs = ["-Xjsr305=strict"]
 		}
-		compileTestKotlin {
-			kotlinOptions {
-				jvmTarget = "1.8"
-				freeCompilerArgs = ["-Xjsr305=strict"]
-			}
+	}
+
+	compileTestKotlin {
+		kotlinOptions {
+			jvmTarget = "1.8"
+			freeCompilerArgs = ["-Xjsr305=strict"]
 		}
 	}
 
@@ -170,18 +179,67 @@ configure(allprojects) { project ->
 	] as String[]
 }
 
-configure(moduleProjects) { project ->
-	apply from: "${rootDir}/gradle/spring-module.gradle"
+configure(subprojects.findAll { (it.name != "spring-core-coroutines"
+		&& it.name != "spring-integration-tests") } ) { subproject ->
+	apply from: "${gradleScriptDir}/publish-maven.gradle"
+
+	jar {
+		manifest.attributes["Implementation-Title"] = subproject.name
+		manifest.attributes["Implementation-Version"] = subproject.version
+		manifest.attributes["Automatic-Module-Name"] = subproject.name.replace('-', '.')  // for Jigsaw
+		manifest.attributes["Created-By"] =
+				"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
+
+		from("${rootProject.projectDir}/src/docs/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.encoding = "UTF-8"
+		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
+		options.author = true
+		options.header = project.name
+		options.use = true
+		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) {
+		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+		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
+	}
 }
 
 configure(rootProject) {
 	description = "Spring Framework"
 
 	apply plugin: "groovy"
-	apply plugin: "kotlin"
 	apply plugin: "io.spring.nohttp"
 	apply plugin: 'org.springframework.build.api-diff'
-	apply from: "${rootDir}/gradle/docs.gradle"
+	apply from: "${gradleScriptDir}/docs.gradle"
 
 	nohttp {
 		source.exclude "**/test-output/**"
@@ -200,6 +258,9 @@ configure(rootProject) {
 		}
 	}
 
+	// Don't publish the default jar for the root project
+	configurations.archives.artifacts.clear()
+
 	dependencies {
 		asciidoctor("io.spring.asciidoctor:spring-asciidoctor-extensions:0.1.3.RELEASE")
 	}
@@ -209,5 +270,6 @@ configure(rootProject) {
 		archives schemaZip
 		archives distZip
 	}
+
 }
 

gradle/docs.gradle

-/**
- * Produce Javadoc for all Spring Framework modules in "build/docs/javadoc"
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
+
 task api(type: Javadoc) {
 	group = "Documentation"
 	description = "Generates aggregated Javadoc API documentation."
 	title = "${rootProject.description} ${version} API"
 
 	dependsOn {
-		moduleProjects.collect {
+		subprojects.collect {
 			it.tasks.getByName("jar")
 		}
 	}
+	options.encoding = "UTF-8"
+	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
+	options.author = true
+	options.header = rootProject.description
+	options.use = true
+	options.overview = "src/docs/api/overview.html"
+	options.stylesheetFile = file("src/docs/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 the javadoc process can resolve types compiled from .aj sources
 				project(":spring-aspects").sourceSets.main.output
 		)
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-	}
-
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		header = rootProject.description
-		use = true
-		overview = "src/docs/api/overview.html"
-		stylesheetFile = file("src/docs/api/stylesheet.css")
-		splitIndex = true
-		links(project.ext.javadocLinks)
-		addStringOption('Xdoclint:none', '-quiet')
-		if(JavaVersion.current().isJava9Compatible()) {
-			addBooleanOption('html5', true)
-		}
+		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
 	}
-	source moduleProjects.collect { project ->
-		project.sourceSets.main.allJava
-	}
-	maxMemory = "1024m"
-	destinationDir = file("$buildDir/docs/javadoc")
 }
 
-/**
- * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
- */
 dokka {
 	dependsOn {
 		tasks.getByName("api")
 	}
 	doFirst {
-		classpath = moduleProjects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-		sourceDirs = files(moduleProjects
-				.findAll {
-					it.pluginManager.hasPlugin("kotlin")
-				}
-				.collect { project ->
-					def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
-					kotlinDirs -= project.sourceSets.main.java.srcDirs
-				})
+		classpath = subprojects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
+		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
+
 	}
 	moduleName = "spring-framework"
 	outputFormat = "html"
 	outputDirectory = "$buildDir/docs/kdoc"
 
+	sourceDirs = files(subprojects.collect { project ->
+		def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
+		kotlinDirs -= project.sourceSets.main.java.srcDirs
+	})
 	externalDocumentationLink {
 		url = new URL("https://docs.spring.io/spring-framework/docs/$version/javadoc-api/")
-		packageListUrl = new File(buildDir, "docs/javadoc/package-list").toURI().toURL()
+		packageListUrl = new File(buildDir, "api/package-list").toURI().toURL()
 	}
 	externalDocumentationLink {
 		url = new URL("https://projectreactor.io/docs/core/release/api/")
@@ -97,10 +101,6 @@ task extractDocResources(type: Sync) {
 	into "$buildDir/asciidoc/build"
 }
 
-/**
- * Produce the Spring Framework Reference documentation
- * from "src/docs/asciidoc" into  "build/asciidoc/html5"
- */
 asciidoctor {
 	sourceDir "$buildDir/asciidoc/build"
 	sources {
@@ -136,54 +136,52 @@ asciidoctor {
 
 asciidoctor.dependsOn extractDocResources
 
-/**
- * Zip all docs (API and reference) into a single archive
- */
 task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'dokka']) {
 	group = "Distribution"
-	description = "Builds -${archiveClassifier} archive containing api and reference " +
+	baseName = "spring-framework"
+	classifier = "docs"
+	description = "Builds -${classifier} archive containing api and reference " +
 			"for deployment at https://docs.spring.io/spring-framework/docs."
 
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("docs")
 	from("src/dist") {
 		include "changelog.txt"
 	}
+
 	from (api) {
 		into "javadoc-api"
 	}
+
 	from ("$asciidoctor.outputDir/html5") {
 		into "spring-framework-reference"
 	}
+
 	from ("$asciidoctor.outputDir/pdf") {
 		into "spring-framework-reference/pdf"
 	}
+
 	from (dokka) {
 		into "kdoc-api"
 	}
 }
 
-/**
- * Zip all Spring Framework schemas into a single archive
- */
 task schemaZip(type: Zip) {
 	group = "Distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("schema")
-	description = "Builds -${archiveClassifier} archive containing all " +
+	baseName = "spring-framework"
+	classifier = "schema"
+	description = "Builds -${classifier} archive containing all " +
 			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy DuplicatesStrategy.EXCLUDE
-	moduleProjects.each { module ->
+	duplicatesStrategy 'exclude'
+	moduleProjects.each { subproject ->
 		def Properties schemas = new Properties();
 
-		module.sourceSets.main.resources.find {
+		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 = module.sourceSets.main.resources.find {
+			File xsdFile = subproject.sourceSets.main.resources.find {
 				it.path.endsWith(schemas.get(key))
 			}
 			assert xsdFile != null
@@ -194,19 +192,15 @@ task schemaZip(type: Zip) {
 	}
 }
 
-/**
- * Create a distribution zip with everything:
- * docs, schemas, jars, source jars, javadoc jars
- */
 task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 
 	group = "Distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("dist")
-	description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
+	baseName = "spring-framework"
+	classifier = "dist"
+	description = "Builds -${classifier} archive, containing all jars and docs, " +
 			"suitable for community download page."
 
-	ext.baseDir = "${archiveBaseName}-${project.version}";
+	ext.baseDir = "${baseName}-${project.version}";
 
 	from("src/docs/dist") {
 		include "readme.txt"
@@ -224,17 +218,49 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 		into "${baseDir}/schema"
 	}
 
-	moduleProjects.each { module ->
+	moduleProjects.each { subproject ->
 		into ("${baseDir}/libs") {
-			from module.jar
-			if (module.tasks.findByPath("sourcesJar")) {
-				from module.sourcesJar
+			from subproject.jar
+			if (subproject.tasks.findByPath("sourcesJar")) {
+				from subproject.sourcesJar
 			}
-			if (module.tasks.findByPath("javadocJar")) {
-				from module.javadocJar
+			if (subproject.tasks.findByPath("javadocJar")) {
+				from subproject.javadocJar
 			}
 		}
 	}
 }
 
-distZip.mustRunAfter moduleProjects.check
+distZip.mustRunAfter subprojects.test
+
+// 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"
+			}
+		}
+	}
+}

gradle/spring-module.gradle → gradle/publish-maven.gradle

-apply plugin: 'org.springframework.build.compile'
-apply plugin: 'org.springframework.build.optional-dependencies'
-apply plugin: 'org.springframework.build.test-sources'
 apply plugin: "maven"
 
-jar {
-	manifest.attributes["Implementation-Title"] = project.name
-	manifest.attributes["Implementation-Version"] = project.version
-	manifest.attributes["Automatic-Module-Name"] = project.name.replace('-', '.')  // for Jigsaw
-	manifest.attributes["Created-By"] =
-			"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
-
-	from("${rootDir}/src/docs/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.encoding = "UTF-8"
-	options.memberLevel = JavadocMemberLevel.PROTECTED
-	options.author = true
-	options.header = project.name
-	options.use = true
-	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) {
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	archiveClassifier.set("sources")
-	from sourceSets.main.allSource
-	// Don't include or exclude anything explicitly by default. See SPR-12085.
-}
-
-task javadocJar(type: Jar) {
-	archiveClassifier.set("javadoc")
-	from javadoc
-}
-
-artifacts {
-	archives sourcesJar
-	archives javadocJar
-}
-
 install {
 	repositories.mavenInstaller {
 		customizePom(pom, project)

integration-tests/integration-tests.gradle

 description = "Spring Integration Tests"
 
-apply plugin: "org.springframework.build.test-sources"
-
 dependencies {
 	testCompile(project(":spring-aop"))
 	testCompile(project(":spring-beans"))

spring-beans/spring-beans.gradle

 description = "Spring Beans"
 
 apply plugin: "groovy"
-apply plugin: "kotlin"
 
 dependencies {
 	compile(project(":spring-core"))

spring-context/spring-context.gradle

 description = "Spring Context"
 
 apply plugin: "groovy"
-apply plugin: "kotlin"
 
 dependencyManagement {
 	imports {

spring-core-coroutines/spring-core-coroutines.gradle

 description = "Spring Core Coroutines support"
 
-apply plugin: "kotlin"
-
 dependencies {
 	compile("org.jetbrains.kotlin:kotlin-reflect")
 	compile("org.jetbrains.kotlin:kotlin-stdlib")
@@ -10,11 +8,6 @@ dependencies {
 	compile("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
 }
 
-// Avoid publishing coroutines JAR to the artifact repository
-if (project.hasProperty("artifactoryPublish")) {
-	artifactoryPublish.skip = true
-}
-
 eclipse {
 	project {
 		buildCommand "org.jetbrains.kotlin.ui.kotlinBuilder"

spring-core/spring-core.gradle

 description = "Spring Core"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"

spring-framework-bom/spring-framework-bom.gradle

 description = "Spring Framework (Bill of Materials)"
 
-apply plugin: "maven"
-
 configurations.archives.artifacts.clear()
 artifacts {
 	// work around GRADLE-2406 by attaching text artifact

spring-jdbc/spring-jdbc.gradle

 description = "Spring JDBC"
 
-apply plugin: "kotlin"
-
 dependencies {
 	compile(project(":spring-beans"))
 	compile(project(":spring-core"))

spring-messaging/spring-messaging.gradle

 description = "Spring Messaging"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"

spring-test/spring-test.gradle

 description = "Spring TestContext Framework"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"

spring-web/spring-web.gradle

 description = "Spring Web"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"

spring-webflux/spring-webflux.gradle

 description = "Spring WebFlux"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"

spring-webmvc/spring-webmvc.gradle

 description = "Spring Web MVC"
 
-apply plugin: "kotlin"
-
 dependencyManagement {
 	imports {
 		mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"