build.gradle

import java.time.OffsetDateTime
import java.time.format.DateTimeFormatter

plugins {
	id 'java-library'
	id 'eclipse'
	id 'idea'
	id 'maven-publish'
	id 'signing'
	id 'com.diffplug.spotless' version '6.25.0'
	id 'net.nemerosa.versioning' version '3.1.0'
	id 'org.ajoberstar.git-publish' version '4.2.2'
	id 'biz.aQute.bnd.builder' version '7.0.0'
	id 'io.github.gradle-nexus.publish-plugin' version '2.0.0'
}

def buildTimeAndDate = OffsetDateTime.now()
ext {
	buildDate = DateTimeFormatter.ISO_LOCAL_DATE.format(buildTimeAndDate)
	buildTime = DateTimeFormatter.ofPattern("HH:mm:ss.SSSZ").format(buildTimeAndDate)
	builtByValue = project.hasProperty('builtBy') ? project.builtBy : project.defaultBuiltBy
}

description = 'Open Test Alliance for the JVM'
def moduleName = 'org.opentest4j'

repositories {
	mavenCentral()
}

java {
	withJavadocJar()
	withSourcesJar()
}

compileJava {
	javaCompiler.set(javaToolchains.compilerFor {
		languageVersion = JavaLanguageVersion.of(11)
	})
	options.compilerArgs = ['--release', '6', '-Xlint:-options']
}

tasks.register('compileModule', JavaCompile) {
	def moduleSrcDir = file('src/module/java')
	source(moduleSrcDir)
	destinationDirectory.set(layout.buildDirectory.dir("classes/java/modules"))
	classpath = compileJava.classpath
	inputs.property("moduleName", moduleName)
	inputs.property("moduleVersion", project.version)
	options.compilerArgs = [
			'--release', '9',
			'--module-version', project.version as String,
			'--module-source-path', moduleSrcDir.toString(),
			'--patch-module', "$moduleName=${sourceSets.main.allJava.srcDirs.join(':')}",
			'--module', moduleName
	]
}

dependencies {
	testImplementation("junit:junit:${junit4Version}")
}

test {
	testLogging {
		exceptionFormat = 'full'
	}
}

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

jar {
	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': versioning.info.commit,
			'Specification-Title': project.name,
			'Specification-Version': normalizeVersion(project.version),
			'Specification-Vendor': 'opentest4j.org',
			'Implementation-Title': project.name,
			'Implementation-Version': project.version,
			'Implementation-Vendor': 'opentest4j.org',
		)
	}
	bundle {
		bnd(
			'Bundle-Name': 'opentest4j',
			'Bundle-SymbolicName': moduleName,
			'Bundle-License': 'The Apache License, Version 2.0',
			'Bundle-Vendor': 'opentest4j.org',
			'-exportcontents': 'org.opentest4j.*'
		)
	}
	from(files(compileModule.destinationDirectory.dir(moduleName)).builtBy(compileModule)) {
		include('module-info.class')
	}

	from(".") {
		include("LICENSE")
		include("COPYRIGHT")
		into("META-INF")
	}
}

javadoc {
	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
	options.author = true
	options.header = 'Open Test Alliance for the JVM'
	options.addStringOption('Xdoclint:html,syntax,reference', '-quiet')
	options.links 'https://docs.oracle.com/en/java/javase/11/docs/api/'
}

spotless {
	java {
		licenseHeaderFile rootProject.file('etc/spotless/apache-license-2.0.java')
		importOrder('java', 'javax', 'com', 'org')
		eclipse().configFile(rootProject.file('etc/eclipse/eclipse-formatter-settings.xml'))

		trimTrailingWhitespace()
		endWithNewline()
	}
}

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

if (signArtifacts) {
	signing {
		useGpgCmd()
		sign(publishing.publications)
	}
}

nexusPublishing {
	repositories {
		sonatype()
	}
}

publishing {
	publications {
		maven(MavenPublication) {
			from(components.java)
			pom {
				name = "${project.group}:${project.name}"
				description = project.description
				url = 'https://github.com/ota4j-team/opentest4j'
				scm {
					connection = 'scm:git:git://github.com/ota4j-team/opentest4j.git'
					developerConnection = 'scm:git:git://github.com/ota4j-team/opentest4j.git'
					url = 'https://github.com/ota4j-team/opentest4j'
				}
				licenses {
					license {
						name = 'The Apache License, Version 2.0'
						url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
					}
				}
				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@heidelpay.com'
					}
					developer {
						id = 'sbrannen'
						name = 'Sam Brannen'
						email = 'sam@sambrannen.com'
					}
				}
			}
		}
	}
}

tasks.withType(PublishToMavenRepository).configureEach {
	dependsOn(check)
}

spotless {
	format 'misc', {
		target fileTree(rootDir) {
			include '*.gradle', '*.md', '.gitignore'
		}
		indentWithTabs()
		trimTrailingWhitespace()
		endWithNewline()
	}
}

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

tasks.register('prepareDocsForUploadToGhPages', Copy) {
	dependsOn(javadoc)
	outputs.dir docsDir

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

def replaceCurrentDocs = project.hasProperty('replaceCurrentDocs')

tasks.register('createCurrentDocsFolder', Copy) {
	dependsOn prepareDocsForUploadToGhPages
	outputs.dir "${docsDir}/current"

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

	enabled = replaceCurrentDocs
}

gitPublish {
	repoUri.set("https://github.com/ota4j-team/opentest4j.git")
	branch.set("gh-pages")
	sign.set(false)
	fetchDepth.set(1)

	contents {
		from(docsDir)
		into("docs")
	}

	preserve {
		include("**/*")
		exclude("docs/$docsVersion/**")
		if (replaceCurrentDocs) {
			exclude("docs/current/**")
		}
	}
}

tasks.named("gitPublishCopy") {
	dependsOn(prepareDocsForUploadToGhPages)
	dependsOn(createCurrentDocsFolder)
}