build.gradle

/*
* For more details take a look at the Java Quickstart chapter in the Gradle
* user guide available at https://docs.gradle.org/4.1/userguide/tutorial_java_projects.html
*/

buildscript {
    repositories {
        mavenCentral()
    }
}

// Access Git info from build script
plugins {
    id "application"
    id "base"
    id "java"

    alias(libs.plugins.git.version)
    alias(libs.plugins.javafx)
    alias(libs.plugins.jpackage.runtime)
    alias(libs.plugins.shadow)

    alias(libs.plugins.spotless) apply false
}

allprojects {
    apply plugin: "com.diffplug.spotless"
}

apply from: rootProject.file('buildSrc/shared.gradle')

// Definitions
defaultTasks 'clean', 'build'


// Custom properties
def appSemVer = ""
ext {
    // Allow packagers to build from the source code tarball, which doesn't
    // have '.git'
    revisionFull = project.findProperty('gitCommit')
    revision = revisionFull ? revisionFull.substring(0, 10) : ''
    tagVersion = project.findProperty('gitTag')
    environment = 'Production'
    sentryDSN = sentry_production_dsn

    if (!project.hasProperty('noGit')) {
        // Get tag and commit info from Git to use for version numbering
        def details = versionDetails()

        revision = details.gitHash
        revisionFull = details.gitHashFull
        // Do not count as production if changes (committed or otherwise) have been made to the tree
        // since the tag. And if the tag is a nightly tag, give it the special "Nightly" environment
        // instead of counting it the same as a production release.
        if (!details.isCleanTag) {
            tagVersion = 'SNAPSHOT-' + revision
            project.description = "SNAPSHOT-" + revision
            environment = "Development"
            sentryDSN = sentry_development_dsn
        }
        else if (details.lastTag.startsWith('nightly')) {
            tagVersion = 'NIGHTLY-' + revision
            project.description = "NIGHTLY-" + revision
            environment = "Nightly"
            sentryDSN = sentry_production_dsn
        }
        else {
            tagVersion = details.lastTag
            environment = "Production"
            sentryDSN = sentry_production_dsn
        }
    }

    // This will strip anything other than core semver from the tag
    // e.g. "1.7.2-rc.1" becomes "1.7.2"
    def foundTags = (tagVersion =~ /\d+\.\d+\.\d+/).findAll()

    // If no semver exists, like in dev environment use a defaultVersion from gradle.properties
    if (foundTags.isEmpty()) {
        appSemVer = defaultVersion
    } else {
        appSemVer = foundTags[0]
        developerRelease = ""
    }

    // vendor, tagVersion, appSemVer, and DSN's defaults are set in gradle.properties
    println 'Configuring for ' + project.name + developerRelease + " " + tagVersion + " by " + vendor
    println "AppVersion: " + appSemVer

    // vendor, tagVersion, appSemVer, and DSNs defaults are set in gradle.properties
    println "OS Detected: " + osdetector.os
}

def javaArgs = [
        "-Xss8M", "-Dsun.java2d.d3d=false", "-Dfile.encoding=UTF-8",
        "-Dpolyglot.engine.WarnInterpreterOnly=false",
        "-Djava.util.Arrays.useLegacyMergeSort=true",
        "-DMAPTOOL_DATADIR=.maptool-" + vendor.toLowerCase(), "-XX:+ShowCodeDetailsInExceptionMessages",
        "--add-opens=java.desktop/java.awt=ALL-UNNAMED", "--add-opens=java.desktop/java.awt.geom=ALL-UNNAMED",
        "--add-opens=java.desktop/sun.awt.geom=ALL-UNNAMED", "--add-opens=java.base/java.util=ALL-UNNAMED",
        "--add-opens=javafx.web/javafx.scene.web=ALL-UNNAMED", "--add-opens=javafx.web/com.sun.webkit=ALL-UNNAMED",
        "--add-opens=javafx.web/com.sun.webkit.dom=ALL-UNNAMED","--add-opens=java.base/java.lang=ALL-UNNAMED",
        "--add-opens=java.desktop/sun.awt=ALL-UNNAMED", "--add-opens=java.desktop/sun.java2d=ALL-UNNAMED",
        "--add-opens=java.desktop/javax.swing=ALL-UNNAMED","--add-opens=java.desktop/sun.awt.shell=ALL-UNNAMED",
        "--add-opens=java.desktop/com.sun.java.swing.plaf.windows=ALL-UNNAMED"]

// Used by gradle assemble & run tasks
application {
    mainClass = 'net.rptools.maptool.client.LaunchInstructions'
    applicationDefaultJvmArgs = javaArgs + ["-DRUN_FROM_IDE=true", "-Dsentry.environment=Development"]
    if (osdetector.os.is('osx')) {
        applicationDefaultJvmArgs += [ '-Xdock:name=' + project.name + developerRelease ]
    }
}

configurations {
    forms.extendsFrom implementation
}

spotless {
    java {
        target project.fileTree(project.projectDir) {
            include 'src/**/*.java'
            exclude '**/JTextAreaAppender.java', '**/GifDecoder.java'
            exclude 'src/main/java/net/rptools/maptool/client/ui/themes/Flat*ContrastIJTheme.java'
            exclude 'src/main/java/net/rptools/maptool/client/ui/themes/Utils.java'
        }
    }
}

// org.openjfx.javafxplugin
javafx {
    version = '22'
    // modules = ['javafx.fxml', 'javafx.graphics']
    modules = ['javafx.base', 'javafx.controls', 'javafx.media', 'javafx.swing', 'javafx.web', 'javafx.fxml', 'javafx.graphics']
}

run {
    args = ['-v=' + appSemVer]
    // Add -Dlog4j2.debug to see log4j2 details
    // Add  -Djavax.net.debug=all to debug networking issues

    if (System.getProperty("exec.args") != null) {
        args System.getProperty("exec.args").split()
    }
}

compileJava.configure {
    // Keep the uninstrumented .class files out of the final destination directory. Otherwise we
    // might instrument the same file twice, resulting in duplicate methods.
    destinationDirectory = file("${layout.buildDirectory.get()}/classes/java/main-uninstrumented")
}

def instrumentForms = tasks.register('instrumentForms', Sync) {
    dependsOn compileJava

    from compileJava.destinationDirectory
    into sourceSets.main.java.destinationDirectory

    def formsSet = objects.sourceDirectorySet('forms', 'IntelliJ form files')
    formsSet.srcDirs sourceSets.main.java.sourceDirectories
    formsSet.include '**/*.form'
    inputs.files(formsSet.files)

    doLast {
        ant.echo "Instrumenting IntelliJ GUI forms"
        ant.taskdef(
                name: "javac2",
                classname: "com.intellij.ant.InstrumentIdeaExtensions",
                classpath: configurations.forms.asPath
        )
        ant.javac2(
                includeantruntime: false,
                srcdir: sourceSets.main.allSource.sourceDirectories.asPath,
                destdir: sourceSets.main.java.destinationDirectory.get(),
                classpath: configurations.forms.asPath
        )
    }
}

classes.configure {
    dependsOn instrumentForms
}


if (osdetector.os.is('linux')) {
    def generateDesktop = tasks.register('generateDesktop', Copy) {
        from 'package/linux/launcher.desktop'
        into 'package/linux/'
        expand(
            description: project.description,
            projectName: project.name,
            developerRelease: developerRelease
        )
        filteringCharset = 'UTF-8'
        rename { fileName ->
            project.name + developerRelease + '.desktop'
        }
    }

    tasks.jpackageImage.dependsOn generateDesktop
    tasks.spotlessMisc.dependsOn generateDesktop
}

// Workaround the runtime plugin's hardcoded dependencies on the shadow plugin. It sneakily
// (dynamically) adds dependencies when shadow is detected, but we don't want it to do that since we
// only use shadow for a completely separate build artifact.
tasks.runtime.configure {
    dependsOn installDist
    afterEvaluate {
        dependsOn -= installShadowDist
    }
}
tasks.jpackageImage.configure {
    dependsOn installDist
    afterEvaluate {
        dependsOn -= installShadowDist
    }
}
runtime {
    distDir.set(installDist.destinationDir)
    options = ['--strip-debug', '--strip-native-commands', '--compress', '2', '--no-header-files', '--no-man-pages']
    modules = ['java.base',
               'java.compiler',
               'java.datatransfer',
               'java.desktop',
               'java.instrument',
               'java.logging',
               'java.management',
               'java.naming',
               'java.net.http',
               'java.prefs',
               'java.rmi',
               'java.scripting',
               'java.security.sasl',
               'java.sql',
               'java.transaction.xa',
               'java.xml',
               'jdk.dynalink',
               'jdk.jfr',
               'jdk.jsobject',
               'jdk.unsupported',
               'jdk.unsupported.desktop',
               'jdk.xml.dom',
               'jdk.crypto.cryptoki',
               'jdk.crypto.ec',
               'jdk.zipfs'
    ]

    jpackage {
        mainJar = jar.archiveFile.get().asFile.name

        installerOutputDir = file("releases")
        jvmArgs = javaArgs

        imageOptions = []
        imageName = project.name + developerRelease
        installerName = project.name
        installerOptions = [
                //'--temp', 'releases/temp-files',
                '--verbose',
                '--description', project.description,
                '--copyright', 'Copyright 2000-2021 RPTools.net',
                '--license-file', 'package/license/COPYING.AFFERO',
                '--app-version', appSemVer,
                '--vendor', vendor,
                '--file-associations', 'package/associations.properties'
        ]

        if (osdetector.os.is('windows')) {
            def winUpgradeUUID = "74d934b9-5fb5-433e-aca4-c6f14bd9aa6b"
            println "Setting Windows installer options with upgrade uuid = " + winUpgradeUUID
            targetPlatformName = "win"
            resourceDir = file('package/windows')
            imageOptions += ['--icon', 'package/windows/' + project.name + developerRelease + '.ico']
            installerOptions += [
                    '--win-dir-chooser',
                    '--win-shortcut',
                    '--win-menu',
                    '--win-menu-group', vendor,
                    '--win-upgrade-uuid', winUpgradeUUID
            ]
            targetPlatform('win') {
                jdkHome = jdkDownload('https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.1%2B12/OpenJDK21U-jdk_x64_windows_hotspot_21.0.1_12.zip')
            }
        }

        if (osdetector.os.is('osx')) {
            println "Setting MacOS installer options"
            targetPlatformName = "mac"
            imageOptions += ['--icon', 'package/macosx/' + project.name + developerRelease + '.icns']
            installerOptions += [
                    '--mac-package-name', project.name + developerRelease
            ]
            targetPlatform('mac') {
                jdkHome = jdkDownload('https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.1%2B12/OpenJDK21U-jdk_x64_mac_hotspot_21.0.1_12.tar.gz')
                jvmArgs += [ '-Xdock:name=' + project.name + developerRelease ]
            }
        }

        if (osdetector.os.is('linux')) {
            println "Setting Linux installer options"
            targetPlatformName = "linux"
            resourceDir = file('package/linux')
            imageOptions += ['--icon', 'package/linux/' + project.name + developerRelease + '.png']
            installerOptions += [
                    '--linux-menu-group', 'Game',
                    '--linux-shortcut'
            ]

            if (installerType == 'deb') {
                installerOptions += [
                        '--linux-deb-maintainer', 'admin@rptools.net'
                ]
            }

            if (installerType == 'rpm') {
                installerOptions += [
                        '--linux-rpm-license-type', 'AGPLv3'
                ]
            }
            targetPlatform('linux') {
                jdkHome = jdkDownload('https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.1%2B12/OpenJDK21U-jdk_x64_linux_hotspot_21.0.1_12.tar.gz')
            }
        }
    }
}

def zipJpackageImage = tasks.register('zipJpackageImage', Zip) {
    // Really we depend on the app-image produce by the jpackageImage task, but for some reason it
    // is defined as an output of the jpackage task. As a result, Gradle will get mad at us if we
    // say we depend directly on jpackageImage.
    dependsOn tasks.jpackage

    def extension = ''
    if (osdetector.os.is('osx')) {
        extension = '.app'
    }

    from "${jpackageImage.jpackageData.imageOutputDirOrDefault}${File.separator}${jpackageImage.jpackageData.imageNameOrDefault}${extension}"
    destinationDirectory = jpackageImage.jpackageData.installerOutputDir
    archiveFileName = project.name + "-" + appSemVer + "-" + jpackageImage.jpackageData.targetPlatformName + "${extension}.zip"
}

// In this section you declare the dependencies for your production and test code
dependencies {
    implementation project(':common')
    implementation project(':dicelib')
    implementation project(':clientserver')
    implementation project(':messages')

    implementation(libs.bundles.log4j)
    implementation(libs.slf4j.simple)
    implementation(libs.apache.commons.logging)
    implementation(libs.bundles.sentry)

    implementation(libs.servicediscovery)
    implementation(libs.upnplib)
    implementation(libs.okhttp)

    implementation(libs.bundles.imageio)
    implementation(libs.batik)
    implementation(libs.bundles.pdfbox)
    implementation(libs.bcmail)
    implementation(libs.bundles.jai.imageio)
    implementation(libs.webp.imageio)

    implementation(libs.bundles.jide) // Currently hosted on nerps.net/repo
    implementation(libs.fifesoft.rsyntaxtexxtarea)
    implementation(libs.fifesoft.rstaui)
    implementation(libs.fifesoft.autocomplete)
    implementation(libs.fifesoft.languagesupport)
    implementation(libs.bundles.flatlaf)
    implementation(libs.tinylaf.nocp)
    implementation(libs.jsvg)

    implementation(libs.bundles.handlebars)

    implementation(libs.apache.commons.configuration)
    implementation(libs.apache.commons.collections)
    implementation(libs.apache.commons.io)
    implementation(libs.apache.commons.net)
    implementation(libs.apache.commons.cli)
    implementation(libs.apache.commons.lang)
    implementation(libs.apache.commons.beanutils)
    implementation(libs.apache.commons.jxpath)
    implementation(libs.apache.tika)

    implementation(libs.gson)

    // region json-smart <2.5.2 is subject to DoS, but json-path has not updated yet. Force it to.
    implementation(libs.jsonpath) {
        exclude group: 'net.minidev', module: 'json-smart'
    }
    implementation("net.minidev:json-smart:2.5.2")
    // endregion

    implementation(libs.jsoup)
    implementation(libs.jcabi.xml)
    implementation(libs.xstream)

    implementation(libs.javatuples)
    implementation(libs.guava)
    implementation(libs.jts.core)
    implementation(libs.jgrapht.core)
    implementation(libs.flexmark.all)
    implementation(libs.reflections)
    implementation(libs.yasb)

    implementation(libs.bundles.graalvm.js)

    forms(libs.intellij.forms.tasks)
    implementation(libs.intellij.forms.runtime)
    implementation(libs.miglayout.swing)

    implementation(libs.rptools.maptool.resources)
    implementation(libs.rptools.parser)
    implementation(libs.rptools.maptool.addons)
    implementation(libs.rptools.dice.roller)
    implementation(libs.noiselib)

    // libgdx
    implementation(libs.bundles.gdx)
    implementation(variantOf(libs.gdx.platform) { classifier('natives-desktop')})
    implementation(variantOf(libs.gdx.freetype.platform) { classifier('natives-desktop')})
}

processResources {
    with copySpec {
        from("build-resources/sentry.properties.template")
        rename("sentry.properties.template", "sentry.properties")
        duplicatesStrategy = DuplicatesStrategy.WARN
        def tokens = [
                AppVersion : "${tagVersion}",
                Environment: "${environment}",
                SentryDSN  : "${sentryDSN}"
        ]
        expand(tokens)
        inputs.properties(tokens)
    }
}

shadowJar {
    zip64 = true
    mergeServiceFiles()

    archiveBaseName = project.name + '-' + tagVersion
    destinationDirectory = file("$rootDir/releases")
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
    archiveClassifier = null

    manifest {
        attributes 'Implementation-Title': project.name + developerRelease,
                'Implementation-Version': tagVersion,
                'Implementation-Vendor': vendor,
                'Git-Commit': revision,
                'Git-Commit-SHA': revisionFull,
                'Built-By': System.getProperty('user.name'),
                'Built-Date': new Date(),
                'Built-JDK': System.getProperty('java.version'),
                'Source-Compatibility': project.java.sourceCompatibility,
                'Target-Compatibility': project.java.targetCompatibility,
                'Main-Class': project.application.mainClass,
                'Multi-Release': true
    }

    exclude 'module-info.class' //This is to make sure maptool doesn't become a module by including module-info of dependencies. Probably needs to be fixed before we go to jdk 11+
}

jar {
    manifest {
        attributes 'Implementation-Title': project.name + developerRelease,
                'Implementation-Version': tagVersion,
                'Implementation-Vendor': vendor,
                'Git-Commit': revision,
                'Git-Commit-SHA': revisionFull,
                'Built-By': System.getProperty('user.name'),
                'Built-Date': new Date(),
                'Built-JDK': System.getProperty('java.version'),
                'Source-Compatibility': project.java.sourceCompatibility,
                'Target-Compatibility': project.java.targetCompatibility,
                'Main-Class': project.application.mainClass
    }
}

// For logging Git Commit during CI
task displayGitInfo {
    doLast {
        println 'Git-Commit-SHA: ' + revisionFull
    }
}

// Currently includes license files
task copyPackageExtras(type: Copy) {
    from('package/license/')
    into('build/libs/')
    include('*')
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
}

javadoc {
    options.addStringOption('Xmaxwarns', '2000')
    options.addBooleanOption('html5', true)
    options.tags("note:a:<strong><u>Note:</u></strong>")
}

task createWrapper(type: Wrapper) {
    gradleVersion = '8.2.1'
}