build.gradle

import java.text.SimpleDateFormat

buildscript {
	repositories {
		// mavenLocal()
		maven { url 'https://plugins.gradle.org/m2/' }
		maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
	}
	dependencies {
		classpath 'com.diffplug.spotless:spotless-plugin-gradle:3.0.0'
		classpath 'org.ajoberstar:gradle-git:1.6.0'
		classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.0-SNAPSHOT'
		classpath 'com.github.ben-manes:gradle-versions-plugin:0.13.0'
	}
}

plugins {
	id 'com.gradle.build-scan' version '1.3'
	id 'net.nemerosa.versioning' version '2.5.0'
}

buildScan {
	licenseAgreementUrl = 'https://gradle.com/terms-of-service'
	licenseAgree = 'yes'
}


Date buildTimeAndDate = new Date()
ext {
	// Generate JAR manifest only if code was compiled or recompiled;
	// otherwise the junitPlatformTest task will always be executed even if
	// no code changes were made. The reason is that the generation of
	// the buildDate and buildTime causes JAR manifests to be modified
	// which triggers unnecessary rebuilding of the dependent JARs.
	generateManifest = false
	buildDate = new SimpleDateFormat('yyyy-MM-dd').format(buildTimeAndDate)
	buildTime = new SimpleDateFormat('HH:mm:ss.SSSZ').format(buildTimeAndDate)
	buildRevision = versioning.info.commit
	builtByValue = project.hasProperty('builtBy') ? project.builtBy : project.defaultBuiltBy

	platformProjects = [
		'junit-platform-commons',
		'junit-platform-console',
		'junit-platform-engine',
		'junit-platform-gradle-plugin',
		'junit-platform-launcher',
		'junit-platform-runner',
		'junit-platform-surefire-provider'
	]

	jupiterProjects = [
		'junit-jupiter-api',
		'junit-jupiter-engine',
		'junit-jupiter-migration-support'
	]

	vintageProjects = [
		'junit-vintage-engine'
	]

	mavenizedProjects = platformProjects + jupiterProjects + vintageProjects

	licenseHeaderFileProvider = { project ->
		project.name == 'junit-platform-surefire-provider'
			? 'apache-license-2.0.java'
			: 'eclipse-public-license-1.0.java'
	}

	cloverTestProjects = [
		'junit-jupiter-engine',
		'junit-jupiter-migration-support',
		'junit-vintage-engine',
		'junit-platform-surefire-provider',
		'platform-tests'
	]
}

allprojects { subproj ->

	apply plugin: 'java'
	apply plugin: 'eclipse'
	apply plugin: 'idea'
	apply plugin: 'com.diffplug.gradle.spotless'
	apply plugin: 'checkstyle'
	apply plugin: 'com.github.ben-manes.versions' // gradle dependencyUpdates
	apply from: "$rootDir/gradle/degraph.gradle"

	repositories {
		// mavenLocal()
		mavenCentral()
		maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
	}

	tasks.withType(Test) { task ->
		task.testLogging.exceptionFormat = 'full'
	}

	tasks.withType(JavaCompile) {
		sourceCompatibility = rootProject.sourceCompatibility
		targetCompatibility = rootProject.targetCompatibility
	}

	// See: http://docs.oracle.com/javase/8/docs/technotes/tools/windows/javac.html#BHCJCABJ
	compileJava.options*.compilerArgs = [
		'-Xlint:cast',
		'-Xlint:classfile',
		'-Xlint:deprecation',
		'-Xlint:dep-ann',
		'-Xlint:divzero',
		'-Xlint:empty',
		'-Xlint:fallthrough',
		'-Xlint:finally',
		'-Xlint:overrides',
		'-Xlint:path',
		'-Xlint:processing',
		'-Xlint:rawtypes',
		'-Xlint:serial',
		'-Xlint:static',
		'-Xlint:try',
		'-Xlint:unchecked',
		'-Xlint:varargs',
		'-Xlint:-options',
		'-Werror'
	]

	// See: http://docs.oracle.com/javase/8/docs/technotes/tools/windows/javac.html#BHCJCABJ
	compileTestJava.options*.compilerArgs = [
		'-Xlint:cast',
		'-Xlint:classfile',
		'-Xlint:deprecation',
		'-Xlint:dep-ann',
		'-Xlint:divzero',
		'-Xlint:empty',
		'-Xlint:fallthrough',
		'-Xlint:finally',
		'-Xlint:path',
		'-Xlint:processing',
		'-Xlint:rawtypes',
		'-Xlint:serial',
		'-Xlint:static',
		'-Xlint:try',
		'-Xlint:unchecked',
		'-Xlint:varargs',
		'-Xlint:-options',
		'-Xlint:-overrides'
	]

	compileTestJava {
		options.compilerArgs += '-parameters'
	}

	checkstyle {
		toolVersion = 6.11
		configFile = rootProject.file('src/checkstyle/checkstyle.xml')
		sourceSets = [ sourceSets.main ]
	}

	if (project.hasProperty('enableClover') && subproj.name != "documentation") {

		configurations {
			clover
		}

		dependencies {
			clover 'com.atlassian.clover:clover:4.1.1'
		}

		ext.cloverDir = file("$buildDir/clover")
		ext.cloverInitstring = "$cloverDir/clover.db"

		def instrumentedJavaSourcesDir = file("$cloverDir/instrumentedSources/java")

		task cloverTaskdef {
			def cloverLicensePath = project.hasProperty('clover.license.path')
					? project.property('clover.license.path') : rootProject.file('clover.license').absolutePath
			ant.taskdef(resource:'cloverlib.xml', classpath: configurations.clover.asPath)
			ant.property(name: 'clover.license.path', value: cloverLicensePath)
		}

		task cloverInstrumentJava(dependsOn: cloverTaskdef) {
			outputs.dir cloverDir
			onlyIf { sourceSets.main.allJava.any { it.exists() } }
			doLast {
				ant.'clover-instr'(
					initstring: cloverInitstring,
					recordTestResults: false,
					destdir: instrumentedJavaSourcesDir,
					source: compileJava.sourceCompatibility) {
					sourceSets.main.allJava.addToAntBuilder(ant, 'fileset', FileCollection.AntType.FileSet)
				}
			}
		}

		// Disable javac warnings when executing Clover
		compileJava.options*.compilerArgs = ['-Xlint:none']
		compileTestJava.options*.compilerArgs = ['-Xlint:none']

		compileJava.source = instrumentedJavaSourcesDir
		sourceSets.main.compileClasspath += configurations.clover
		sourceSets.test.compileClasspath += configurations.clover
		sourceSets.test.runtimeClasspath += configurations.clover
		compileJava.dependsOn cloverInstrumentJava
	}
}

subprojects { subproj ->
	if (subproj.name in mavenizedProjects) {
		apply plugin: 'maven'
		apply plugin: 'signing'

		if (subproj.name in platformProjects) {
			subproj.group = platformGroup
			subproj.version = platformVersion
		}
		else if (subproj.name in vintageProjects) {
			subproj.group = vintageGroup
			subproj.version = vintageVersion
		}

		javadoc {
			options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
			options.author = true
			options.header = project.name
			options.addStringOption('Xdoclint:html,syntax,reference', '-quiet')
		}

		task sourcesJar(type: Jar, dependsOn: classes) {
			classifier = 'sources'
			from sourceSets.main.allSource
		}

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

		artifacts {
			archives sourcesJar
			archives javadocJar
		}

		tasks.withType(Jar) {
			from(project.projectDir) {
				include 'LICENSE.md'
				into 'META-INF'
			}
		}

		def signArtifacts = !project.version.contains('SNAPSHOT')

		afterEvaluate {
			if (signArtifacts && uploadArchives.enabled) {
				signing {
					sign configurations.archives
				}
			}
		}

		uploadArchives {

			dependsOn check

			repositories {
				mavenDeployer {

					if (signArtifacts) {
						beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
					}

					def ossrhUsername = rootProject.hasProperty('ossrhUsername') ? rootProject.ossrhUsername : ''
					def ossrhPassword = rootProject.hasProperty('ossrhPassword') ? rootProject.ossrhPassword : ''

					repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
						authentication(userName: ossrhUsername, password: ossrhPassword)
					}

					snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
						authentication(userName: ossrhUsername, password: ossrhPassword)
					}

					pom.project {
						name "${project.group}:${project.name}"
						packaging 'jar'
						description "Module \"${project.name}\" of JUnit 5."
						url 'http://junit.org/junit5/'

						scm {
							connection 'scm:git:git://github.com/junit-team/junit5.git'
							developerConnection 'scm:git:git://github.com/junit-team/junit5.git'
							url 'https://github.com/junit-team/junit5'
						}

						licenses {
							license {
								name 'Eclipse Public License v1.0'
								url 'http://www.eclipse.org/legal/epl-v10.html'
							}
						}

						developers {
							developer {
								id 'bechte'
								name 'Stefan Bechtold'
								email 'stefan.bechtold@me.com'
							}
							developer {
								id 'jlink'
								name 'Johannes Link'
								email 'business@johanneslink.net'
							}
							developer {
								id 'marcphilipp'
								name 'Marc Philipp'
								email 'mail@marcphilipp.de'
							}
							developer {
								id 'mmerdes'
								name 'Matthias Merdes'
								email 'Matthias.Merdes@heidelberg-mobil.com'
							}
							developer {
								id 'sbrannen'
								name 'Sam Brannen'
								email 'sam@sambrannen.com'
							}
						}
					}
				}
			}
		}
	} else {
		jar.enabled = false
		javadoc.enabled = false
		uploadArchives.enabled = false
	}

	def normalizeVersion = { versionLiteral ->
		try {
			(versionLiteral =~ /(\d+)\.(\d+)\.(\d+).*/)[0][1..3].join('.')
		} catch(x) {
			throw new GradleException("Version '$versionLiteral' does not match version pattern, e.g. 5.0.0-QUALIFIER")
		}
	}

	compileJava.doLast {
		// Enable JAR manifest generation
		generateManifest = true
	}

	jar {
		onlyIf {
			project.generateManifest
		}
		manifest {
			attributes(
				'Created-By': "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})".toString(),
				'Built-By': builtByValue,
				'Build-Date': buildDate,
				'Build-Time': buildTime,
				'Build-Revision': buildRevision,
				'Specification-Title': project.name,
				'Specification-Version': normalizeVersion(project.version),
				'Specification-Vendor': 'junit.org',
				'Implementation-Title': project.name,
				'Implementation-Version': project.version,
				'Implementation-Vendor': 'junit.org'
			)
		}
	}

	spotless {
		def headerFile = rootProject.file('src/spotless/' + licenseHeaderFileProvider.call(project))

		java {
			licenseHeaderFile headerFile, '(package|import) '
			importOrderFile rootProject.file('src/eclipse/junit-eclipse.importorder')
			eclipseFormatFile rootProject.file('src/eclipse/junit-eclipse-formatter-settings.xml')

			trimTrailingWhitespace()
			endWithNewline()
		}

		format 'groovy', {
			target 'src/**/*.groovy'
			indentWithTabs()
			trimTrailingWhitespace()
			endWithNewline()
			licenseHeaderFile headerFile, "package "

			replaceRegex 'class-level Javadoc indentation fix', /^\*/, ' *'
			replaceRegex 'nested Javadoc indentation fix', /\t\*/, '\t *'
		}
	}

	afterEvaluate {
		if (project.hasProperty('enableClover') && subproj.name in cloverTestProjects) {
			cloverAggregateDatabases.dependsOn subproj.tasks.test
		}
	}

}

configure(rootProject) {
	description = 'JUnit 5'

	apply plugin: "org.ajoberstar.github-pages"

	jar.enabled = false
	uploadArchives.enabled = false

	def ota4jDocVersion = ota4jVersion.contains('SNAPSHOT') ? 'snapshot' : ota4jVersion

	task aggregateJavadocs(type: Javadoc) {
		group = "Documentation"
		description = "Generates aggregated Javadocs"
		title = "JUnit ${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.splitIndex = true
		options.addStringOption('Xdoclint:none', '-quiet')
		options.jFlags '-Xmx1g'
		options.links 'https://docs.oracle.com/javase/8/docs/api/', "http://ota4j-team.github.io/opentest4j/docs/${ota4jDocVersion}/api/"

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

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

		doFirst {
			classpath = files(subprojects.collect { it.sourceSets.main.compileClasspath })
		}
	}

	spotless {
		format 'misc', {
			target '**/*.gradle', '**/*.gitignore'
			indentWithTabs()
			trimTrailingWhitespace()
			endWithNewline()
		}
		format 'documentation', {
			target '**/*.adoc', '**/*.md'
			trimTrailingWhitespace()
			endWithNewline()
		}
	}

	if (project.hasProperty('enableClover')) {

		def cloverAggregationFile = "$cloverDir/coverage.db"

		task cloverAggregateDatabases(dependsOn: cloverTaskdef) {
			outputs.file cloverAggregationFile
			doLast {
				ant.'clover-merge'(initString: cloverAggregationFile) {
					subprojects.each { project ->
						def cloverDbFile = project.file(project.cloverInitstring)
						if(cloverDbFile.exists()) {
							cloverDb(initString: project.cloverInitstring)
						}
					}
				}
			}
		}

		task cloverHtmlReport(dependsOn: cloverAggregateDatabases) {
			outputs.dir "$buildDir/reports/clover/html"
			doLast {
				ant."clover-report"(initString: cloverAggregationFile) {
					current(outfile: "$buildDir/reports/clover/html", title: rootProject.description, homepage: 'overview') {
						format(type: 'html')
					}
				}
			}
		}

		task cloverXmlReport(dependsOn: cloverAggregateDatabases) {
			outputs.file "$buildDir/reports/clover/clover.xml"
			doLast {
				ant."clover-report"(initString: cloverAggregationFile) {
					current(outfile: "$buildDir/reports/clover/clover.xml") {
						format(type: 'xml')
					}
				}
			}
		}
	}

	def docsVersion = project.version.contains('SNAPSHOT') ? 'snapshot' : project.version
	def docsDir = new File(buildDir, 'ghpages-docs')

	task prepareDocsForUploadToGhPages(dependsOn: [aggregateJavadocs, ":documentation:asciidoctor"], type: Copy) {
		outputs.dir docsDir

		from(project(':documentation').buildDir) {
			include 'asciidoc/**'
		}
		from("$buildDir/docs") {
			include 'javadoc/**'
		}
		into "${docsDir}/${docsVersion}"
		filesMatching('asciidoc/**') { fileCopyDetails ->
			fileCopyDetails.path = fileCopyDetails.path.replace('asciidoc/', 'user-guide/')
		}
		filesMatching('javadoc/**') { fileCopyDetails ->
			fileCopyDetails.path = fileCopyDetails.path.replace('javadoc/', 'api/')
		}
		includeEmptyDirs = false
	}

	task createCurrentDocsFolder(dependsOn: prepareDocsForUploadToGhPages, type: Copy) {
		outputs.dir "${docsDir}/current"

		from "${docsDir}/${docsVersion}"
		into "${docsDir}/current"
	}

	createCurrentDocsFolder.onlyIf { project.hasProperty('replaceCurrentDocs') }

	githubPages {
		repoUri = 'https://github.com/junit-team/junit5.git'

		credentials {
			username = project.hasProperty('githubToken') ? project.githubToken : ''
			password = ''
		}

		pages {
			from docsDir
			into "docs"
		}

		deleteExistingFiles = false
	}

	prepareGhPages.dependsOn(prepareDocsForUploadToGhPages)
	prepareGhPages.dependsOn(createCurrentDocsFolder)

	task wrapper(type: Wrapper) {
		description = 'Generates gradlew and gradlew.bat scripts'
		gradleVersion = '3.3'
	}

}