build.gradle

//file:noinspection GroovyAssignabilityCheck
//file:noinspection GrUnresolvedAccess
import com.diffplug.spotless.extra.wtp.EclipseWtpFormatterStep
import com.github.spotbugs.snom.Confidence
import com.github.spotbugs.snom.Effort
import com.github.spotbugs.snom.SpotBugsTask
import java.util.stream.Collectors
import org.ajoberstar.grgit.Grgit
import org.gradle.nativeplatform.platform.internal.Architectures
import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

plugins {
	id 'application'
	id 'com.benjaminsproule.license-report' version '0.16.2'
	id 'com.diffplug.spotless' version '6.25.0'
	id 'com.github.spotbugs' version '6.0.27'
	id 'net.ltgt.errorprone' version '4.1.0'
	id 'org.ajoberstar.grgit' version '5.3.0'
	id 'org.gradlex.extra-java-module-info' version '1.9'
}

def git = Grgit.open(dir: projectDir)
version = "${git.describe(longDescr: true).replaceFirst('-', '.').replaceFirst('-g', '-')}${((!git.status().isClean()) ? '.dirty' : '')}"

base {
	archivesName = application.applicationName.toLowerCase()
}

application {
	mainModule = 'de.bwravencl.controllerbuddy'
	mainClass = 'de.bwravencl.controllerbuddy.gui.Main'
}

ext {
	javaLanguageVersion = JavaLanguageVersion.of(23)

	def launcher = javaToolchains.launcherFor {
		languageVersion.set(javaLanguageVersion)
	}
	javaHome = launcher.map { it.metadata.installationPath }

	os = DefaultNativePlatform.currentOperatingSystem

	moduleInfoFile = 'src/main/java/module-info.java'
	constantsFile = 'src/main/java/de/bwravencl/controllerbuddy/constants/Constants.java'

	resourcesDir = 'src/main/resources'
	tmpDir = layout.buildDirectory.dir 'tmp'
	runtimeDir = tmpDir.map { it.dir 'runtime' }

	xmsJvmArg = '-Xms128m'

	linuxAddOpensValue = "java.desktop/sun.awt.X11=${project.application.mainModule.get()}"
	linuxJvmArgs = [
		"--add-opens=$linuxAddOpensValue"
	]

	gamecontrollerdbFile = "$resourcesDir/gamecontrollerdb.txt"

	arch = DefaultNativePlatform.currentArchitecture
	distAppendix = "${os.toFamilyName()}-$arch.name"

	openVrSupport = false
}

java {
	toolchain {
		languageVersion = javaLanguageVersion
		vendor = JvmVendorSpec.AZUL
	}
}

repositories {
	mavenCentral()
}

tasks.register('cleanModuleInfo') {
	description = "Removes the \'$moduleInfoFile\' source file"
	doLast { delete moduleInfoFile }
}

tasks.register('cleanConstants') {
	description = "Removes the \'$constantsFile\' source file"
	doLast { delete constantsFile }
}

tasks.register('cleanGameControllerDB') {
	description = "Removes the \'gamecontrollerdb.txt\' file from the \'$resourcesDir\' directory."
	doLast { delete gamecontrollerdbFile }
}

clean.dependsOn cleanModuleInfo, cleanConstants, cleanGameControllerDB

dependencies {
	errorprone('com.google.errorprone:error_prone_core:2.36.0')

	def dbusJavaVersion = '5.1.0'
	def jnaVersion = '5.16.0'
	def lwjglVersion = '3.3.5'

	def lwjglOs
	if (os.windows) {
		lwjglOs = "windows"
		openVrSupport = true
	} else if (os.macOsX)
		lwjglOs = 'macos'
	else if (os.linux) {
		lwjglOs = 'linux'
	} else
		throw new GradleException("Unsupported operating system $os.displayName")

	def lwjglArch
	switch (arch.name) {
		case { Architectures.X86.isAlias(it) && os.windows }:
			lwjglArch = 'x86'
			break
		case { Architectures.X86_64.isAlias(it) }:
			lwjglArch = ''
			break
		case { Architectures.ARM_V7.isAlias(it) && os.linux }:
			lwjglArch = 'arm32'
			openVrSupport = false
			break
		case { Architectures.AARCH64.isAlias(it) }:
			lwjglArch = 'arm64'
			break
		default:
			throw new GradleException("Unsupported system architecture $arch.displayName")
	}

	def lwjglPlatform = "${lwjglOs}${lwjglArch.isEmpty() ? '' : '-'}${lwjglArch}"

	implementation 'commons-cli:commons-cli:1.9.0'
	implementation 'com.formdev:flatlaf:3.5.4'
	implementation("com.github.hypfvieh:dbus-java-core:$dbusJavaVersion") { exclude group: 'org.slf4j', module: 'slf4j-api' }
	implementation("com.github.hypfvieh:dbus-java-transport-native-unixsocket:$dbusJavaVersion") { exclude group: 'org.slf4j', module: 'slf4j-api' }
	implementation('org.hid4java:hid4java:0.8.0') { exclude module: 'jna' }
	implementation 'com.xenoamess:JXInput:1.0.1'
	implementation 'com.google.code.gson:gson:2.11.0'
	implementation 'io.github.classgraph:classgraph:4.8.179'
	implementation "net.java.dev.jna:jna-jpms:$jnaVersion"
	implementation "net.java.dev.jna:jna-platform-jpms:$jnaVersion"
	implementation('org.apache.xmlgraphics:batik-swing:1.18') { exclude group: 'xml-apis', module: 'xml-apis' }
	implementation "org.lwjgl:lwjgl:$lwjglVersion"
	implementation "org.lwjgl:lwjgl-glfw:$lwjglVersion"
	implementation "org.lwjgl:lwjgl-glfw:$lwjglVersion:natives-$lwjglPlatform"
	implementation "org.lwjgl:lwjgl-opengl:$lwjglVersion"
	implementation "org.lwjgl:lwjgl-openvr:$lwjglVersion"
	implementation "org.lwjgl:lwjgl:$lwjglVersion:natives-$lwjglPlatform"
	implementation 'org.slf4j:slf4j-jdk14:2.0.16'
	implementation('uk.co.bithatch:linuxio4j:2.1') {
		exclude module: 'jna'
		exclude module: 'jna-platform'
	}
	if (openVrSupport) {
		implementation "org.lwjgl:lwjgl-opengl:$lwjglVersion:natives-$lwjglPlatform"
		implementation "org.lwjgl:lwjgl-openvr:$lwjglVersion:natives-$lwjglPlatform"
	}
}

extraJavaModuleInfo {
	deriveAutomaticModuleNamesFromFileNames = true
	failOnMissingModuleInfo = false
}

tasks.register('generateModuleInfo') {
	description = "Generates the \'$moduleInfoFile\' source file"
	doLast {
		new File(moduleInfoFile).write """\
			@SuppressWarnings({"requires-automatic", "Java9RedundantRequiresStatement"})
			module de.bwravencl.controllerbuddy {
			    exports de.bwravencl.controllerbuddy.gui;

			    opens de.bwravencl.controllerbuddy.input to
				        com.google.gson;
			    opens de.bwravencl.controllerbuddy.input.action to
				        com.google.gson;
			    opens de.bwravencl.controllerbuddy.input.driver to
				        com.sun.jna;

			    requires com.google.gson;
			    requires com.formdev.flatlaf;
			    requires com.sun.jna;
			    requires com.sun.jna.platform;
			    requires hid4java;
			    requires io.github.classgraph;
			    requires java.logging;
			    requires java.prefs;
			    requires jdk.xml.dom;
			    requires JXInput;
			    requires org.apache.commons.cli;
			    requires org.apache.xmlgraphics.batik.anim;
			    requires org.apache.xmlgraphics.batik.brdige;
			    requires org.apache.xmlgraphics.batik.constants;
			    requires org.apache.xmlgraphics.batik.dom;
			    requires org.apache.xmlgraphics.batik.util;
			    requires org.apache.xmlgraphics.batik.swing;
			    requires org.freedesktop.dbus;
			    requires org.lwjgl;
			    requires org.lwjgl.natives;
			    requires org.lwjgl.glfw;
			    requires org.lwjgl.glfw.natives;
			    requires org.lwjgl.opengl;
			${openVrSupport ? '    requires org.lwjgl.opengl.natives;' : ''}
			    requires org.lwjgl.openvr;
			${openVrSupport ? '    requires org.lwjgl.openvr.natives;' : ''}
			    requires uk.co.bithatch.linuxio;
			    requires xml.apis.ext;
			}
			""".stripIndent()
	}
}

spotbugs {
	baselineFile = file('spotbugs-baseline.xml')
	effort = Effort.valueOf('MAX')
	extraArgs = ['-maxRank', '20']
	onlyAnalyze = ['de.bwravencl.-']
	reportLevel = Confidence.valueOf('LOW')
}

tasks.withType(SpotBugsTask).configureEach {
	reports {
		html { required.set true }
		xml { required.set true }
	}
}

spotless {
	encoding 'UTF-8'
	java {
		target 'src/main/java/de/bwravencl/**/*.java'
		targetExclude moduleInfoFile, constantsFile
		eclipse('4.33').configFile 'spotless.eclipseformat.xml'
		formatAnnotations()
		//noinspection GroovyAccessibility
		cleanthat().sourceCompatibility(project.sourceCompatibility.toString()).addMutators([
			'SafeButNotConsensual',
			'SafeButControversial'
		])
		importOrderFile 'spotless.importorder'
		removeUnusedImports()
		licenseHeader '''\
			/* Copyright (C) $YEAR  Matteo Hausner
			 *
			 * This program is free software: you can redistribute it and/or modify
			 * it under the terms of the GNU General Public License as published by
			 * the Free Software Foundation, either version 3 of the License, or
			 * (at your option) any later version.
			 *
			 * This program is distributed in the hope that it will be useful,
			 * but WITHOUT ANY WARRANTY; without even the implied warranty of
			 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
			 * GNU General Public License for more details.
			 *
			 * You should have received a copy of the GNU General Public License
			 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
			 */

			'''.stripIndent()
	}
	groovyGradle {
		target '*.gradle'
		greclipse()
		importOrder()
	}
	format 'xml', {
		target '*.svg'
		eclipseWtp EclipseWtpFormatterStep.XML
	}
	format 'newlineAndTrailingWhitespace', {
		target '.github/**/*.yml', "$resourcesDir/**/*.properties", "$resourcesDir/**/*.svg".toString()
		endWithNewline()
		trimTrailingWhitespace()
	}
	format 'onlyNewline', {
		target 'LICENSE', '*.gitignore', '*.md', '*.txt', "$resourcesDir/**/*.txt".toString()
		targetExclude gamecontrollerdbFile
		endWithNewline()
	}
}

downloadLicenses {
	def mit = license('MIT', 'https://opensource.org/license/mit/')

	includeProjectDependencies = true
	ignoreFatalParseErrors = false
	licenses = ['com.github.strikerx3:jxinput:1.0.0': mit]
	// @formatter:off
	aliases = [(license('Apache-2.0', 'https://www.apache.org/licenses/LICENSE-2.0')): [
			'Apache-2.0',
			'Apache License, Version 2.0',
			'The Apache License, Version 2.0',
			'The Apache Software License, Version 2.0'
		], (mit): [
			'MIT',
			'MIT License',
			'The MIT License (MIT)'
		]]
	// @formatter:on
	dependencyConfiguration = 'runtimeClasspath'

	report {
		reportByLicenseType = false
		json.enabled = false
		xml.enabled = false
	}
}

tasks.register('generateConstants') {
	dependsOn 'downloadLicenses'
	description = "Generates the \'$constantsFile\' source file"
	doLast {
		def dependencyLicenseHtml = layout.buildDirectory.file('reports/license/dependency-license.html').get().getAsFile().text.replaceFirst('<head>[\\s\\S]*</head>', '').replaceFirst('<style>[\\s\\S]*</style>', '').replaceFirst('<h3>Jar</h3>', '<h3>File</h3>').replaceAll('class\\s*=\\s*\'-?[_a-zA-Z]+[_a-zA-Z0-9-]*\'', '').replaceAll('>\\s*<', '><')
		def projectLicenseHtml = layout.projectDirectory.file('LICENSE').getAsFile().readLines().collect({ it.trim().codePoints().mapToObj({ it > 127 || '"\'<>&'.indexOf(it) != -1 ? "&#$it;" : new String(Character.toChars(it)) }).collect(Collectors.joining()) }).join '<br>'

		def licensesHtmlStringBuilder = new StringBuilder(dependencyLicenseHtml)
		def bodyTag = '<body>'
		licensesHtmlStringBuilder.insert(licensesHtmlStringBuilder.indexOf(bodyTag) + bodyTag.length(), "<center><h1>$application.applicationName License:</h1><p>$projectLicenseHtml</p><br><h1>Third-Party Licenses:</h1>")
		licensesHtmlStringBuilder.insert(licensesHtmlStringBuilder.lastIndexOf('</table>'), '<tr><td>SDL_GameControllerDB</td><td>gamecontrollerdb.txt</td><td>zlib License</td><td><a href=\'https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/master/LICENSE\'>Show license agreement</a></td></tr>')
		licensesHtmlStringBuilder.insert(licensesHtmlStringBuilder.lastIndexOf('</body>'), '</center>')

		def file = new File(constantsFile)
		file.getParentFile().mkdirs()
		file.write("""\
			package de.bwravencl.controllerbuddy.constants;\n
			public class Constants {

				public static final String APPLICATION_NAME = "$application.applicationName";

				public static final String VERSION = "$project.version";

				public static final String LICENSES_HTML;

				static {
					LICENSES_HTML = "${licensesHtmlStringBuilder.toString()}";
				}
			}
			""".stripIndent())
	}
}

tasks.register('copyGameControllerDB', Copy) {
	description = "Places a copy of the \'gamecontrollerdb.txt\' file from the SDL_GameControllerDB Git Submodule folder into the \'$resourcesDir' directory."
	from 'SDL_GameControllerDB/gamecontrollerdb.txt'
	into resourcesDir
}

tasks.processResources.dependsOn copyGameControllerDB
tasks.spotlessGroovyGradleCheck.dependsOn copyGameControllerDB
tasks.spotlessNewlineAndTrailingWhitespace.dependsOn copyGameControllerDB
tasks.spotlessOnlyNewline.dependsOn copyGameControllerDB
tasks.spotlessXml.dependsOn copyGameControllerDB

tasks.withType(JavaCompile).configureEach {
	dependsOn generateModuleInfo, generateConstants
	source generateConstants.outputs.files, sourceSets.main.java
	options.encoding = 'UTF-8'
	gradle.taskGraph.whenReady {
		if (!it.hasTask(run)) {
			options.compilerArgs << '-Xlint:all' << '-Werror'
			options.deprecation = true
			options.errorprone.error 'MissingBraces'
		}
	}
}

run {
	jvmArgs += xmsJvmArg

	if (os.linux)
		jvmArgs += linuxJvmArgs
}

tasks.register('jlink', Exec) {
	description = 'Executes the jlink command to create a customized minimal Java runtime inside the build directory. Also removes any preexisting runtime in the same directory.'
	dependsOn check
	group
	doFirst { delete runtimeDir }
	commandLine "${javaHome.get()}/bin/jlink", '--output', runtimeDir.get(), '--strip-debug', '--no-header-files', '--no-man-pages', '--strip-native-commands', '--add-modules', 'java.desktop,java.management,jdk.unsupported,java.logging,jdk.accessibility,jdk.net,jdk.security.auth,jdk.xml.dom'
}

tasks.register('cleanLibsDirectory') {
	description = "Removes the \'${base.libsDirectory.get()}\' directory."
	doLast { delete base.libsDirectory }
}

jar.mustRunAfter cleanLibsDirectory

tasks.register('copyLibs', Copy) {
	description = 'Copies all jar files into a directory called \'libs\' inside the build directory.'
	dependsOn cleanLibsDirectory, jar
	from configurations.runtimeClasspath
	into base.libsDirectory
}

tasks.register('customizeLoggingProperties') {
	description = 'Alters the default "logging.properties" configuration file of the Java runtime to include a FileHandler that logs to a logfile in the system\'s TEMP directory using SimpleFormatter with custom formatting.'
	dependsOn jlink
	doLast {
		ant.propertyfile(file: "${runtimeDir.get()}/conf/logging.properties") {
			entry(key: 'handlers', value: 'java.util.logging.FileHandler, java.util.logging.ConsoleHandler')
			entry(key: 'java.util.logging.FileHandler.pattern', value: "%t/${project.name}.log")
			entry(key: 'java.util.logging.FileHandler.formatter', value: 'java.util.logging.SimpleFormatter')
			entry(key: 'java.util.logging.SimpleFormatter.format', value: '[%1$tY-%1$tm-%1$td %1$tk:%1$tM:%1$tS:%1$tL] %3$s: %5$s%6$s%n')
		}
	}
}

tasks.register('jpackage', Exec) {
	description = 'Executes the jpackage command to create a standalone application image packaged with a custom minimal Java runtime.'
	dependsOn copyLibs, customizeLoggingProperties
	doFirst { delete tmpDir.get().file(project.name) }
	def commandLineParts = [
		"${javaHome.get()}/bin/jpackage",
		'--dest',
		tmpDir.get(),
		'--type',
		'app-image',
		'--name',
		project.name,
		'--runtime-image',
		runtimeDir.get(),
		'--module-path',
		base.libsDirectory.get(),
		'--module',
		"${project.application.mainModule.get()}/${project.application.mainClass.get()}",
		'--app-version',
		version.substring(0, version.indexOf('-')),
		'--icon',
		"$projectDir/icon.${os.windows ? 'ico' : 'png'}",
		'--copyright',
		"Copyright ${new Date().format 'yyyy'} Matteo Hausner",
		'--vendor',
		'Matteo Hausner',
		'--verbose',
		'--java-options',
		xmsJvmArg
	]
	if (os.linux)
		linuxJvmArgs.each { commandLineParts.addAll(['--java-options', it]) }
	commandLine commandLineParts
}

startScripts.enabled = false

tasks.replace('distTar', Tar).configure {
	dependsOn jpackage
	from tmpDir
	include "$project.name${os.macOsX ? '.app' : ''}/**"
	archiveAppendix = distAppendix
	compression Compression.GZIP
}

tasks.replace('distZip', Zip).configure {
	dependsOn jpackage
	from tmpDir
	include "$project.name${os.macOsX ? '.app' : ''}/**"
	archiveAppendix = distAppendix
}

tasks.replace('installDist', Sync).configure {
	dependsOn jpackage
	from tmpDir
	into layout.buildDirectory.dir('install')
	include "$project.name${os.macOsX ? '.app' : ''}/**"
}