build.gradle

/*
 * Copyright (c) 2011-2017 Pivotal Software Inc, All Rights Reserved.
 *
 * 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
 *
 *       http://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.
 */
import me.champeau.gradle.japicmp.JapicmpTask
import org.gradle.api.internal.plugins.osgi.OsgiHelper

buildscript {
  ext.kotlinVersion = '1.2.51'
  repositories {
	maven { url "http://repo.spring.io/plugins-release" }
  }
  dependencies {
	classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
	classpath 'io.spring.gradle:spring-io-plugin:0.0.4.RELEASE'
	classpath 'com.github.jengelman.gradle.plugins:shadow:1.2.0'
	classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
	classpath 'org.jruby:jruby-complete:9.1.17.0'
	classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.7'
	classpath 'org.asciidoctor:asciidoctorj-pdf:1.5.0-alpha.16'
  }
}

plugins {
  id 'org.asciidoctor.convert' version '1.5.6'
  id "me.champeau.gradle.jmh" version "0.4.7" apply false
  id "org.jetbrains.dokka" version "0.9.16"
  id "me.champeau.gradle.japicmp" version "0.2.6"
}

apply from: "gradle/doc.gradle"
apply from: "gradle/setup.gradle"


ext {
  //also set up the special version at root, for refguide
  if (project.hasProperty('versionBranch') && version.toString().endsWith(".BUILD-SNAPSHOT")) {
	versionBranch = versionBranch.replaceAll("\"", "").trim()
	if (!versionBranch.isEmpty()) {
	  realVersion = version.toString().replace("BUILD-SNAPSHOT", versionBranch + ".BUILD-SNAPSHOT")
	  project.version = realVersion
	}
  }

  // Metrics
  micrometerVersion = 'latest.release' //TODO specify a version of micrometer?

  // Logging
  slf4jVersion = '1.7.12'
  logbackVersion = '1.1.2'

  // Testing
  assertJVersion = '3.11.1'
  mockitoVersion = '2.23.0'
  jUnitParamsVersion = '1.1.1'

  javadocLinks = ["https://docs.oracle.com/javase/8/docs/api/",
				  "https://docs.oracle.com/javaee/6/api/",
				  "http://www.reactive-streams.org/reactive-streams-1.0.2-javadoc/"] as String[]


  bundleImportPackages = ['org.slf4j;resolution:=optional;version="[1.5.4,2)"',
						  'kotlin.*;resolution:=optional',
						  '!javax.annotation',
						  '!javax.annotation.meta',
						  '*']
}

configure(subprojects) { p ->
  apply plugin: 'java'
  apply plugin: 'kotlin'
  apply plugin: 'jacoco'
  apply plugin: 'propdeps'
  apply plugin: 'osgi'

  description = 'Non-Blocking Reactive Foundation for the JVM'
  group = 'io.projectreactor'

  ext {
	//set up special version per sub-project
	//(the root level configuration doesn't seem to propagate)
	if (project.hasProperty('versionBranch') && version.toString().endsWith(".BUILD-SNAPSHOT")) {
	  versionBranch = versionBranch.replaceAll("\"", "").trim()
	  if (!versionBranch.isEmpty()) {
		realVersion = p.version.toString().replace("BUILD-SNAPSHOT", versionBranch + ".BUILD-SNAPSHOT")
		p.version = realVersion
		println "Building special ${project} snapshot ${p.version}"
		println "OSGI version would be: ${new OsgiHelper().getVersion(p.version.toString())}"
	  }
	}
  }

  repositories {
	mavenLocal()
	if (version.endsWith('BUILD-SNAPSHOT') || project.hasProperty('platformVersion')) {
	  maven { url 'http://repo.spring.io/libs-snapshot' }
	}

	mavenCentral()
	jcenter()
	maven { url 'http://repo.spring.io/libs-milestone' }
	maven { url "https://oss.sonatype.org/content/repositories/releases/" }

  }

  jacoco {
	toolVersion = '0.8.2'
  }

  jacocoTestReport {
	reports {
	  xml.enabled = true
	  html.enabled = true
	}
  }

  [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
  [compileJava, compileTestJava]*.options*.compilerArgs =
		  ["-Xlint:-varargs", // intentionally disabled
		   "-Xlint:cast",
		   "-Xlint:classfile",
		   "-Xlint:dep-ann",
		   "-Xlint:divzero",
		   "-Xlint:empty",
		   "-Xlint:finally",
		   "-Xlint:overrides",
		   "-Xlint:path",
		   "-Xlint:processing",
		   "-Xlint:static",
		   "-Xlint:try",
		   "-Xlint:deprecation",
		   "-Xlint:unchecked",
		   "-Xlint:-serial",      // intentionally disabled
		   "-Xlint:-options",     // intentionally disabled
		   "-Xlint:-fallthrough", // intentionally disabled
		   "-Xlint:-rawtypes"     // TODO enable and fix warnings
		  ]

  compileJava {
	sourceCompatibility = 1.8
	targetCompatibility = 1.8
  }

  compileTestJava {
	sourceCompatibility = 1.8
	targetCompatibility = 1.8
  }

  compileKotlin {
	kotlinOptions.jvmTarget = "1.8"
	kotlinOptions.freeCompilerArgs = ["-Xjsr305=strict"]
  }

  compileTestKotlin {
	kotlinOptions.jvmTarget = "1.8"
	kotlinOptions.freeCompilerArgs = ["-Xjsr305=strict"]
  }

  if (JavaVersion.current().isJava8Compatible()) {
	compileTestJava.options.compilerArgs += "-parameters"
	p.tasks.withType(Javadoc) {
	  options.addStringOption('Xdoclint:none', '-quiet')
	}
  }

  //includes for base test task (see below for additional common configurations)
  test {
	include '**/*Tests.*'
	include '**/*Test.*'
	include '**/*Spec.*'
  }

  //all test tasks will show FAILED for each test method,
  // common exclusions, no scanning
  p.tasks.withType(Test).all {
	testLogging {
	  events "FAILED"
	  showExceptions true
	  exceptionFormat "FULL"
	  stackTraceFilters "ENTRY_POINT"
	  maxGranularity 3
	}

	if (JavaVersion.current().isJava9Compatible()) {
	  println "Java 9+: lowering MaxGCPauseMillis to 20ms in ${project.name} ${name}"
	  jvmArgs = ["-XX:MaxGCPauseMillis=20"]
	}

	systemProperty("java.awt.headless", "true")
	systemProperty("reactor.trace.cancel", "true")
	systemProperty("reactor.trace.nocapacity", "true")
	systemProperty("testGroups", p.properties.get("testGroups"))
	scanForTestClasses = false
	exclude '**/*Abstract*.*'
	exclude '**/*OperatorTest*.*'

	//allow re-run of failed tests only without special test tasks failing
	// because the filter is too restrictive
	filter.setFailOnNoMatchingTests(false)

	//display intermediate results for special test tasks
	afterSuite { desc, result ->
	  if (!desc.parent) { // will match the outermost suite
		println('\n' + "${desc} Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)")
	  }
	}
  }

  // now that kotlin-gradle-plugin 1.1.60 is out with fix for https://youtrack.jetbrains.com/issue/KT-17564
  // be wary and fail if the issue of source file duplication in jar comes up again
  sourcesJar {
	duplicatesStrategy = DuplicatesStrategy.FAIL
  }

}

if (project.hasProperty('platformVersion')) {
  apply plugin: 'spring-io'

  dependencyManagement {
	springIoTestRuntime {
	  imports {
		mavenBom "io.spring.platform:platform-bom:$platformVersion"
	  }
	}
  }
}


project('reactor-core') {
  apply plugin: 'idea' //needed to avoid IDEA seeing the jmh folder as source
  apply plugin: 'me.champeau.gradle.jmh'

  sourceSets {
	noMicrometerTest {
	  java.srcDir 'src/test/java'
	  resources.srcDir 'src/test/resources'
	}
  }

  configurations {
	compileOnly.extendsFrom jsr166backport
	testCompile.extendsFrom jsr166backport
	baseline
	noMicrometerTestRuntime {
	  extendsFrom testRuntime
	  exclude group:"io.micrometer", module:"micrometer-core"
	}
  }

  dependencies {
	// Reactive Streams
	compile "org.reactivestreams:reactive-streams:1.0.2"
	testCompile "org.reactivestreams:reactive-streams-tck:1.0.2"

	// JSR-305 annotations
	optional "com.google.code.findbugs:jsr305:3.0.2"

	//Optional Logging Operator
	optional "org.slf4j:slf4j-api:$slf4jVersion"

	//Optional Metrics
	optional "io.micrometer:micrometer-core:$micrometerVersion"

	optional("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")

	//Optional JDK 9 Converter
	jsr166backport "io.projectreactor:jsr166:1.0.0.RELEASE"

	testCompile 'junit:junit:4.12'

	testRuntime "ch.qos.logback:logback-classic:$logbackVersion"
	testRuntime "io.micrometer:micrometer-core:$micrometerVersion"
	// Testing
	testCompile(project(":reactor-test")) {
	  exclude module: 'reactor-core'
	}

	testCompile "org.hamcrest:hamcrest-library:1.3",
			"org.testng:testng:6.8.5",
			"org.assertj:assertj-core:$assertJVersion",
			"org.mockito:mockito-core:$mockitoVersion",
			"org.openjdk.jol:jol-core:0.9",
			"pl.pragmatists:JUnitParams:$jUnitParamsVersion",
			"org.awaitility:awaitility:3.1.2"

	if ("$compatibleVersion" != "SKIP") {
	  baseline("io.projectreactor:reactor-core:$compatibleVersion") {
		transitive = false
		force = true
	  }
	}

	noMicrometerTestCompile sourceSets.main.output
	noMicrometerTestCompile sourceSets.test.output
	noMicrometerTestCompile configurations.testCompile
  }

  jmh {
	resultFormat = 'JSON'
  }

  task japicmp(type: JapicmpTask) {
	onlyIf { "$compatibleVersion" != "SKIP" }
	oldClasspath = configurations.baseline
	newClasspath = files(jar.archivePath)
	onlyBinaryIncompatibleModified = true
	failOnModification = true
	failOnSourceIncompatibility = true
	txtOutputFile = file("${project.buildDir}/reports/japi.txt")
	ignoreMissingClasses = true
	includeSynthetic = true

	//TODO after a release, bump the gradle.properties baseline
	//TODO after a release, remove the reactor-core exclusions below if any
//	classExcludes = []
//	methodExcludes = ["reactor.core.Scannable#operatorName()"]
  }

  javadoc {
	dependsOn jar
	group = "documentation"
	description = "Generates aggregated Javadoc API documentation."
	title = "Reactor Core $version"

	options.addStringOption('charSet', 'UTF-8')

	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
	options.author = true
	options.header = "$project.name"
	options.overview = "$rootDir/docs/api/overview.html"
	options.stylesheetFile = file("$rootDir/docs/api/stylesheet.css")
	options.links(rootProject.ext.javadocLinks )
	options.tags = [ "apiNote:a:API Note:", "implSpec:a:Implementation Requirements:",
					 "implNote:a:Implementation Note:", "reactor.errorMode:m:Error Mode Support",
					 "reactor.discard:m:onDiscard Support"]

	// In Java 9, javadoc generator will complain if it finds invalid class files in the classpath
	// And Kotlin produces such classes, plus kotlin plugin puts them in the main sourceSet
	classpath = sourceSets.main.output.filter { !it.absolutePath.contains("kotlin") }
	classpath += sourceSets.main.compileClasspath

	maxMemory = "1024m"
	destinationDir = new File(project.buildDir, "docs/javadoc")

	doLast {
	  // work around https://github.com/gradle/gradle/issues/4046
	  copy {
		from('src/main/java')
		into "$project.buildDir/docs/javadoc/"
		include "**/doc-files/*"
	  }
	}
  }

  // Need https://github.com/Kotlin/dokka/issues/184 to be fixed to avoid "Can't find node by signature" log spam
  task dokka(type: org.jetbrains.dokka.gradle.DokkaTask) {
	dependsOn jar
	group = "documentation"
	description = "Generates Kotlin API documentation."
	moduleName = "reactor-core"
	jdkVersion = 8

	outputFormat = "html"
	outputDirectory = new File(project.buildDir, "docs/kdoc")

	//this is needed so that links to java classes are resolved
	doFirst {
	  classpath += project.jar.outputs.files.getFiles()
	  classpath += project.sourceSets.main.compileClasspath
	}
	//this is needed so that the kdoc only generates for kotlin classes
	//(default kotlinTasks sourceSet also includes java)
	kotlinTasks {

	}
	processConfigurations = []
	sourceDirs = files("src/main/kotlin")

	externalDocumentationLink {
	  url = new URL("http://projectreactor.io/docs/core/release/api/")
	}
	externalDocumentationLink {
	  url = new URL("http://www.reactive-streams.org/reactive-streams-1.0.2-javadoc/")
	}
  }

  task kdocZip(type: Zip, dependsOn: dokka) {
	//ends up similar to javadoc jar: reactor-core-xxxx.RELEASE-kdoc.zip
	classifier = 'kdoc'
	from("${project.buildDir}/docs/kdoc")
  }

  task testStaticInit(type: Test, group: 'verification') {
	systemProperty 'reactor.trace.operatorStacktrace', 'true'
	include '**/*TestStaticInit.*'
	doFirst {
	  println "Additional tests from `testStaticInit` ($includes)"
	}
	afterSuite { TestDescriptor descriptor, TestResult result ->
	    if (result.testCount > 0 && (result.skippedTestCount + result.failedTestCount + result.successfulTestCount == 0)) {
			throw new GradleException("No static initialization tests were executed")
		}
	}
  }

  task loops(type: Test, group: 'verification') {
	mustRunAfter testStaticInit
	include '**/*Loop.*'
	doFirst {
	  println "Additional tests from `loops` ($includes)"
	}
  }

  task testNG(type: Test, group: 'verification') {
	mustRunAfter testStaticInit
	useTestNG()
	include '**/*Verification.*'
	doFirst {
	  println "Additional tests from `testNG` ($includes)"
	}
  }

  task testNoMicrometer(type: Test, group: 'verification') {
	testClassesDirs = sourceSets.noMicrometerTest.output.classesDirs
	classpath = sourceSets.noMicrometerTest.runtimeClasspath
	include '**/*NoMicrometerTest.*'

	doFirst {
	  println "Additional tests without Micrometer ($includes)"
	}
  }

  //inherit basic test task + common configuration in root
  //always depend on testStaticInit, skip testNG on Travis, skip loops when not releasing
  //note that this way the tasks can be run individually
  test {
	dependsOn testStaticInit
	dependsOn testNoMicrometer
	if (System.env.TRAVIS != "true") {
	  dependsOn testNG
	}
	if (!version.endsWith('BUILD-SNAPSHOT')) {
	  dependsOn loops
	}
  }

  if (!JavaVersion.current().isJava9Compatible()) {
	test {
	  jvmArgs = ["-Xbootclasspath/p:" + configurations.jsr166backport.asPath]
	}
  }

  jar {
	manifest {
	  attributes 'Implementation-Title': 'reactor-core',
			  'Implementation-Version': version
	  instruction 'Import-Package', bundleImportPackages.join(',')
	}
  }

  artifacts {
	archives sourcesJar
	archives javadocJar
	archives docsZip
	archives kdocZip
  }

  jacocoTestReport.dependsOn test
  check.dependsOn jacocoTestReport
  jar.finalizedBy(japicmp)
}




project('reactor-test') {
  description = 'Reactor Test support'

  configurations {
	baseline
  }

  dependencies {
	compile project(":reactor-core")

	testCompile 'junit:junit:4.12'

	testRuntime "ch.qos.logback:logback-classic:$logbackVersion"

	testCompile "org.hamcrest:hamcrest-library:1.3",
			"org.assertj:assertj-core:$assertJVersion",
			"org.mockito:mockito-core:$mockitoVersion"

	if ("$compatibleVersion" != "SKIP") {
	  baseline("io.projectreactor:reactor-test:$compatibleVersion") {
		transitive = false
		force = true
	  }
	}
  }

  task japicmp(type: JapicmpTask) {
	onlyIf { "$compatibleVersion" != "SKIP" }
	oldClasspath = configurations.baseline
	newClasspath = files(jar.archivePath)
	onlyBinaryIncompatibleModified = true
	failOnModification = true
	failOnSourceIncompatibility = true
	txtOutputFile = file("${project.buildDir}/reports/japi.txt")
	ignoreMissingClasses = true
	includeSynthetic = true

	//TODO after a release, remove the reactor-test exclusions below if any
  }

  javadoc {
	dependsOn jar
	group = "documentation"
	description = "Generates aggregated Javadoc API documentation."
	title = "Reactor Test $version"

	options.addStringOption('charSet', 'UTF-8')

	options.memberLevel = JavadocMemberLevel.PROTECTED
	options.author = true
	options.header = "$project.name"
	options.stylesheetFile = file("$rootDir/docs/api/stylesheet.css")
	options.links(rootProject.ext.javadocLinks
			.plus("http://projectreactor.io/docs/core/release/api/") as String[])
	options.tags = [ "apiNote:a:API Note:", "implSpec:a:Implementation Requirements:",
					 "implNote:a:Implementation Note:" ]

	// In Java 9, javadoc generator will complain if it finds invalid class files in the classpath
	// And Kotlin produces such classes, plus kotlin plugin puts them in the main sourceSet
	classpath = sourceSets.main.output.filter { !it.absolutePath.contains("kotlin") }
	classpath += sourceSets.main.compileClasspath

	maxMemory = "1024m"
	destinationDir = new File(project.buildDir, "docs/javadoc")
  }

  // Need https://github.com/Kotlin/dokka/issues/184 to be fixed to avoid "Can't find node by signature" log spam
  task dokka(type: org.jetbrains.dokka.gradle.DokkaTask) {
	dependsOn jar
	group = "documentation"
	description = "Generates Kotlin API documentation."
	moduleName = "reactor-test"
	jdkVersion = 8

	outputFormat = "html"
	outputDirectory = new File(project.buildDir, "docs/kdoc")

	//this is needed so that links to java classes are resolved
	doFirst {
	  classpath += project.jar.outputs.files.getFiles()
	  classpath += project.sourceSets.main.compileClasspath
	}
	//this is needed so that the kdoc only generates for kotlin classes
	//(default kotlinTasks sourceSet also includes java)
	kotlinTasks {

	}
	processConfigurations = []
	sourceDirs = files("src/main/kotlin")

	externalDocumentationLink {
	  url = new URL("http://projectreactor.io/docs/core/release/api/")
	}
	externalDocumentationLink {
	  url = new URL("http://projectreactor.io/docs/test/release/api/")
	}
	externalDocumentationLink {
	  url = new URL("http://www.reactive-streams.org/reactive-streams-1.0.2-javadoc/")
	}
  }

  task kdocZip(type: Zip, dependsOn: dokka) {
	//ends up similar to javadoc jar: reactor-test-xxx.RELEASE-kdoc.zip
	classifier = 'kdoc'
	from("${project.buildDir}/docs/kdoc")
  }

  artifacts {
	archives kdocZip
  }

  jar.finalizedBy(japicmp)
}

assemble.dependsOn docsZip