build.gradle

import art.arcane.volmit.packaging.PackagingMode
import art.arcane.volmit.packaging.PackedJar
import art.arcane.volmit.packaging.VerifyNativeClassBoundary
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.api.tasks.WriteProperties

buildscript {
    repositories {
        mavenCentral()
        maven { url = uri('https://jitpack.io') }
    }
    dependencies {
        classpath('com.github.VolmitSoftware.VolmLib:packaging:master-SNAPSHOT')
    }
}

plugins {
    id 'java-library'
    alias libs.plugins.lombok
    alias libs.plugins.shadow
    alias libs.plugins.slimjar
}

apply plugin: 'art.arcane.volmit-packaging'

tasks.named('slimJar').get()

String biletoolsVersion = providers.gradleProperty('biletoolsVersion').get()
version = biletoolsVersion
ext.bukkitMinecraftRange = providers.gradleProperty('bukkitMinecraftRange').getOrElse('1.20.1-26.3')
def apiVersion = '1.20'
def main = 'com.volmit.bile.BileTools'
def volmLibCoordinate = providers.gradleProperty("volmLibCoordinate").orElse("com.github.VolmitSoftware:VolmLib:master-SNAPSHOT").get()
String languageSourceRepository = providers.gradleProperty('languageSourceRepository').orElse('VolmitSoftware/BileTools').get()
String languageSourceBranch = providers.gradleProperty('languageSourceBranch').orElse(providers.provider {
    try {
        Process process = new ProcessBuilder('git', 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD')
                .directory(projectDir)
                .redirectErrorStream(true)
                .start()
        String output = process.inputStream.text.trim()
        if (process.waitFor() == 0 && output.startsWith('origin/')) {
            return output.substring('origin/'.length())
        }
    } catch (IOException | InterruptedException ignored) {
    }
    return 'master'
}).get()
if (!(languageSourceRepository ==~ /[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/)) {
    throw new GradleException('languageSourceRepository must be a GitHub owner/repository')
}
if (!(languageSourceBranch ==~ /[A-Za-z0-9][A-Za-z0-9._\/-]{0,127}/) || languageSourceBranch.contains('..')) {
    throw new GradleException('languageSourceBranch must be a Git branch name')
}
String languageSourcePath = 'src/main/resources/languages'
List<File> languageSourceFiles = fileTree(languageSourcePath) {
    include('*.toml')
}.files.toList().sort { File left, File right -> left.name <=> right.name }
List<String> languageSourceLocales = new ArrayList<>(languageSourceFiles.size())
for (File languageSourceFile : languageSourceFiles) {
    languageSourceLocales.add(languageSourceFile.name.substring(0,
            languageSourceFile.name.length() - '.toml'.length()))
}
def languageSourceManifestTask = tasks.register('generateLanguageSourceManifest', WriteProperties) {
    destinationFile.set(layout.buildDirectory.file('generated/language-source/biletools-language-source.properties'))
    property('repository', languageSourceRepository)
    property('branch', languageSourceBranch)
    property('path', languageSourcePath)
    property('extension', '.toml')
    property('locales', languageSourceLocales.join(','))
}

evaluationDependsOn(':velocity')
def shadowJarTask = tasks.named('shadowJar', org.gradle.api.tasks.bundling.Jar)
def velocityJarTask = project(':velocity').tasks.named('shadowJar', org.gradle.api.tasks.bundling.Jar)
def universalJarTask = tasks.register('universalJar', Jar) {
    group = 'build'
    description = 'Packages the Bukkit and Velocity entry points in one BileTools plugin jar.'
    archiveClassifier.set('')
    archiveFileName.set("BileTools v${project.version} [CraftBukkit] ${bukkitMinecraftRange}.jar")
    duplicatesStrategy = DuplicatesStrategy.FAIL
    dependsOn(shadowJarTask, velocityJarTask)
    from(shadowJarTask.flatMap { it.archiveFile }.map { zipTree(it) }) {
        exclude('META-INF/MANIFEST.MF')
    }
    from(velocityJarTask.flatMap { it.archiveFile }.map { zipTree(it) }) {
        exclude('META-INF/MANIFEST.MF')
    }
}
tasks.named('assemble') { dependsOn(universalJarTask) }
tasks.named('jar') { enabled = false }

tasks.processResources {
    dependsOn(languageSourceManifestTask)
    exclude('languages/*.toml')
    from(languageSourceManifestTask)
    inputs.properties(
        'name': rootProject.name,
        'version': version,
        'main': main,
        'apiVersion': apiVersion,
    )

    filesMatching('**/plugin.yml') {
        expand(inputs.properties)
    }
}

tasks.withType(org.gradle.api.tasks.bundling.Jar).configureEach {
    exclude('languages/**')
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(25)
    }
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

repositories {
    mavenLocal()
    mavenCentral()
    maven { url = 'https://repo.papermc.io/repository/maven-public/' }
    maven { url = 'https://jitpack.io' }
}

tasks.named('compileJava', JavaCompile) {
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(17)
}

tasks.named('compileTestJava', JavaCompile) {
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(17)
}

tasks.named('test', Test) {
    exclude('com/volmit/bile/RuntimeLibraryBootstrapTest.class')
}

tasks.register('runtimeArtifactTest', Test) {
    group = 'verification'
    description = 'Runs the tests that exercise the packaged runtime artifact.'
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    include('com/volmit/bile/RuntimeLibraryBootstrapTest.class')
    dependsOn universalJarTask
    systemProperty('biletools.runtimeArtifact', universalJarTask.get().archiveFile.get().asFile.absolutePath)
}

tasks.register('bukkitRuntimeArtifactTest', Test) {
    group = 'verification'
    description = 'Runs the runtime bootstrap tests against the Bukkit artifact.'
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    include('com/volmit/bile/RuntimeLibraryBootstrapTest.class')
    dependsOn(shadowJarTask)
    inputs.file(shadowJarTask.flatMap { Jar archive -> archive.archiveFile })
    doFirst {
        systemProperty('biletools.runtimeArtifact', shadowJarTask.get().archiveFile.get().asFile.absolutePath)
    }
}

configurations {
    spigotCompatibility
    currentPaperCompatibility
    currentSpigotCompatibility
}

dependencies {
    compileOnly libs.paper
    spigotCompatibility libs.spigot
    currentPaperCompatibility libs.paperCurrent
    currentSpigotCompatibility libs.spigotCurrent
    implementation(volmLibCoordinate) {
        changing = true
        transitive = false
    }
    implementation('de.crazydev22.slimjar.helper:spigot:2.1.9')
    slimApi('com.google.code.gson:gson:2.10.1')
    slimApi('com.moandjiezana.toml:toml4j:0.7.2')
    slimApi('net.kyori:adventure-api:4.26.1')
    slimApi('net.kyori:adventure-text-minimessage:4.26.1')
    slimApi('net.kyori:adventure-text-serializer-legacy:4.26.1')
    slimApi('net.kyori:adventure-text-serializer-plain:4.26.1')
    // VolmLib's ComponentMessenger Spigot path pins JSONOptions by data version; without this the
    // shaded jar carries a dangling reference and the thin step refuses it.
    slimApi('net.kyori:adventure-text-serializer-gson:4.26.1')
    slimApi('net.kyori:adventure-text-serializer-json:4.26.1')
    implementation libs.bstats
    testImplementation libs.paper
    testImplementation 'junit:junit:4.13.2'
}

configurations.configureEach {
    resolutionStrategy.cacheChangingModulesFor(0, "seconds")
    resolutionStrategy.cacheDynamicVersionsFor(0, "seconds")
}

tasks.register('compileSpigotCompatibility', JavaCompile) {
    source = sourceSets.main.java
    classpath = files(sourceSets.main.compileClasspath.filter { File dependency ->
        !dependency.name.startsWith('paper-api-')
    }) + configurations.spigotCompatibility
    destinationDirectory.set(layout.buildDirectory.dir('classes/java/spigotCompatibility'))
    options.annotationProcessorPath = configurations.annotationProcessor
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(17)
}

tasks.register('compileCurrentPaperCompatibility', JavaCompile) {
    source = sourceSets.main.java
    classpath = files(sourceSets.main.compileClasspath.filter { File dependency ->
        !dependency.name.startsWith('paper-api-')
    }) + configurations.currentPaperCompatibility
    destinationDirectory.set(layout.buildDirectory.dir('classes/java/currentPaperCompatibility'))
    options.annotationProcessorPath = configurations.annotationProcessor
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(25)
}

tasks.register('compileCurrentSpigotCompatibility', JavaCompile) {
    source = sourceSets.main.java
    classpath = files(sourceSets.main.compileClasspath.filter { File dependency ->
        !dependency.name.startsWith('paper-api-')
    }) + configurations.currentSpigotCompatibility
    destinationDirectory.set(layout.buildDirectory.dir('classes/java/currentSpigotCompatibility'))
    options.annotationProcessorPath = configurations.annotationProcessor
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(25)
}

slimJar {
    relocate('com.google.gson', 'com.volmit.bile.libs.gson')
    relocate('com.moandjiezana.toml', 'com.volmit.bile.libs.toml')
    relocate('net.kyori', 'com.volmit.bile.libs.kyori')
}

tasks.named('shadowJar') {
    archiveClassifier.set('bukkit')
    destinationDirectory.set(layout.buildDirectory.dir('platform'))
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    // bStats internals are reflection/callable driven, keep the minimizer off them.
    minimize {
        exclude(dependency('org.bstats:.*:.*'))
        exclude(dependency('de.crazydev22.slimjar.helper:.*:.*'))
    }
    // bStats refuses to enable unless its package is relocated. VolmLib stays unrelocated on purpose.
    relocate('org.bstats', 'com.volmit.bile.libs.bstats')
    relocate('io.github.slimjar', 'com.volmit.bile.libs.slimjar')
    relocate('com.google.gson', 'com.volmit.bile.libs.gson')
    relocate('com.moandjiezana.toml', 'com.volmit.bile.libs.toml')
    relocate('net.kyori', 'com.volmit.bile.libs.kyori') {
        skipStringConstants = true
    }
}

tasks.register('verifyCompatibilityArtifact') {
    dependsOn tasks.named('shadowJar')

    doLast {
        File artifact = tasks.named('shadowJar').get().archiveFile.get().asFile
        java.util.zip.ZipFile archive = new java.util.zip.ZipFile(artifact)
        try {
            List<String> bundledLanguages = new ArrayList<>()
            Properties languageManifest = null
            java.util.Enumeration<? extends java.util.zip.ZipEntry> entries = archive.entries()
            while (entries.hasMoreElements()) {
                java.util.zip.ZipEntry entry = entries.nextElement()
                if (entry.name == 'velocity-plugin.json' || entry.name.startsWith('com/volmit/bile/velocity/')) {
                    throw new GradleException("Bukkit artifact contains a Velocity entry: ${entry.name}")
                }
                if (!entry.directory && entry.name.startsWith('languages/') && entry.name.endsWith('.toml')) {
                    bundledLanguages.add(entry.name)
                }
                if (!entry.directory && entry.name == 'biletools-language-source.properties') {
                    languageManifest = new Properties()
                    archive.getInputStream(entry).withCloseable { InputStream input -> languageManifest.load(input) }
                }
                if (!entry.name.endsWith('.class')) {
                    continue
                }
                if (entry.name.startsWith('com/volmit/bile/libs/gson/')
                        || entry.name.startsWith('com/volmit/bile/libs/toml/')
                        || entry.name.startsWith('com/volmit/bile/libs/kyori/')
                        || entry.name.startsWith('com/google/gson/')
                        || entry.name.startsWith('com/moandjiezana/toml/')
                        || entry.name.startsWith('net/kyori/')) {
                    throw new GradleException("Runtime dependency is bundled in ${artifact.name}: ${entry.name}")
                }

                java.io.DataInputStream input = new java.io.DataInputStream(archive.getInputStream(entry))
                try {
                    long magic = Integer.toUnsignedLong(input.readInt())
                    if (magic != 0xCAFEBABEL) {
                        throw new GradleException("Invalid class file in ${artifact.name}: ${entry.name}")
                    }
                    input.readUnsignedShort()
                    int majorVersion = input.readUnsignedShort()
                    if (majorVersion > 61) {
                        throw new GradleException("${entry.name} requires class version ${majorVersion}; BileTools must remain Java 17 compatible")
                    }
                } finally {
                    input.close()
                }
            }

            java.util.zip.ZipEntry descriptor = archive.getEntry('plugin.yml')
            if (archive.getEntry('slimjar.dat') == null
                    || archive.getEntry('slimjar-resolutions.dat') == null
                    || archive.getEntry('com/volmit/bile/libs/slimjar/app/builder/SpigotApplicationBuilder.class') == null) {
                throw new GradleException("${artifact.name} is missing its runtime dependency bootstrap")
            }
            if (descriptor == null) {
                throw new GradleException("${artifact.name} does not contain plugin.yml")
            }
            String pluginYml = archive.getInputStream(descriptor).getText('UTF-8')
            if (!pluginYml.readLines().contains('api-version: 1.20')) {
                throw new GradleException("${artifact.name} does not declare api-version: 1.20")
            }
            if (!bundledLanguages.isEmpty()) {
                throw new GradleException("Runtime artifact contains language resources: ${bundledLanguages}")
            }
            if (languageManifest == null) {
                throw new GradleException('Runtime artifact is missing biletools-language-source.properties')
            }
            if (languageManifest.getProperty('repository') != languageSourceRepository
                    || languageManifest.getProperty('branch') != languageSourceBranch
                    || languageManifest.getProperty('path') != languageSourcePath
                    || languageManifest.getProperty('extension') != '.toml'
                    || languageManifest.getProperty('locales') != languageSourceLocales.join(',')) {
                throw new GradleException('Runtime language source manifest does not match the build source set')
            }
            if (languageManifest.stringPropertyNames().any { String key ->
                key == 'revision' || key == 'mode' || key.startsWith('sha256.')
            }) {
                throw new GradleException('Runtime language source manifest must track the repository branch, not a pinned revision')
            }
        } finally {
            archive.close()
        }
    }
}

tasks.register('verifyPlatformPackaging') {
    group = 'verification'
    description = 'Verifies the Velocity descriptor and bytecode inside the universal BileTools jar.'
    dependsOn(universalJarTask)
    inputs.file(universalJarTask.flatMap { it.archiveFile })
    doLast {
        File artifact = universalJarTask.get().archiveFile.get().asFile
        new java.util.jar.JarFile(artifact).withCloseable { java.util.jar.JarFile archive ->
            java.util.jar.JarEntry descriptorEntry = archive.getJarEntry('velocity-plugin.json')
            if (descriptorEntry == null) {
                throw new GradleException("${artifact.name} does not contain velocity-plugin.json")
            }
            Map descriptor = new groovy.json.JsonSlurper().parse(archive.getInputStream(descriptorEntry))
            if (descriptor.main != 'com.volmit.bile.velocity.BileVelocity') {
                throw new GradleException("Velocity descriptor main is ${descriptor.main}")
            }
            if (descriptor.version != project.version.toString()) {
                throw new GradleException("Velocity descriptor version is ${descriptor.version}")
            }
            java.util.jar.JarEntry entryPoint = archive.getJarEntry('com/volmit/bile/velocity/BileVelocity.class')
            if (entryPoint == null) {
                throw new GradleException("${artifact.name} does not contain the Velocity entry point")
            }
            String bytecode = new String(archive.getInputStream(entryPoint).readAllBytes(),
                    java.nio.charset.StandardCharsets.ISO_8859_1)
            if (bytecode.contains('com/volmit/bile/libs/')) {
                throw new GradleException('Velocity bytecode must not reference Bukkit-relocated libraries')
            }
        }
    }
}

tasks.named('check') {
    dependsOn tasks.named('runtimeArtifactTest')
    dependsOn tasks.named('compileSpigotCompatibility')
    dependsOn tasks.named('compileCurrentPaperCompatibility')
    dependsOn tasks.named('compileCurrentSpigotCompatibility')
    dependsOn tasks.named('verifyCompatibilityArtifact')
    dependsOn tasks.named('verifyPlatformPackaging')
    dependsOn ':velocity:test'
}

tasks.named('build') {
    dependsOn tasks.named('shadowJar')
    dependsOn universalJarTask
    dependsOn tasks.named('verifyCompatibilityArtifact')
    dependsOn ':velocity:build'
}

if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_25)) {
    System.err.println()
    System.err.println('=========================================================================================================')
    System.err.println("You must run gradle on Java 25 or newer. You are using ${JavaVersion.current()}")
    System.err.println()
    System.err.println('=== For IDEs ===')
    System.err.println('1. Configure the project for Java 25')
    System.err.println('2. Configure the bundled gradle to use Java 25 in settings')
    System.err.println()
    System.err.println('=== For Command Line (gradlew) ===')
    System.err.println('1. Install JDK 25 from https://adoptium.net/temurin/releases/?version=25')
    System.err.println('2. Set JAVA_HOME environment variable to the new jdk installation folder')
    System.err.println('3. Open a new command prompt window to get the new environment variables if need be.')
    System.err.println('=========================================================================================================')
    System.err.println()
    System.exit(69)
}

pluginPackaging {
    artifacts {
        create('bukkit') {
            taskName = 'shadowJar'
            policyName = 'BileTools'
            intermediate = true
            prunePrefixes = ['art/arcane/volmlib/']
            keepPrefixes = ['art/arcane/volmlib/util/matter/slices/']
            shrinkRules = [file('packaging/shrink.pro')]
            shrinkRelocations = [
                'com.google.gson': 'com.volmit.bile.libs.gson',
                'com.moandjiezana.toml': 'com.volmit.bile.libs.toml',
                'net.kyori': 'com.volmit.bile.libs.kyori'
            ]
        }
        create('distribution') {
            stripDirectories = true
            stripLocalVariables = true
            releaseCompression = providers.gradleProperty('compactRelease').map { it.toBoolean() }
                    .getOrElse(!PackagingMode.resolve(providers).development())
            packed = true
            packedJarAccessors = ['com/volmit/bile/BileTools#runtimeArchive']
            taskName = 'universalJar'
            policyName = 'BileTools'
            shrinkRules = [file('packaging/shrink.pro')]
            shrinkLibraries.from(project(':velocity').configurations.compileClasspath)
            shrinkRelocations = [
                'com.google.gson': 'com.volmit.bile.libs.gson',
                'com.moandjiezana.toml': 'com.volmit.bile.libs.toml',
                'net.kyori': 'com.volmit.bile.libs.kyori'
            ]
            forbiddenPrefixes = forbiddenPrefixes + ['com/velocitypowered/', 'com/google/inject/']
            requiredEntries = requiredEntries + [
                'velocity-plugin.json',
                'com/volmit/bile/velocity/BileVelocity.class',
                'com/volmit/bile/velocity/watch/PluginJarDirectoryWatcher.class'
            ]
        }
    }
}

configurations {
    paper263Compatibility {
        canBeConsumed = false
        canBeResolved = true
        attributes {
            attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE,
                    objects.named(org.gradle.api.attributes.Usage, org.gradle.api.attributes.Usage.JAVA_API))
            attribute(org.gradle.api.attributes.java.TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 25)
        }
    }
}

dependencies {
    paper263Compatibility('io.papermc.paper:paper-api:26.3.build.25-alpha')
}

tasks.register('compilePaper263Compatibility', JavaCompile) {
    source = sourceSets.main.java
    classpath = configurations.paper263Compatibility + files(sourceSets.main.compileClasspath.filter { File dependency ->
        !dependency.name.startsWith('paper-api-') && !dependency.name.startsWith('spigot-api-')
    })
    destinationDirectory.set(layout.buildDirectory.dir('classes/java/paper263Compatibility'))
    options.annotationProcessorPath = configurations.annotationProcessor
    options.compilerArgs.add('-parameters')
    options.encoding = 'UTF-8'
    options.release.set(25)
}

tasks.named('check').configure {
    dependsOn(tasks.named('compilePaper263Compatibility'))
}

tasks.register('verifyBukkitNativeClassBoundary', VerifyNativeClassBoundary) {
    group = 'verification'
    classes.from(sourceSets.main.output.classesDirs)
    nativeImplementationPackages.set(pluginPackaging.nativeImplementationPackages)
    report.set(layout.buildDirectory.file('reports/bukkit-native-class-boundary.txt'))
    dependsOn('verifyNativeBoundary')
}

tasks.register('packedBukkitJar', PackedJar) {
    group = 'build'
    description = 'Packages the Bukkit runtime without the Velocity entry point.'
    dependsOn('verifyBukkitPackaging')
    inputJar.set(shadowJarTask.flatMap { Jar archive -> archive.archiveFile })
    outputJar.set(layout.buildDirectory.file("platform/BileTools-${project.version}-bukkit-packed.jar"))
    maximumBytes.set(pluginPackaging.artifacts.getByName('bukkit').effectiveMaximumBytes)
    jarAccessors.set(['com/volmit/bile/BileTools#runtimeArchive'])
}

tasks.register('prepareRelease', Sync) {
    group = 'distribution'
    description = 'Verifies and stages the CraftBukkit release jar.'
    dependsOn('test', 'bukkitRuntimeArtifactTest', 'compileSpigotCompatibility',
            'compileCurrentPaperCompatibility', 'compileCurrentSpigotCompatibility',
            'compilePaper263Compatibility', 'verifyCompatibilityArtifact',
            'verifyLoggingPolicy', 'verifyBukkitNativeClassBoundary', 'packedBukkitJar')
    from(tasks.named('packedBukkitJar', PackedJar).flatMap { PackedJar archive -> archive.outputJar })
    into(layout.buildDirectory.dir('release'))
    rename { String name -> "BileTools-${project.version}-bukkit.jar" }
}

tasks.register('buildSwiftSwamp', Copy) {
    group = 'development'
    description = 'Builds, verifies, and stages BileTools in the workspace BUILDS directory.'
    dependsOn('check', universalJarTask)
    outputs.upToDateWhen { false }
    from(universalJarTask.flatMap { Jar archive -> archive.archiveFile })
    into(providers.gradleProperty('buildsDirectory').orElse('../BUILDS'))
    rename { String ignored -> 'BileTools.jar' }
}

apply from: 'gradle/multiplexor.gradle'