build.gradle

/*
 * Copyright 2025 Dynatrace LLC
 *
 * 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
 *
 * http://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.
 */
import com.diffplug.gradle.spotless.JavaExtension

plugins {
	id "java-library"
	id "jacoco"
	id "me.champeau.jmh" version "0.7.3"
	id "org.sonarqube" version "6.1.0.5360"
	id "com.diffplug.spotless" version "7.0.2"
	id "maven-publish"
	id "signing"
	id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
	id "net.ltgt.errorprone" version "4.1.0"
	id "org.revapi.revapi-gradle-plugin" version "1.8.0"
}

repositories {
	mavenCentral()
	gradlePluginPortal()
}

dependencies {
	testImplementation group: "org.junit.jupiter", name: "junit-jupiter-api", version: "5.12.1"
	testRuntimeOnly group: "org.junit.jupiter", name: "junit-jupiter-engine", version: "5.12.1"
	testImplementation group: "org.junit.jupiter", name: "junit-jupiter-params", version: "5.12.1"
	testRuntimeOnly group: 'org.junit.platform', name: 'junit-platform-launcher', version: "1.12.1"
	testImplementation group: "org.assertj", name: "assertj-core", version: "3.27.3"
	testImplementation group: "org.hipparchus", name: "hipparchus-stat", version: "4.0.1"
	testImplementation group: "org.hipparchus", name: "hipparchus-optim", version: "4.0.1"
	testImplementation group: "com.google.guava", name: "guava", version: "33.4.6-jre"
	testImplementation group: "commons-codec", name: "commons-codec", version: "1.18.0"
	testImplementation group: "net.openhft", name: "zero-allocation-hashing", version: "0.15"
	testImplementation group: "com.appmattus.crypto", name: "cryptohash", version: "1.0.2"
	testImplementation group: "org.greenrobot", name: "essentials", version: "3.1.0"
	testImplementation group: "com.sangupta", name: "murmur", version: "1.0.0"
	errorprone group:"com.google.errorprone",name:"error_prone_core", version: "2.37.0"
}

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(21)
	}
	withSourcesJar()
	withJavadocJar()
}


sourceSets {
	jmh
	main
	test
	java21 {
		java {
			srcDir "src/main/java21"
		}
		dependencies {
			// add Java 21 dependencies here to make them available for Java 21 code
		}
		// include main source code to make it accessible from Java 21
		compileClasspath += sourceSets.main.output
		runtimeClasspath += sourceSets.main.output
	}
	java21Test {
		java {
			srcDir "src/test/java21"
		}
		dependencies {
			// add Java 21 dependencies here to make them available for Java 21 code
		}
		// include test source code to make it accessible from Java 21
		compileClasspath += sourceSets.test.output
		runtimeClasspath += sourceSets.test.output
	}
}

jar {
	dependsOn "compileJava21Java"
	into("META-INF/versions/21") {
		from sourceSets.java21.output
	}
	manifest {
		attributes "Multi-Release": "true"
	}
}

tasks.compileJava {
	options.release.set(11)
}

tasks.compileTestJava {
	options.release.set(11)
}

tasks.compileJava21Java {
	options.release.set(21)
}
tasks.compileJava21TestJava {
	options.release.set(21)
}

tasks.test {
	javaLauncher = javaToolchains.launcherFor {
		languageVersion = JavaLanguageVersion.of(11)
	}
}

tasks.register("java21Test", Test) {
	group = LifecycleBasePlugin.VERIFICATION_GROUP
	javaLauncher = javaToolchains.launcherFor {
		languageVersion = JavaLanguageVersion.of(21)
	}
	// run Java 21 specific and generic tests
	testClassesDirs = sourceSets.java21Test.output + sourceSets.test.output
	classpath = files(jar) + sourceSets.java21Test.runtimeClasspath + sourceSets.test.runtimeClasspath
}

tasks.check {
	dependsOn(java21Test)
}

tasks.withType(Test).configureEach {
	useJUnitPlatform()
	maxHeapSize = "8g"
}

tasks.withType(JavaCompile).configureEach {
	options.compilerArgs << "-Werror"
	options.errorprone.disableWarningsInGeneratedCode = false
	// options.errorprone.enabled = false
}

group = "com.dynatrace.hash4j"
version = "0.20.0"


static def readJavaLicense(licenseName) {
	File licenseFile = new File("licenses/" + licenseName + ".txt")
	def line
	def s = "/*\n"
	licenseFile.withReader { reader ->
		while ((line = reader.readLine()) != null) {
			s += " *"
			if(!line.isEmpty()) {
				s += " "
				s += line
			}
			s += "\n"
		}
	}
	s += " */"
	return s
}

static def readPythonLicense(licenseName) {
	File licenseFile = new File("licenses/" + licenseName + ".txt")
	def line
	def s = "#\n"
	licenseFile.withReader { reader ->
		while ((line = reader.readLine()) != null) {
			s += "#"
			if(!line.isEmpty()) {
				s += " "
				s += line
			}
			s += "\n"
		}
	}
	s += "#"
	return s
}

apply plugin: "groovy"
spotless {
	def googleJavaFormatVersion = "1.25.2"
	def eclipseCdtVersion = "11.6"
	def blackVersion = "24.10.0"
	def greclipseVersion = "4.32"
	def specialLicenseHeaders = [
		new Tuple3("javaImohash", "MIT_IMOHASH", [
			"src/main/java/com/dynatrace/hash4j/file/Imohash1_0_2.java"
		]),
		new Tuple3("javaKomihash", "MIT_KOMIHASH" , [
			"src/main/java/com/dynatrace/hash4j/hashing/Komihash4_3.java",
			"src/main/java/com/dynatrace/hash4j/hashing/Komihash5_0.java",
			"src/main/java/com/dynatrace/hash4j/hashing/AbstractKomihash.java"
		]),
		new Tuple3("javaFarmHash", "MIT_APACHE_2_0_FARMHASH",[
			"src/main/java/com/dynatrace/hash4j/hashing/FarmHashNa.java",
			"src/main/java/com/dynatrace/hash4j/hashing/FarmHashUo.java"
		]),
		new Tuple3("javaPolymurHash", "ZLIB_POLYMURHASH",[
			"src/main/java/com/dynatrace/hash4j/hashing/PolymurHash2_0.java"
		]),
		new Tuple3("javaSplitMix64", "CREATIVE_COMMONS_SPLITMIX64",[
			"src/main/java/com/dynatrace/hash4j/random/SplitMix64V1.java"
		]),
		new Tuple3("javaExponential", "BOOST_EXPONENTIAL_RANDOM_GENERATION",[
			"src/main/java/com/dynatrace/hash4j/random/RandomExponentialUtil.java"
		]),
		new Tuple3("javaConsistentJumpHash", "APACHE_2_0_GUAVA",[
			"src/main/java/com/dynatrace/hash4j/consistent/ConsistentJumpBucketHasher.java"
		]),
		new Tuple3("javaXXH", "APACHE_2_0_XXH",[
			"src/main/java/com/dynatrace/hash4j/hashing/XXH3_64.java",
			"src/main/java/com/dynatrace/hash4j/hashing/XXH3_128.java",
			"src/main/java/com/dynatrace/hash4j/hashing/XXH3Base.java"
		])
	]

	ratchetFrom "origin/main"
	groovy {
		importOrder()
		removeSemicolons()
		greclipse(greclipseVersion)
		licenseHeader readJavaLicense("APACHE_2_0_DYNATRACE")
		target("**/build.gradle")
	}
	python {
		target "python/**/*.py"
		black(blackVersion)
		licenseHeader readPythonLicense("APACHE_2_0_DYNATRACE"), "(import|from)"
	}
	cpp {
		target "reference-implementations/*/*.cpp", "reference-implementations/*/*.hpp", "reference-implementations/*.cpp", "reference-implementations/*.hpp"
		eclipseCdt(eclipseCdtVersion)
		licenseHeader readJavaLicense("APACHE_2_0_DYNATRACE")
	}
	java {
		importOrder()
		removeUnusedImports()
		cleanthat()
		googleJavaFormat(googleJavaFormatVersion)
		formatAnnotations()
		licenseHeader readJavaLicense("APACHE_2_0_DYNATRACE")
		targetExclude specialLicenseHeaders.collect {it.get(2)}.flatten()
	}
	specialLicenseHeaders.forEach {
		def formatName = it.get(0)
		def licenseName = it.get(1)
		def files = it.get(2)
		format formatName, JavaExtension, {
			importOrder()
			removeUnusedImports()
			cleanthat()
			googleJavaFormat(googleJavaFormatVersion)
			formatAnnotations()
			licenseHeader readJavaLicense("APACHE_2_0_DYNATRACE") + "\n\n" + readJavaLicense(licenseName)
			target files
		}
	}
}

sonarqube {
	properties {
		property "sonar.projectKey", "dynatrace-oss_hash4j"
		property "sonar.organization", "dynatrace-oss"
		property "sonar.host.url", "https://sonarcloud.io"
	}
}


jmh {
	fork = 1
	timeUnit = "us"
	failOnError = false
	timeOnIteration = "1s"
	warmupForks = 0
	warmupIterations = 5
	warmupBatchSize = 1
	warmup = "1s"
	iterations = 20
	resultFormat = "JSON"
}

task evaluateBenchmarks(type:Exec) {
	group = "evaluation"
	workingDir = "."
	commandLine "python", "python/benchmark_evaluation.py"
}

task evaluateEstimationErrors(type:Exec) {
	group = "evaluation"
	workingDir = "."
	commandLine "python", "python/estimation_error_evaluation.py"
}

def sketches = ["UltraLogLog", "HyperLogLog"]
def pValues = [
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
	11,
	12,
	13,
	14,
	15,
	16
]
def evaluationTasks = []
for (sketch in sketches) {
	def sketchTasks = []
	for (p in pValues) {
		def sketchTaskName = "simulate" + sketch + "EstimationErrorsP" + String.format( "%02d", p )
		def outputFileName = "test-results/" + sketch.toLowerCase() + "-estimation-error-p" + String.format( "%02d", p )  + ".csv"
		task "${sketchTaskName}"(type: JavaExec) {
			outputs.files outputFileName
			group = "evaluation"
			classpath = sourceSets.test.runtimeClasspath
			mainClass = "com.dynatrace.hash4j.distinctcount." + sketch + "EstimationErrorSimulation"
			args = [p.toString(), outputFileName]
			jvmArgs = ["-Xmx16g"]
		}
		sketchTasks.add(sketchTaskName)
	}
	def evaluationTaskName = "simulate" + sketch + "EstimationErrors"
	task "${evaluationTaskName}" {
		group = "evaluation"
		dependsOn sketchTasks
	}
	evaluationTasks.add(evaluationTaskName)
}
task "simulateEstimationErrors" {
	group = "evaluation"
	dependsOn evaluationTasks
}

tasks.register("checkStatusForBenchmarks") {
	outputs.upToDateWhen { false }
	doLast {
		def status_text = "git status --porcelain".execute().text
		if(status_text?.trim()) {
			throw new GradleException("There are uncommitted changes:\n" + status_text)
		}
	}
}

tasks.register("copyBenchmarkReport", Copy) {
	def proc = "git rev-parse HEAD".execute()
	def revision = proc.text.trim()
	from("build/results/jmh/") {
		include "results.*"
		rename "results", new Date().format("yyyy-MM-dd-HH-mm-ss") + " " + revision
	}
	into "benchmark-results"
}

tasks.register("deleteBenchmarkReport", Delete) {
	delete "build/results/jmh/results.json"
}

tasks.test.finalizedBy jacocoTestReport
tasks.jmh.finalizedBy copyBenchmarkReport
tasks.copyBenchmarkReport.finalizedBy deleteBenchmarkReport
check.dependsOn jacocoTestCoverageVerification
tasks.jmh.dependsOn checkStatusForBenchmarks
tasks.copyBenchmarkReport.dependsOn checkStatusForBenchmarks
tasks.simulateHyperLogLogEstimationErrors.finalizedBy evaluateEstimationErrors
tasks.simulateUltraLogLogEstimationErrors.finalizedBy evaluateEstimationErrors

javadoc {
	failOnError = true
	title = "hash4j " + project.version + " API"
}

jacoco {
	toolVersion = "0.8.11"
}

jacocoTestReport {
	reports {
		xml.required = true
		csv.required = true
	}
}

jacocoTestCoverageVerification {
	violationRules {
		rule {
			limit {
				minimum = 1.0
				counter = "LINE"
			}
			limit {
				minimum = 1.0
				counter = "BRANCH"
			}
		}
	}
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			from components.java
			pom {
				name = "com.dynatrace.hash4j:hash4j"
				description = "hash4j: A Dynatrace hash library for Java"
				url = "https://github.com/dynatrace-oss/hash4j"
				licenses {
					license {
						name = "The Apache License, Version 2.0"
						url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
					}
				}
				developers {
					developer {
						id = "Dynatrace"
						name = "Dynatrace LLC"
						email = "opensource@dynatrace.com"
					}
				}
				scm {
					connection = "scm:git:git://github.com/dynatrace-oss/hash4j.git"
					developerConnection = "scm:git:ssh://github.com/dynatrace-oss/hash4j.git"
					url = "https://github.com/dynatrace-oss/hash4j"
				}
			}
		}
	}
}

signing {
	useInMemoryPgpKeys(System.getenv("GPG_PRIVATE_KEY"), System.getenv("GPG_PASSPHRASE"))
	sign publishing.publications.mavenJava
}

nexusPublishing {
	packageGroup = "com.dynatrace"
	useStaging = true
	repositories {
		sonatype {
			nexusUrl = uri("https://oss.sonatype.org/service/local/")
			snapshotRepositoryUrl = uri("https://oss.sonatype.org/content/repositories/snapshots/")
			username = System.getenv("OSSRH_USERNAME")
			password = System.getenv("OSSRH_PASSWORD")
		}
	}
}

if (file("extra-configuration.gradle").exists()) {
	apply from: "extra-configuration.gradle"
}