build.gradle

//-*- mode: groovy -*-

buildscript {
	repositories {
		mavenCentral()
	}
}

plugins {
	id 'application'
	id 'jacoco'
	id 'java'

	id 'com.diffplug.spotless' version '6.23.3'
	id 'com.gradleup.shadow' version '8.3.0'
	id 'net.nemerosa.versioning' version '3.1.0'
	id 'org.ajoberstar.grgit' version '5.2.2'
	id 'org.panteleyev.jpackageplugin' version '1.6.0'
	id "com.github.ben-manes.versions" version "0.51.0" // enables ./gradlew dependencyUpdates for outdated
}

sourceSets {
	main {
		java {
			srcDirs = ['src', 'lib']
			destinationDirectory.set(file('build/main'))
		}
		resources {
			srcDirs = ['src', 'lib']
			excludes = ['**/*.java', '**/*.jar']
		}
	}

	lib {
		java {
			srcDirs = ['lib']
			destinationDirectory.set(file('build/lib'))
		}
	}

	test {
		java {
			srcDirs = ['test']
			destinationDirectory.set(file('build/test'))
		}
		resources {
			srcDirs = ['test/resources']
		}
	}
}

repositories {
	// Use Maven Central for resolving dependencies.
	mavenCentral()
}

dependencies {
	// Use JUnit Jupiter for running JUnit5 tests.
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.11.0'
	testRuntimeOnly 'org.junit.jupiter:junit-jupiter:5.11.0'

	testImplementation 'org.hamcrest:hamcrest:3.0'
	testImplementation 'com.spotify:hamcrest-optional:1.3.2'
	testImplementation 'org.junit.jupiter:junit-jupiter-api:5.11.0'
	testImplementation 'org.junit.jupiter:junit-jupiter-params:5.11.0'
	testImplementation 'org.mockito:mockito-core:5.13.0'
	testImplementation('org.eclipse.xtext:org.eclipse.xtext.xbase.lib:2.36.0') {
		because 'assertion errors including Location/Range/Position need it'
	}
	testImplementation 'org.junit-pioneer:junit-pioneer:2.2.0'

	implementation 'com.formdev:flatlaf:1.6.5'
	implementation 'com.formdev:flatlaf-intellij-themes:1.6.5'
	implementation 'com.formdev:flatlaf-swingx:1.6.5'
	// Optional runtime deps for svnkit
	runtimeOnly 'com.trilead:trilead-ssh2:1.0.0-build222'
	runtimeOnly 'net.java.dev.jna:jna:5.14.0'
	runtimeOnly 'net.java.dev.jna:jna-platform:5.14.0'

	libImplementation 'org.swinglabs:swingx:1.0'

	implementation files('build/lib') {
		builtBy 'compileLibJava'
	}

	implementation 'net.sourceforge.htmlcleaner:htmlcleaner:2.29'
	implementation('org.eclipse.lsp4j:org.eclipse.lsp4j:0.23.1') {
		exclude group: 'org.eclipse.xtend', module: 'org.eclipse.xtend.lib'
	}
	implementation 'org.slf4j:slf4j-nop:2.0.16'
	implementation 'org.fusesource.jansi:jansi:2.4.1'
	implementation 'com.alibaba.fastjson2:fastjson2:2.0.53'
	implementation 'org.mozilla:rhino:1.7.15'
	implementation 'org.swinglabs:swingx:1.0'
	implementation 'org.tmatesoft.svnkit:svnkit:1.10.11'
	implementation 'com.jgoodies:jgoodies-binding:2.13.0'
	implementation 'org.eclipse.jgit:org.eclipse.jgit:6.10.0.202406032230-r'
	implementation 'org.eclipse.jgit:org.eclipse.jgit.ssh.apache:6.10.0.202406032230-r'
}

application {
	// Define the main class for the application.
	mainClass = 'net.sourceforge.kolmafia.KoLmafia'
}

spotless {
	format 'misc', {
		target '.gitignore'

		trimTrailingWhitespace()
		indentWithSpaces(2)
		endWithNewline()
	}

	freshmark {
		target '*.md'
	}

	groovyGradle {
		greclipse()
	}
	java {
		target 'src/**/*.java', 'test/**/*.java'
		googleJavaFormat()
	}
}

task cleanDist(type: Delete) {
	onlyIf {
		file('dist').exists()
	}
	inputs.dir('dist')
	outputs.upToDateWhen { true }
	doLast {
		file('dist').eachFile(groovy.io.FileType.FILES) { File file ->
			if (file.name.startsWith('KoLmafia-') && file.name.endsWith('.jar')) {
				delete file
			}
		}
	}
}

task pruneDist(type: Delete) {
	onlyIf {
		file('dist').exists()
	}
	inputs.dir('dist')
	outputs.upToDateWhen { true }
	doLast {
		file('dist').eachFile(groovy.io.FileType.FILES) { File file ->
			if (file.name.startsWith('KoLmafia-') && file.name.endsWith('.jar')) {
				if (!file.name.contains(project.getVersion().toString()) || (isDirty() != file.name.endsWith('-M.jar'))) {
					delete file
				}
			}
		}
	}
}

test {
	useJUnitPlatform()
	systemProperty 'line.separator', '\n'
	systemProperty 'junit.jupiter.extensions.autodetection.enabled', true
	systemProperty 'useCWDasROOT', true
	systemProperty 'file.encoding', 'UTF-8'
	workingDir 'test/root'

	testLogging.showStandardStreams = true

	reports {
		html.required = true
		junitXml.required = true
	}
}

jacocoTestReport {
	reports {
		xml.required = true
	}
}

jar {
	manifest {
		attributes(
				'Main-Class'      : 'net.sourceforge.kolmafia.KoLmafia',
				'Build-Revision'  : new Object() {
					String toString() {
						project.getVersion()
					}
				},
				'Build-Branch'    : versioning.info.branchId,
				'Build-Build'     : versioning.info.build,
				'Build-Dirty'     : isDirty(),
				'Build-Jdk'       : "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})",
				'Build-OS'        : "${System.properties['os.name']} ${System.properties['os.arch']} ${System.properties['os.version']}"
				)
	}

	from {
		configurations.runtimeClasspath.collect {
			it.isDirectory() ? it : zipTree(it)
		}
	} {
		exclude 'META-INF/*.RSA', 'META-INF/*.SF', 'META-INF/*.DSA'
	}
	duplicatesStrategy = 'exclude'
	destinationDirectory = file('dist/')
	archiveBaseName.set('KoLmafia')
	archiveClassifier.set("${isDirty() ? 'M' : ''}")
}

shadowJar {
	mustRunAfter cleanDist
	duplicatesStrategy = 'exclude'
	destinationDirectory = file('dist/')
	archiveClassifier.set("${isDirty() ? 'M' : ''}")
}

task getRevision() {
	onlyIf {
		file('.git').exists()
	}
	def commit = findProperty('commit') ?: 'HEAD'
	inputs.dir('.git')
	inputs.property('commit', commit)
	outputs.files file('build/revision.txt')

	doLast {
		def revision = grgit.log(includes:[commit]).size() - localCommits(commit)
		logger.info('Commit: {} Revision: {}', commit, revision)
		file('build/revision.txt').text = revision.toString().trim()
		// Update the version to the new revision
		project.setVersion(revision.toString().trim())
		def revString = isDirty() ? project.getVersion() +'-M': project.getVersion()
		println '\nRevision: ' + revString
	}
}

task gitUpdate() {
	doLast {
		def remote = grgit.branch.current().trackingBranch.getName()
		def latestHead = grgit.resolve.toCommit(remote)
		grgit.fetch {
			remote = remote
		}
		if (grgit.resolve.toCommit(remote) == latestHead) {
			println 'Already up-to-date, nothing to do.'
			return
		}
		def dirty = isDirty()
		if (dirty) {
			// This pollutes the reflog, but there's no stash functionality in
			// grgit...
			grgit.commit {
				message = 'temporary stash commit'
				all = true
			}
		}
		grgit.pull {
			rebase = true
		}
		if (dirty) {
			grgit.reset {
				mode = 'mixed'
				commit = 'HEAD^'
			}
		}
	}
}

java {
	sourceCompatibility = JavaVersion.toVersion(javaSourceCompatibility)
	targetCompatibility = JavaVersion.toVersion(javaTargetCompatibility)
}

tasks.withType(JavaCompile) {
	options.encoding = 'UTF-8'
}

tasks.withType(Test) {
	// Mockito requires dynamic loading for mock creation.
	jvmArgs("-XX:+EnableDynamicAgentLoading")
}

task cleanJpackage(type: Delete) {
	onlyIf {
		file('build/releases').exists()
	}
	delete 'build/releases'
}

gradle.taskGraph.whenReady { graph ->
	if (graph.hasTask(":tsDefs") || graph.hasTask(":test")) {
		compileJava.options.compilerArgs += "-parameters"
	}
}

task tsDefs(type: JavaExec) {
	classpath = sourceSets.main.runtimeClasspath
	mainClass = "net.sourceforge.kolmafia.textui.TypescriptDefinition"
	doFirst {
		args lastRevision()
	}
}

tsDefs.dependsOn getRevision

tasks.jpackage {
	dependsOn shadowJar, cleanJpackage
	input = 'dist'
	destination = 'build/releases'
	mainClass = 'net.sourceforge.kolmafia.KoLmafia'
	appName = 'KoLmafia'
	appVersion = new Date().format('yy.MM')
	linux {
		icon = 'util/linux/KoLmafia.ico'
	}
	mac {
		type = 'dmg'
		icon = 'util/macosx/limeglass.icns'
	}
	windows {
		type = 'exe'
		icon = 'util/windows/KoLmafia.ico'
		winShortcut = true
		winPerUserInstall = true
		javaOptions = ["-DuseCWDasROOT=true"]
	}
	doFirst {
		mainJar = tasks.shadowJar.archiveFileName.get()
		appVersion += '.' + version + "${isDirty() ? 'M' : ''}"
		println 'Packaging app ' + appName + '.' + appVersion + '...'
		if (System.properties['os.name'] != 'Linux') {
			return
		}
		def hasDeb = exec {
			ignoreExitValue = true
			errorOutput = OutputStream.nullOutputStream()
			executable 'bash'
			args '-c', 'which dpkg-deb'
		}
		def hasRpm = exec {
			ignoreExitValue = true
			errorOutput = OutputStream.nullOutputStream()
			executable 'bash'
			args '-c', 'which rpmbuild'
		}
		if (hasDeb.getExitValue() == 0) {
			println 'Targeting deb for jpackage...'
			linux { type = 'deb' }
		} else if (hasRpm.getExitValue() == 0) {
			println 'Targeting rpm for jpackage...'
			linux { type = 'rpm' }
		} else {
			println 'Bundling all files for jpackage.'
			linux { type = 'app-image' }
		}
	}
}

clean.dependsOn cleanDist
pruneDist.dependsOn getRevision

// Note that pruneDist relies on getRevision.
jar.dependsOn pruneDist
shadowJar.dependsOn pruneDist

startShadowScripts.dependsOn jar
startScripts.dependsOn jar

distTar.dependsOn shadowJar
distZip.dependsOn shadowJar
startScripts.dependsOn shadowJar

jacocoTestReport.dependsOn test

def isDirty() {
	return versioning.info.dirty || localCommits(findProperty('commit') ?: 'HEAD') > 0
}

def localCommits(commit) {
	return grgit.log(includes:[commit], excludes:['origin/main']).size()
}

def lastRevision() {
	def revisionFile = file('build/revision.txt')
	return revisionFile.exists() ? revisionFile.text.trim() : '0'
}

// Set version from last build/revision.txt if up-to-date
version = lastRevision()