build.gradle

buildscript {
	configurations.classpath {
		resolutionStrategy.activateDependencyLocking()
	}
}

plugins {
	id "java-library"
	id "org.jetbrains.kotlin.jvm"
	id "com.github.ben-manes.versions"
	id "org.jetbrains.kotlin.kapt"
	id "org.jetbrains.kotlin.plugin.spring" // opens certain classes
	id "jacoco"
	id "org.sonarqube"
	id "maven-publish"
}

group = "dev.capybaralabs.shipa"
version = "$shipaVersion"

allprojects {
	java {
		toolchain {
			languageVersion = JavaLanguageVersion.of(theJavaVersion)
			vendor = JvmVendorSpec.ADOPTIUM
		}
		withSourcesJar()
		consistentResolution {
			useCompileClasspathVersions()
		}
	}

	tasks.withType(JavaCompile).configureEach {
		dependsOn(processResources)
		options.encoding = "UTF-8"
		options.release.set(theJavaVersion.toInteger())
		options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation" << "-Xmaxerrs" << "10000" << "-Xdiags:verbose"
		options.incremental = true
	}
	tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
		kotlinOptions.jvmTarget = theJavaVersion
		compilerOptions.freeCompilerArgs.addAll("-java-parameters", "-Werror")
	}

	repositories {
		mavenCentral()
	}
}

dependencies {
	api platform(libs.kotlin.bom)
	api platform(libs.spring.boot.bom)
	kapt platform(libs.spring.boot.bom)
	api platform(libs.sentry.bom)

	api "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
	api "org.jetbrains.kotlin:kotlin-reflect"
	api "org.jetbrains.kotlinx:kotlinx-coroutines-core"
	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8"
	api "org.springframework.boot:spring-boot-starter"
	api "org.springframework.boot:spring-boot-starter-web"
	api "io.micrometer:micrometer-registry-prometheus"
	api "com.fasterxml.jackson.module:jackson-module-kotlin"
	implementation "io.sentry:sentry-kotlin-extensions"
	implementation libs.saltycoffee
	implementation "com.github.ben-manes.caffeine:caffeine"

	kapt "org.springframework.boot:spring-boot-configuration-processor"
}

dependencyLocking {
	lockAllConfigurations()
}

// ./gradlew resolveAndLockAll --write-locks
tasks.register("resolveAndLockAll") {
	doFirst {
		assert gradle.startParameter.writeDependencyLocks
	}
	doLast {
		configurations.configureEach {
			resolutionStrategy {
				componentSelection properReleasesOnly()
			}
		}
		configurations
				.findAll { it.canBeResolved }
				.each { it.resolve() }
	}
}

tasks.named("dependencyUpdates").configure {
	resolutionStrategy {
		componentSelection properReleasesOnly()
	}
	checkConstraints = true
	checkBuildEnvironmentConstraints = true
	gradleReleaseChannel = "current"
}


static def properReleasesOnly() {
	return { rules ->
		rules.all { ComponentSelection selection ->
			if (isNonStable(selection.candidate.version) && (selection.hasProperty("currentVersion") && !isNonStable(selection.currentVersion))) {
				reject("Release candidate")
			}
		}
	}
}

static def isNonStable(String version) {
	def stableKeyword = ["RELEASE", "FINAL", "GA"].any { it -> version.toUpperCase().contains(it) }
	def regex = /^[0-9,.v-]+(-r)?$/
	return !stableKeyword && !(version ==~ regex)
}


// See https://github.com/gradle/gradle/issues/8881#issuecomment-593227192
tasks.register("codeCoverageReport", JacocoReport) {
	dependsOn(test, ":example:test")
	// Gather execution data from all subprojects
	executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")
	// Add all relevant sourcesets from the subprojects
	subprojects.each {
		sourceSets it.sourceSets.main
	}
	reports {
		xml.required.set(true)
		html.required.set(true)
		csv.required.set(false)
	}
}

tasks.withType(org.sonarqube.gradle.SonarTask).configureEach {
	dependsOn codeCoverageReport
}
sonarqube {
	properties {
		property "sonar.projectKey", "dev.capybaralabs.shipa"
		property "sonar.coverage.jacoco.xmlReportPaths", "${rootDir}/build/reports/jacoco/codeCoverageReport/codeCoverageReport.xml"
		property "sonar.coverage.exclusions", "example/**/*"
	}
}


publishing {
	publications {
		create("main", MavenPublication) {
			from(components.kotlin)
		}
	}
}

jar {
	manifest {
		attributes(
				'Implementation-Title': "CapybaraLabs Shipa",
				'Implementation-Version': "$project.version",
		)
	}
}