build.gradle

import com.google.common.io.ByteStreams
import org.parchmentmc.compass.CompassPlugin
import org.parchmentmc.compass.tasks.GenerateExport
import org.parchmentmc.compass.tasks.GenerateSanitizedExport
import org.parchmentmc.compass.tasks.VersionDownload

import java.time.OffsetDateTime
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter

plugins {
    id 'java-base'
    id 'maven-publish'
    id 'org.parchmentmc.compass' version '0.10.0'
    id 'org.parchmentmc.writtenbooks' version '0.5.+'
}

group = 'org.parchmentmc.data'
final releaseType = project.findProperty('releaseType') ?: 'local'
final date = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern('yyyy.MM.dd'))
final isRelease = releaseType.toString() == 'release'
version = date + (isRelease ? '' : "-${releaseType}-SNAPSHOT")
final isBleeding = releaseType.toString() == 'bleeding'
if (isBleeding) {
    version = 'BLEEDING-SNAPSHOT'
}
// Only output if not in CI
if (!Boolean.parseBoolean(System.getenv("CI"))){
    println("Version: $version")
}

writtenbooks {
    snapshotVersion = !isRelease
    bleedingVersion = isBleeding
    githubRepo = 'ParchmentMC/Parchment'
}

compass {
    version = '1.21.1'
}

repositories {
    maven {
        name = 'MinecraftForge'
        url = 'https://maven.minecraftforge.net/'
    }
    maven {
        name = 'FabricMC'
        url = 'https://maven.fabricmc.net/'
    }
    maven {
        name = 'QuiltMC <333'
        url = 'https://maven.quiltmc.org/repository/release/'
    }
    // remove when ASM 9.8 is released
    maven {
        name = 'OW2 Snapshots for Enigma'
        url = "https://repository.ow2.org/nexus/content/repositories/snapshots/"
    }
}

configurations {
    enigma
    remapper
}

dependencies {
    // MCPConfig for the SRG intermediate
    mcpconfig 'de.oceanlabs.mcp:mcp_config:1.19.3-20221207.122022'

    // ForgeAutoRenamingTool, for remapping the client JAR
    remapper 'net.minecraftforge:ForgeAutoRenamingTool:1.0.2'

    // Enigma, gorgeous interface for editing mappings
    enigma 'org.quiltmc:enigma-swing:2.5.2'

    // ParchmentJAM, JAMMER integration for migrating mapping data
    jammer 'org.parchmentmc.jam:jam-parchment:0.1.0'
}

tasks.register('printGHActionsOutput') {
    doLast {
        println("CI_VERSION=${project.version}")
        println("CI_GROUP=${project.group}")
        println("CI_ARTIFACT=parchment-${project.compass.version.get()}")
        println("CI_GAME_VERSION=${project.compass.version.get()}")
    }
}

final downloadClientJar = tasks.register('downloadClientJar', VersionDownload) {
    group 'parchment'
    description 'Downloads the client JAR for the current version set in Compass.'
}

final remapJar = tasks.register('remapJar', RemapJar) {
    dependsOn downloadClientJar

    final obfDL = project.plugins.getPlugin(CompassPlugin).obfuscationMapsDownloader
    inputJar = downloadClientJar.flatMap { it.outputFile }
    mappings = obfDL.getObfuscationMap().flatMap { s -> obfDL.clientDownloadOutput }
    outputJar = project.layout.buildDirectory.dir('remapped')
            .zip(project.compass.version) { d, ver -> d.file("$ver-client.jar") }
    logFile = project.layout.buildDirectory.dir('remapped')
            .map { d -> d.file('log.txt') }
}

tasks.register('enigma', EnigmaExec) {
    inputJar = remapJar.flatMap { it.outputJar }
    mappings = project.compass.productionData
}

tasks.withType(GenerateExport).configureEach {
    // Disable blackstone if UPDATING is set.
    // This will ensure cascaded method data does not get mixed into the production data when updating.
    useBlackstone = !Boolean.valueOf(project.findProperty('UPDATING')?.toString())
}

tasks.register('generateSanitizedExport', GenerateSanitizedExport) {
    group = 'compass'
    description = "Generates an export file using the 'official' intermediate provider and production data."
    input = project.compass.productionData
    inputFormat = project.compass.productionDataFormat
}

tasks.register('officialExportZip', Zip) {
    group = 'build'
    description = "Creates a ZIP archive containing the export produced by the 'official' intermediate provider and production data."
    from(tasks.named('generateOfficialExport', GenerateExport).flatMap { it.output })
    archiveBaseName = 'officialExport'
}

tasks.register('officialSanitizedExportZip', Zip) {
    group = 'build'
    description = "Creates a ZIP archive containing the sanitized export produced by the 'official' intermediate provider and production data."
    from(tasks.named('generateSanitizedExport', GenerateExport).flatMap { it.output })
    archiveBaseName = 'officialSanitizedExport'
}

tasks.register('officialStagingExportZip', Zip) {
    group = 'build'
    description = "Creates a ZIP archive containing the export produced by the 'official' intermediate provider and staging data."
    from(tasks.named('generateOfficialStagingExport', GenerateExport).flatMap { it.output })
    archiveBaseName = 'officialStagingExport'
}

tasks.withType(Zip).matching { it.name.startsWith 'official' }.configureEach {
    rename { 'parchment.json' }
    reproducibleFileOrder = true
    preserveFileTimestamps = false
    destinationDirectory = project.layout.buildDirectory.dir('exportZips')
}

publishing {
    publications.all { p ->
        p.pom {
            name = 'Parchment Mappings'
            description = 'Parameter names and javadoc mappings for Minecraft: Java Edition.'
            organization {
                name = 'ParchmentMC'
                url = 'https://github.com/ParchmentMC'
            }
            licenses {
                license {
                    name = 'CC0-1.0'
                    url = 'https://creativecommons.org/publicdomain/zero/1.0/legalcode'
                }
            }
        }
        afterEvaluate {
            p.artifactId = "parchment-${project.compass.version.get()}"
            p.pom.properties['minecraft_version'] = project.compass.version
        }
    }
    publications.register('export', MavenPublication) { p ->
        p.artifact tasks.named('officialExportZip', Zip)
        p.artifact(tasks.named('officialSanitizedExportZip', Zip)) {
            classifier = 'checked'
        }
    }
    publications.register('staging', MavenPublication) { p ->
        p.artifact tasks.named('officialStagingExportZip', Zip)
        p.version = 'staging-SNAPSHOT'
    }
    repositories {
        maven {
            name 'projectLocal'
            url "file://${rootProject.file('repo').absolutePath}"
        }
    }
}

tasks.register('publishExport') {
    group = PublishingPlugin.PUBLISH_TASK_GROUP
    description = "Publishes the 'export' Maven publication."

    dependsOn tasks.withType(PublishToMavenRepository).matching {
        it.publication == publishing.publications.export
    }
}

abstract class RemapJar extends JavaExec {
    @InputFile
    abstract RegularFileProperty getInputJar()

    @InputFile
    abstract RegularFileProperty getMappings()

    @OutputFile
    abstract RegularFileProperty getOutputJar()

    @Console
    abstract RegularFileProperty getLogFile()

    RemapJar() {
        group 'parchment'
        description 'Remaps the client JAR with the Mojang obfuscation mappings.'

        classpath project.configurations.remapper
        mainClass.set 'net.minecraftforge.fart.Main'

        standardOutput = ByteStreams.nullOutputStream() // We have a log file in place

        args = ['--reverse'] // Input mappings is expected to be OBF->MOJ (ProGuard layout)
        argumentProviders.add({ ->
            ['--input', inputJar.get().asFile.absolutePath,
             '--map', mappings.get().asFile.absolutePath,
             '--output', outputJar.get().asFile.absolutePath,
             '--log', logFile.get().asFile.absolutePath]
        } as CommandLineArgumentProvider)
    }
}

abstract class EnigmaExec extends JavaExec {
    @InputFile
    abstract RegularFileProperty getInputJar()

    @InputDirectory
    abstract DirectoryProperty getMappings()

    EnigmaExec() {
        group 'parchment'
        description 'Runs the Enigma mapping tool.'

        classpath project.configurations.enigma
        mainClass.set 'org.quiltmc.enigma.gui.Main'

        args = ['--no-edit-all', '--edit-parameters', '--edit-javadocs']
        argumentProviders.add({ ->
            ['--jar', inputJar.get().asFile.absolutePath,
             '--mappings', mappings.get().asFile.absolutePath]
        } as CommandLineArgumentProvider)

        // Enigma runs on Java 17. If the Gradle JVM supports Java 17, then we are fine
        // If not, then we set the java launcher via JVM toolchain so Gradle downloads a Java 17 JVM
        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
            javaLauncher.set project.javaToolchains.launcherFor {
                languageVersion = JavaLanguageVersion.of(17)
            } as Provider<JavaLauncher>
        }
    }
}