build.gradle

/*
 * Copyright (C) 2021 Emerson Pinter - All Rights Reserved
 */

group 'br.com.pinter.tqrespec'
apply plugin: 'application'
apply plugin: 'java'
apply plugin: 'org.sonarqube'

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:3.1.1"
    }
}
apply from: "gradle/patchModulesJar.gradle"

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform

sourceSets {
    main.output.resourcesDir = main.java.classesDirectory.get()
}

OperatingSystem OS = DefaultNativePlatform.currentOperatingSystem
ext.distAppName = 'TQRespec'
version = '0.12.0'
sourceCompatibility = JavaVersion.VERSION_17
ext.moduleName = 'br.com.pinter.tqrespec'
ext.mainPackageName = 'br.com.pinter.tqrespec'
ext.javahome = System.getProperty("java.home")
ext.moduleInfoPresent = false
ext.osArch = System.getProperty("os.arch").toLowerCase()
ext.javafxSdkDir = file(String.format("%s/sdk/javafx-sdk-%s-%s-%s", projectDir, sourceCompatibility, OS.toFamilyName().toLowerCase(), osArch))
ext.javafxSdkBinDir = file("${javafxSdkDir}/bin")
ext.javafxSdkLibDir = file("${javafxSdkDir}/lib")
// jpms ready modules
ext.modulesJars = ["jna-platform-jpms-", "jna-jpms-", "jackson-annotations-", "jackson-core-", "jackson-databind-"]
// toggle patch-jar feature, enable jpms on non-modular jars
ext.patchJars = true
// directory for patched jars
ext.patchjarDir = new File(buildDir, '/patchedjar')
// modules dependencies to be passed to jdeps
ext.patchJarModuleDeps = ["org.apache.commons.lang3": ["java.desktop"],
              "org.apache.commons.text" : ["org.apache.commons.lang3"],
              "com.google.guice"        : ["com.google.common", "aopalliance"],
              "com.google.common"       : ["com.google.errorprone.annotations", "javax.inject", "j2objc.annotations",
                                           "jsr305", "failureaccess"]]

if (file('src/main/java/module-info.java').exists()) {
    ext.moduleInfoPresent = true
}
mainClassName = "br.com.pinter.tqrespec.Main"

if (!file(javafxSdkDir).directory) {
    throw new GradleException(String.format("ERROR: openjfx-sdk for java %s (%s) not found in %s", sourceCompatibility, System.getProperty("os.arch"), javafxSdkDir))
}

if (project.hasProperty('buildVersion')) {
    project.version = project.properties.get("buildVersion")
}
if (osArch == "amd64") {
    ext.appArchiveName = "${distAppName}-${project.version}.zip"
} else {
    ext.appArchiveName = "${distAppName}-${project.version}_${osArch}.zip"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation fileTree(dir: 'libs', include: '*.jar')
    implementation fileTree(dir: javafxSdkLibDir, include: '*.jar')
    implementation 'com.google.inject:guice:5.1.0'
    implementation 'org.apache.commons:commons-lang3:3.12.0'
    implementation 'org.apache.commons:commons-text:1.9'
    implementation 'net.java.dev.jna:jna-platform-jpms:5.11.0'
    implementation 'com.fasterxml.jackson.core:jackson-core:2.13.2'
    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.13.2'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.2.2'


    implementation project(':tqdatabase')

    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
    testImplementation 'org.mockito:mockito-core:4.4.0'
    testImplementation 'org.mockito:mockito-junit-jupiter:4.4.0'
    testImplementation 'com.google.inject:guice:5.1.0'
}

test {
    useJUnitPlatform()

    jvmArgs '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
            '--add-opens', 'java.base/java.util.concurrent=ALL-UNNAMED',
            '--add-opens', 'java.base/java.io=ALL-UNNAMED',
            '--add-opens', 'java.base/java.nio=ALL-UNNAMED',
            '--add-opens', 'java.base/java.nio.file=ALL-UNNAMED',
            '--add-opens', 'java.logging/java.util.logging=ALL-UNNAMED'
}

if (OS.isWindows()) {
    ext.binjlink = javahome + "/bin/jlink.exe"
    ext.binjpackage = javahome + "/bin/jpackage.exe"
} else {
    ext.binjlink = javahome + "/bin/jlink"
    ext.binjpackage = javahome + "/bin/jpackage"
}

jar {
    //noinspection GroovyAssignabilityCheck
    manifest {
        attributes('Class-Path': configurations.runtimeClasspath.collect { it.getName() }.join(' '),
                'Implementation-Title': distAppName,
                'Implementation-Version': project.version,
                'Automatic-Module-Name': moduleName,
                'Main-Class': mainClassName)
    }
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

task copyMetaInf(type: Copy) {
    group = 'tqrespec'
    from fileTree(new File(sourceSets.main.output.resourcesDir, '/META-INF'))
    into sourceSets.main.java.classesDirectory.get().dir('/META-INF')
}

if (moduleInfoPresent) {
    compileJava {
        inputs.property("moduleName", moduleName)
        doFirst {
            options.compilerArgs = [
                    '--module-path', classpath.asPath,
            ]
            classpath = files()
        }
    }

    run {
        inputs.property("moduleName", moduleName)
        doFirst {
            jvmArgs = [
                    '-XX:+UseSerialGC',
                    '-Dguice_bytecode_gen_option=DISABLED',
                    '-XX:MinHeapFreeRatio=10', '-XX:MaxHeapFreeRatio=15',
                    '--module-path', classpath.asPath,
                    '--class-path', classpath.asPath,
                    '--module', moduleName,
            ]
            classpath = files()
        }
    }
} else {
    run {
        doFirst {
            jvmArgs = [
                    '-XX:+UseSerialGC',
                    '-XX:MinHeapFreeRatio=10', '-XX:MaxHeapFreeRatio=15',
                    '--module-path', "${javafxSdkLibDir}",
                    '--add-modules', 'javafx.base,javafx.fxml,javafx.graphics,javafx.controls',
            ]
        }
    }
}

task copyToLib(type: Copy) {
    group = 'tqrespec'
    doFirst {
        mkdir "$buildDir/jardist"
    }
    from(configurations.runtimeClasspath.findAll { !it.getName().toLowerCase().matches("javafx.*\\.jar") }).collect { it.getPath() }

    from jar
    into "$buildDir/jardist"
}

copyToLib.dependsOn(jar)
classes.dependsOn('copyMetaInf')

task copyJarsToModuleDeps(type: Copy) {
    group = 'tqrespec'
    if (patchJars) {
        from project(':tqdatabase').configurations.compileClasspath
        from project.configurations.compileClasspath
        into patchjarDir
    }
}

task patchModulesJar(type: PatchJarModuleTask) {
    group = 'tqrespec'
    dependsOn 'copyJarsToModuleDeps'
    delete = true
    tempPatchDir = new File(buildDir, '/temppatch')
    tempJarDir = patchjarDir
    moduleDeps = patchJarModuleDeps
}

task createDirs {
    doLast {
        mkdir "${buildDir}/appimage-files"
        mkdir "${buildDir}/appimage-modules"
    }
}

task copyAppimageModules(type: Copy) {
    group = 'tqrespec'
    dependsOn jar
    dependsOn 'tqdatabase:jar'
    if (patchJars) {
        dependsOn patchModulesJar
    }

    if (moduleInfoPresent) {
        if (patchJars) {
            from patchjarDir
        }
        from jar
    }

    from configurations.runtimeClasspath.findAll {
        modulesJars.findAll { f -> it.getName().toLowerCase().startsWith(f.toString().toLowerCase()) }
    }.collect()
    from project(':tqdatabase').tasks.jar.outputs.files.collect { it.getPath() }

    into "$buildDir/appimage-modules"
}

task copyAppimageFiles {
    group = 'tqrespec'
    dependsOn jar
    dependsOn 'tqdatabase:jar'
    dependsOn copyAppimageModules

    def excludeJars = new ArrayList<>()

    doFirst {
        excludeJars.addAll(configurations.runtimeClasspath.findAll {
            it.getName().toLowerCase().matches("javafx.*.jar")
                    || it.getName().toLowerCase().matches("tqdatabase.*.jar")
                    || modulesJars.findAll { m -> it.getName().toLowerCase().startsWith(m.toLowerCase()) }
                    || patchjarDir.listFiles().findAll { p -> it.getName().equalsIgnoreCase(p.getName()) }
        }.collect { x -> x.getName() })
    }

    doLast {
        copy {
            if (!moduleInfoPresent) {
                from project(':tqdatabase').tasks.jar.outputs.files.collect { it.getPath() }
                from jar
            }

            from configurations.runtimeClasspath.findAll {
                !excludeJars.contains(it.getName().toLowerCase())
            }.collect()

            into("$buildDir/appimage-files")
        }
    }
}

task jlink(type: Exec) {
    group = 'tqrespec'
    dependsOn createDirs
    dependsOn 'copyToLib'
    dependsOn 'copyAppimageFiles'
    workingDir buildDir

    doFirst {
        def addModulesJlink
        if (moduleInfoPresent) {
            //noinspection GroovyAccessibility
            addModulesJlink = String.join(",",
                    "br.com.pinter.tqdatabase",
                    "${moduleName}",
                    "com.sun.jna", "com.sun.jna.platform",
                    "java.desktop",
                    "javafx.base,javafx.fxml,javafx.graphics,javafx.controls",
                    "java.prefs,java.base,jdk.zipfs,jdk.unsupported,java.logging",
                    "java.net.http,jdk.crypto.cryptoki",
                    "com.fasterxml.jackson.core",
                    "com.fasterxml.jackson.databind",
                    "com.fasterxml.jackson.annotation",
                    String.join(",", patchModulesJar.patchedModules))

            commandLine binjlink,
                    '-J-Djlink.debug=true',
                    '--module-path', "${javafxSdkLibDir}" + File.pathSeparator + "${buildDir}/appimage-modules",
                    '--add-modules', addModulesJlink,
                    '--output', "${buildDir}/jre-image",
                    '--compress', '2',
                    '--no-header-files',
                    '--no-man-pages',
                    '--strip-native-commands'
        } else {
            commandLine binjlink,
                    '--module-path', "${javafxSdkLibDir}" + File.pathSeparator + "${buildDir}/appimage-modules",
                    '--add-modules', ("javafx.base,javafx.fxml,javafx.graphics,javafx.controls,java.prefs,java.base,jdk.zipfs,jdk.unsupported,java.logging,java.net.http,jdk.crypto.cryptoki"),
                    '--output', "${buildDir}/jre-image",
                    '--compress', '2',
                    '--no-header-files',
                    '--no-man-pages',
                    '--strip-native-commands'
        }
    }
}

task archiveAppimage(type: Zip) {
    group = 'tqrespec'
    dependsOn clean
    dependsOn 'appimage'
    doLast {
        println("Creating archive '${appArchiveName}'")
    }
    from "${buildDir}/app-image"
    archiveFileName = appArchiveName
    destinationDirectory = file("$buildDir")
}

task appimage(type: Exec) {
    group = 'tqrespec'
    dependsOn clean
    dependsOn jlink
    workingDir buildDir
    if (moduleInfoPresent) {
        commandLine binjpackage,
                '--type', 'app-image',
                '--verbose',
                '--runtime-image', "${buildDir}/jre-image",
                '--module', "${moduleName}/${mainClassName}",
                '--dest', "${buildDir}/app-image",
                '--name', distAppName,
                '--icon', "${projectDir}/src/main/resources/icon/icon64.ico",
                '--app-version', project.version,
                '--vendor', 'Emerson Pinter',
                '--input', "${buildDir}/appimage-files",
                '--description', 'The respec tool for Titan Quest game',
                '--java-options',
                '-XX:+UseSerialGC ' +
                        '-Dguice_bytecode_gen_option=DISABLED ' +
                        '-XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=15 '
    } else {
        commandLine binjpackage,
                '--type', 'app-image',
                '--verbose',
                '--runtime-image', "${buildDir}/jre-image",
                '--dest', "${buildDir}/app-image",
                '--name', distAppName,
                '--icon', "${projectDir}/src/main/resources/icon/icon64.ico",
                '--app-version', project.version,
                '--vendor', 'Emerson Pinter',
                '--input', "${buildDir}/appimage-files",
                '--description', 'The respec tool for Titan Quest game',
                '--main-jar', jar.outputs.files.collect { it.getName() }.get(0),
                '--main-class', mainClassName,
                '--java-options',
                '-XX:+UseSerialGC ' +
                        '-Dguice_bytecode_gen_option=DISABLED ' +
                        '-XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=15 ' +
                        '--add-opens javafx.base/com.sun.javafx.reflect=ALL-UNNAMED ' +
                        '--add-opens java.base/java.lang=ALL-UNNAMED '
    }
    doLast {
        copy {
            if (OS.isWindows()) {
                from javafxSdkBinDir.listFiles().findAll {
                    it.getName().equalsIgnoreCase("decora_sse.dll") ||
                            it.getName().equalsIgnoreCase("fxplugins.dll") ||
                            it.getName().equalsIgnoreCase("glass.dll") ||
                            it.getName().equalsIgnoreCase("javafx_font.dll") ||
                            it.getName().equalsIgnoreCase("javafx_iio.dll") ||
                            it.getName().equalsIgnoreCase("prism_common.dll") ||
                            it.getName().equalsIgnoreCase("prism_d3d.dll") ||
                            it.getName().equalsIgnoreCase("prism_sw.dll")
                }.collect()
                into "$buildDir/app-image/${distAppName}/runtime/bin"
            } else {
                from javafxSdkLibDir.listFiles().findAll { it.getName().toLowerCase().endsWith('.so') }.collect()
                into "$buildDir/app-image/${distAppName}"
            }
        }
        new File(buildDir, "app-image/${distAppName}").listFiles().findAll {
            it.getName().equalsIgnoreCase("jfxwebkit.dll") ||
                    it.getName().equalsIgnoreCase("ucrtbase.dll") ||
                    it.getName().equalsIgnoreCase("gstreamer-lite.dll") ||
                    it.getName().equalsIgnoreCase("glib-lite.dll") ||
                    it.getName().toLowerCase().startsWith("api-ms-win-core") ||
                    it.getName().toLowerCase().startsWith("api-ms-win-crt")
        }.forEach({
            f -> f.delete()
        })
        copy {
            from "${projectDir}/README.md"
            into new File(buildDir, "app-image/${distAppName}")
        }
        new File(buildDir, "app-image/${distAppName}/savedata").mkdir()
        new File(buildDir, "app-image/${distAppName}/gamedata").mkdir()
        new File(buildDir, "jre-image").deleteDir()
    }
}

clean.dependsOn subprojects.collect { it.tasks.matching { it.name == 'clean' } }