build.gradle

buildscript {
	ext.kotlinVersion = '1.4.32'
	repositories {
		mavenCentral()
		maven { url 'https://plugins.gradle.org/m2' }
		maven { url 'https://repo.spring.io/plugins-release' }
	}
	dependencies {
		classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
		classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion"
	}
}

plugins {
	id 'base'
	id 'project-report'
	id 'idea'
	id 'org.sonarqube' version '2.8'
	id 'org.ajoberstar.grgit' version '4.0.1' apply false
	id 'io.spring.nohttp' version '0.0.5.RELEASE'
	id 'io.spring.dependency-management' version '1.0.10.RELEASE' apply false
	id 'com.jfrog.artifactory' version '4.18.2' apply false
	id 'org.asciidoctor.jvm.pdf' version '3.3.0'
	id 'org.asciidoctor.jvm.gems' version '3.3.0'
	id 'org.asciidoctor.jvm.convert' version '3.3.0'
}

apply plugin: 'io.spring.nohttp'

def gitPresent = new File('.git').exists()

if(gitPresent) {
	apply plugin: 'org.ajoberstar.grgit'
}

description = 'Spring for Apache Kafka'

ext {
	linkHomepage = 'https://github.com/spring-projects/spring-kafka'
	linkCi = 'https://build.spring.io/browse/SK'
	linkIssue = 'https://github.com/spring-projects/spring-kafka/issues'
	linkScmUrl = 'https://github.com/spring-projects/spring-kafka'
	linkScmConnection = 'https://github.com/spring-projects/spring-kafka.git'
	linkScmDevConnection = 'git@github.com:spring-projects/spring-kafka.git'
	docResourcesVersion = '0.2.5'


	if (gitPresent) {
		modifiedFiles =
			files(grgit.status().unstaged.modified).filter{ f -> f.name.endsWith('.java') || f.name.endsWith('.kt') }
	}

	assertjVersion = '3.20.1'
	awaitilityVersion = '4.1.0'
	googleJsr305Version = '3.0.2'
	hamcrestVersion = '2.2'
	hibernateValidationVersion = '6.2.0.Final'
	jacksonBomVersion = '2.12.4'
	jaywayJsonPathVersion = '2.4.0'
	junit4Version = '4.13.2'
	junitJupiterVersion = '5.7.2'
	kafkaVersion = '2.8.0'
	log4jVersion = '2.14.1'
	micrometerVersion = '1.8.0-M1'
	mockitoVersion = '3.11.2'
	reactorVersion = '2020.0.9'
	scalaVersion = '2.13'
	springBootVersion = '2.4.8' // docs module
	springDataVersion = '2021.1.0-M1'
	springRetryVersion = '1.3.1'
	springVersion = '5.3.9'

	idPrefix = 'kafka'
}

nohttp {
	source.include '**/src/**'
	source.exclude '**/*.gif', '**/*.ks'
}

allprojects {
	group = 'org.springframework.kafka'

	apply plugin: 'io.spring.dependency-management'

	dependencyManagement {
		resolutionStrategy {
			cacheChangingModulesFor 0, 'seconds'
		}
		applyMavenExclusions = false
		generatedPomCustomization {
			enabled = false
		}

		imports {
			mavenBom "com.fasterxml.jackson:jackson-bom:$jacksonBomVersion"
			mavenBom "org.junit:junit-bom:$junitJupiterVersion"
			mavenBom "org.springframework:spring-framework-bom:$springVersion"
			mavenBom "io.projectreactor:reactor-bom:$reactorVersion"
			mavenBom "org.springframework.data:spring-data-bom:$springDataVersion"
		}
	}

	repositories {
		mavenCentral()
		maven { url 'https://repo.spring.io/libs-milestone' }
		if (version.endsWith('SNAPSHOT')) {
			maven { url 'https://repo.spring.io/libs-snapshot' }
		}
//		maven { url 'https://repository.apache.org/content/groups/staging/' }
	}

}

subprojects { subproject ->
	apply plugin: 'java-library'
	apply plugin: 'java'
	apply from: "${rootProject.projectDir}/publish-maven.gradle"
	apply plugin: 'eclipse'
	apply plugin: 'idea'
	apply plugin: 'jacoco'
	apply plugin: 'checkstyle'
	apply plugin: 'kotlin'
	apply plugin: 'kotlin-spring'

	java {
		withJavadocJar()
		withSourcesJar()
		registerFeature('optional') {
			usingSourceSet(sourceSets.main)
		}
		registerFeature('provided') {
			usingSourceSet(sourceSets.main)
		}
	}

	compileJava {
		sourceCompatibility = 1.8
		targetCompatibility = 1.8
	}

	compileTestJava {
		sourceCompatibility = 11
		options.encoding = 'UTF-8'
	}

	compileTestKotlin {
		kotlinOptions {
			jvmTarget = '1.8'
		}
	}

	eclipse.project.natures += 'org.springframework.ide.eclipse.core.springnature'

	jacoco {
		toolVersion = '0.8.6'
	}

	// dependencies that are common across all java projects
	dependencies {
		implementation "com.google.code.findbugs:jsr305:$googleJsr305Version"
		testImplementation 'org.junit.jupiter:junit-jupiter-api'
		testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
		testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

		// To avoid compiler warnings about @API annotations in JUnit code
		testCompileOnly 'org.apiguardian:apiguardian-api:1.0.0'

		testRuntimeOnly "org.apache.logging.log4j:log4j-slf4j-impl:$log4jVersion"

		testImplementation 'org.jetbrains.kotlin:kotlin-reflect'
		testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
		testImplementation("org.awaitility:awaitility:$awaitilityVersion") {
			exclude group: 'org.hamcrest'
		}
		testImplementation "org.hamcrest:hamcrest-core:$hamcrestVersion"
		optionalApi "org.assertj:assertj-core:$assertjVersion"
	}

	// enable all compiler warnings; individual projects may customize further
	[compileJava, compileTestJava]*.options*.compilerArgs = ['-Xlint:all,-options']

	test {
		testLogging {
			events "skipped", "failed"
			showStandardStreams = project.hasProperty("showStandardStreams") ?: false
			showExceptions = true
			showStackTraces = true
			exceptionFormat = 'full'
		}

		maxHeapSize = '1536m'
//		jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:8111'
		jacoco {
			destinationFile = file("$buildDir/jacoco.exec")
		}
		useJUnitPlatform()

		if (System.properties['sonar.host.url']) {
			finalizedBy jacocoTestReport
		}
	}

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

	jacocoTestReport {
		reports {
			xml.enabled true
			csv.enabled false
			html.enabled false
			xml.destination file("${buildDir}/reports/jacoco/test/jacocoTestReport.xml")
		}
	}

	publishing {
		publications {
			mavenJava(MavenPublication) {
				suppressAllPomMetadataWarnings()
				from components.java
				pom.withXml {
					def pomDeps = asNode().dependencies.first()
					subproject.configurations.providedImplementation.allDependencies.each { dep ->
						pomDeps.remove(pomDeps.'*'.find { it.artifactId.text() == dep.name })
						pomDeps.appendNode('dependency').with {
							it.appendNode('groupId', dep.group)
							it.appendNode('artifactId', dep.name)
							it.appendNode('version', dep.version)
							it.appendNode('scope', 'provided')
						}
					}
				}
			}
		}
	}

	task updateCopyrights {
		onlyIf { gitPresent && !System.getenv('GITHUB_ACTION') && !System.getenv('bamboo_buildKey') }
		if (gitPresent) {
			inputs.files(modifiedFiles.filter { f -> f.path.contains(subproject.name) })
		}
		outputs.dir('build')

		doLast {
			def now = Calendar.instance.get(Calendar.YEAR) as String
			inputs.files.each { file ->
				def line
				file.withReader { reader ->
					while (line = reader.readLine()) {
						def matcher = line =~ /Copyright (20\d\d)-?(20\d\d)?/
						if (matcher.count) {
							def beginningYear = matcher[0][1]
							if (now != beginningYear && now != matcher[0][2]) {
								def years = "$beginningYear-$now"
								def sourceCode = file.text
								sourceCode = sourceCode.replaceFirst(/20\d\d(-20\d\d)?/, years)
								file.write(sourceCode)
								println "Copyright updated for file: $file"
							}
							break
						}
					}
				}
			}
		}
	}

	compileKotlin.dependsOn updateCopyrights

	jar {
		manifest {
			attributes(
					'Implementation-Version': archiveVersion,
					'Created-By': "JDK ${System.properties['java.version']} (${System.properties['java.specification.vendor']})",
					'Implementation-Title': subproject.name,
					'Implementation-Vendor-Id': subproject.group,
					'Implementation-Vendor': 'Pivotal Software, Inc.',
					'Implementation-URL': linkHomepage,
					'Automatic-Module-Name': subproject.name.replace('-', '.')  // for Jigsaw
			)
		}

		from("${rootProject.projectDir}/src/dist") {
			include 'license.txt'
			include 'notice.txt'
			into 'META-INF'
			expand(copyright: new Date().format('yyyy'), version: project.version)
		}
	}

}

project ('spring-kafka') {
	description = 'Spring Kafka Support'

	dependencies {
		api 'org.springframework:spring-context'
		api 'org.springframework:spring-messaging'
		api 'org.springframework:spring-tx'
		api ("org.springframework.retry:spring-retry:$springRetryVersion") {
			exclude group: 'org.springframework'
		}
		api "org.apache.kafka:kafka-clients:$kafkaVersion"
		optionalApi "org.apache.kafka:kafka-streams:$kafkaVersion"

		optionalApi 'com.fasterxml.jackson.core:jackson-core'
		optionalApi 'com.fasterxml.jackson.core:jackson-databind'
		optionalApi 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8'
		optionalApi 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
		optionalApi 'com.fasterxml.jackson.datatype:jackson-datatype-joda'
		optionalApi ('com.fasterxml.jackson.module:jackson-module-kotlin') {
			exclude group: 'org.jetbrains.kotlin'
		}

		// Spring Data projection message binding support
		optionalApi ("org.springframework.data:spring-data-commons") {
			exclude group: 'org.springframework'
		}
		optionalApi "com.jayway.jsonpath:json-path:$jaywayJsonPathVersion"

		optionalApi 'io.projectreactor:reactor-core'
		optionalApi 'io.projectreactor.kafka:reactor-kafka'
		optionalApi "io.micrometer:micrometer-core:$micrometerVersion"

		testImplementation project (':spring-kafka-test')
		testImplementation 'io.projectreactor:reactor-test'
		testImplementation "org.mockito:mockito-junit-jupiter:$mockitoVersion"
		testImplementation "org.hibernate.validator:hibernate-validator:$hibernateValidationVersion"
	}
}

project ('spring-kafka-test') {
	description = 'Spring Kafka Test Support'

	dependencies {
		api 'org.springframework:spring-context'
		api 'org.springframework:spring-test'
		api ("org.springframework.retry:spring-retry:$springRetryVersion") {
			exclude group: 'org.springframework'
		}

		api "org.apache.kafka:kafka-clients:$kafkaVersion:test"
		api "org.apache.kafka:kafka-streams:$kafkaVersion"
		api "org.apache.kafka:kafka-streams-test-utils:$kafkaVersion"
		api "org.apache.kafka:kafka_$scalaVersion:$kafkaVersion"
		api "org.apache.kafka:kafka_$scalaVersion:$kafkaVersion:test"
		api 'org.junit.jupiter:junit-jupiter-api'
		optionalApi "org.hamcrest:hamcrest-core:$hamcrestVersion"
		optionalApi "org.mockito:mockito-core:$mockitoVersion"
		optionalApi ("junit:junit:$junit4Version") {
			exclude group: 'org.hamcrest', module: 'hamcrest-core'
		}
		optionalApi "org.apache.logging.log4j:log4j-core:$log4jVersion"
	}
}

project ('spring-kafka-docs') {
	description = 'Spring Kafka Code Snippets For Docs'

	dependencies {
		api "org.springframework.boot:spring-boot-starter:$springBootVersion"
		api project (':spring-kafka')
		optionalApi 'org.jetbrains.kotlin:kotlin-stdlib'
		optionalApi 'com.fasterxml.jackson.core:jackson-core'
		optionalApi 'com.fasterxml.jackson.core:jackson-databind'
	}

	compileKotlin {
		kotlinOptions {
			jvmTarget = '1.8'
		}
	}

	sonarqube {
		skipProject = true
	}

}

sonarqube {
	properties {
		property 'sonar.links.homepage', linkHomepage
		property 'sonar.links.ci', linkCi
		property 'sonar.links.issue', linkIssue
		property 'sonar.links.scm', linkScmUrl
		property 'sonar.links.scm_dev', linkScmDevConnection
	}
}

configurations {
	docs
}

dependencies {
	docs "io.spring.docresources:spring-doc-resources:${docResourcesVersion}@zip"
}

task prepareAsciidocBuild(type: Sync) {
	dependsOn configurations.docs
	from {
		configurations.docs.collect { zipTree(it) }
	}
	from 'spring-kafka-docs/src/main/asciidoc/','spring-kafka-docs/src/main/java','spring-kafka-docs/src/main/kotlin'
	into "$buildDir/asciidoc"
}

asciidoctorPdf {
	dependsOn prepareAsciidocBuild
	baseDirFollowsSourceFile()
	configurations 'asciidoctorExt'

	asciidoctorj {
		sourceDir "$buildDir/asciidoc"
		inputs.dir(sourceDir)
		sources {
			include 'index.adoc'
		}
		options doctype: 'book'
		attributes 'icons': 'font',
		'sectanchors': '',
		'sectnums': '',
		'toc': '',
		'source-highlighter' : 'coderay',
		revnumber: project.version,
		'project-version': project.version
	}
}

asciidoctorj {
	version = '2.4.1'
	// fatalWarnings ".*"
	options doctype: 'book', eruby: 'erubis'
	attributes([
			icons: 'font',
			idprefix: '',
			idseparator: '-',
			docinfo: 'shared',
			revnumber: project.version,
			sectanchors: '',
			sectnums: '',
			'source-highlighter': 'highlight.js',
			highlightjsdir: 'js/highlight',
			'highlightjs-theme': 'googlecode',
			stylesdir: 'css/',
			stylesheet: 'stylesheet.css',
			'spring-version': project.version,
			'project-version': project.version,
			'java-examples': 'org/springframework/kafka/jdocs',
			'kotlin-examples': 'org/springframework/kafka/kdocs'
	])
}

asciidoctor {
	dependsOn asciidoctorPdf
	baseDirFollowsSourceFile()
	configurations 'asciidoctorExt'
	sourceDir = file("$buildDir/asciidoc")
	sources {
		include '*.adoc'
	}
	resources {
		from(sourceDir) {
			include 'images/*', 'css/**', 'js/**'
		}
	}

}

task reference(dependsOn: asciidoctor) {
	group = 'Documentation'
	description = 'Generate the reference documentation'
}

reference.onlyIf { "$System.env.NO_REFERENCE_TASK" != 'true' || project.hasProperty('ignoreEnvToStopReference') }

task api(type: Javadoc) {
	group = 'Documentation'
	description = 'Generates aggregated Javadoc API documentation.'
	title = "${rootProject.description} ${version} API"
	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
	options.author = true
	options.header = rootProject.description
	options.overview = 'src/api/overview.html'

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

	classpath = files(subprojects.collect { project ->
		project.sourceSets.main.compileClasspath
	})
	destinationDir = new File(buildDir, 'api')
}

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

	from('src/dist') {
		include 'changelog.txt'
	}

	from(api) {
		into 'api'
	}

	from ('build/docs/asciidoc') {
		into 'reference/html'
	}

	from ('build/docs/asciidocPdf') {
		include 'index.pdf'
		rename 'index.pdf', 'spring-kafka-reference.pdf'
		into 'reference/pdf'
	}
}

task distZip(type: Zip, dependsOn: [docsZip]) { //, schemaZip]) {
	group = 'Distribution'
	archiveClassifier = 'dist'
	description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
			"suitable for community download page."

	ext.baseDir = "${project.name}-${project.version}"

	from('src/dist') {
		include 'readme.txt'
		include 'license.txt'
		include 'notice.txt'
		into "${baseDir}"
	}

	from(zipTree(docsZip.archivePath)) {
		into "${baseDir}/docs"
	}

	subprojects.each { subproject ->
		into ("${baseDir}/libs") {
			from subproject.jar
			from subproject.sourcesJar
			from subproject.javadocJar
		}
	}
}

artifacts {
	archives distZip
	archives docsZip
}

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

apply from: "${rootProject.projectDir}/publish-maven.gradle"

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifact docsZip
			artifact distZip
		}
	}
}

apply from: "${rootDir}/gradle/docs.gradle"