build.gradle

/*
 * Copyright 2016-2020 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.
 */

plugins {
	id 'checkstyle'
	id 'io.spring.nohttp'
	id 'io.spring.javaformat'
}

description = "Spring CredHub"

ext {
	springBootVersion = "3.3.4"
	javadocLinks = [
			"https://docs.oracle.com/en/java/javase/17/docs/api/",
			"https://docs.spring.io/spring-framework/docs/current/javadoc-api/"
	] as String[]
}

configure(allprojects) {
	apply plugin: 'java'
	apply plugin: 'eclipse'
	apply plugin: 'checkstyle'
	apply plugin: 'io.spring.nohttp'
	apply plugin: 'io.spring.javaformat'

	group = 'org.springframework.credhub'

	checkstyle {
		toolVersion = "9.3"
		configDirectory.set(rootProject.file("src/checkstyle"))
	}

	nohttp {
		allowlistFile = rootProject.file("src/nohttp/allowlist.lines")
	}
	
	dependencies {
		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.43")
	}
}

configure(libraryProjects) {
	apply plugin: 'java-library'

	java {
		withJavadocJar()
		withSourcesJar()
	}

	javadoc {
		options.encoding = 'UTF-8'
		options.memberLevel = JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = project.name
	}

	sourcesJar {
		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
		archiveClassifier.set "sources"
		from sourceSets.main.allJava
	}

	javadocJar {
		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
		archiveClassifier.set "javadoc"
		from javadoc
	}
}

configure(publishedProjects) {
	apply from: "${rootProject.projectDir}/publish-maven.gradle"
}

subprojects {
	tasks.withType(JavaCompile) {
		options.encoding = 'UTF-8'
		options.compilerArgs.addAll(["-Werror", "-Xlint:unchecked", "-Xlint:deprecation"])
	}

	java {
		toolchain {
			languageVersion = JavaLanguageVersion.of(17)
		}
		registerFeature('reactive') {
			usingSourceSet(sourceSets.main)
		}
		registerFeature('security') {
			usingSourceSet(sourceSets.main)
		}
		registerFeature('httpclient') {
			usingSourceSet(sourceSets.main)
		}
	}

	dependencies {
		testRuntimeOnly("org.junit.platform:junit-platform-launcher")
		testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
	}

	tasks.withType(Test).forEach { Test task ->
		task.with {
			// enable JUnit 5
			useJUnitPlatform()
			scanForTestClasses = true
			group = "verification"

			// add jvm arg to resolve BlockHound issues, see https://github.com/reactor/BlockHound/issues/33
			jvmArgs += [
					"-XX:+AllowRedefinitionToAddDeleteMethods"
			]

			testLogging {
				exceptionFormat = "full"
				events = ["passed", "skipped", "failed"]
			}

			// print failed tests after the execution
			def failedTests = []
			afterTest { test, result ->
				if (result.resultType == TestResult.ResultType.FAILURE) {
					failedTests << test
				}
			}

			// create a summary after the execution
			afterSuite { desc, result ->
				if (!desc.parent) {
					println "\nTest result: ${result.resultType}"
					println "Test summary: ${result.testCount} tests, " +
							"${result.successfulTestCount} succeeded, " +
							"${result.failedTestCount} failed, " +
							"${result.skippedTestCount} skipped"

					failedTests.each { test -> println "FAILED test: ${test.className} > ${test.name}" }
				}
			}
		}
	}

}

configure(rootProject) {
	task sourcesJar(type: Jar) {
		archiveClassifier.set('sources')
		from sourceSets.main.allSource
	}

	task javadocJar(type: Jar) {
		archiveClassifier.set('javadoc')
		from javadoc.destinationDir
	}

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

		options.encoding = 'UTF-8'
		options.memberLevel = JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = rootProject.description
		options.links(project.ext.javadocLinks)

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

		classpath = files(subprojects.collect { project ->
			project.sourceSets.main.compileClasspath
		})

		exclude '**/spring-credhub-integration-tests/**', '**/spring-credhub-reactive-integration-tests/**'

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

	task docsZip(type: Zip, dependsOn: [':spring-credhub-docs:asciidoctor']) {
		group = 'Distribution'
		archiveClassifier.set('docs')
		description = "Builds -${archiveClassifier} archive containing api and reference " +
				"for deployment at docs.spring.io/spring-credhub/docs."

		from(api) {
			into 'api'
		}
		from(project.tasks.findByPath(':spring-credhub-docs:asciidoctor')) {
			into 'reference'
		}
	}

	artifacts {
		archives docsZip
	}
	
	publishing {
		publications {
			mavenJava(MavenPublication) {
				artifact sourcesJar
				artifact javadocJar
				artifact docsZip
			}
		}
	}

	task dist(dependsOn: assemble) {
		group = "Distribution"
		description = "Builds -dist and -docs distribution archives."
	}
}

def getDocumentationProjects() {
	[project(":spring-credhub-docs")] as Set
}

def getTestProjects() {
	[project(":spring-credhub-integration-tests"),
	 project(":spring-credhub-reactive-integration-tests")] as Set
}

def getJavaProjects() {
	subprojects
}

def getLibraryProjects() {
	javaProjects - documentationProjects - testProjects
}

def getPublishedProjects() {
	libraryProjects + rootProject
}