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 'org.parchmentmc.compass' version '0.8.1'
    id 'org.parchmentmc.writtenbooks' version '0.5.+'
    id 'maven-publish'
    id 'java-base'
}

group = 'org.parchmentmc.data'
def releaseType = project.findProperty('releaseType') ?: "local"
def date = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern('yyyy.MM.dd'))
def isRelease = releaseType.toString() == "release"
version = date + (isRelease ? '' : "-${releaseType}-SNAPSHOT")
def isBleeding = releaseType.toString() == "bleeding"
if (isBleeding) {
    version = "BLEEDING-SNAPSHOT"
}
println("Version: $version")

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

compass {
    version = '1.19.3'
}

repositories {
    maven {
        name = 'MinecraftForge'
        url = 'https://maven.minecraftforge.net/'
    }
    maven {
        name = 'FabricMC'
        url = 'https://maven.fabricmc.net/'
    }
}

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:0.1.24'

    // Enigma, pretty interface for editing mappings
    enigma 'cuchaz:enigma-swing:2.2.0'
}

afterEvaluate {
    def isCI = Boolean.parseBoolean(project.findProperty('isCI') as String)
    if (isCI) {
        println("Running on CI.")
        println("##teamcity[setParameter name='env.CI_VERSION' value='$version']")
        println("##teamcity[setParameter name='env.CI_GROUP' value='$group']")
        println("##teamcity[setParameter name='env.CI_ARTIFACT' value='parchment-${project.compass.version.get()}']")
        println("##teamcity[setParameter name='env.CI_GAME_VERSION' value='${project.compass.version.get()}']")
    }
}

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

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

    def 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.create('export', MavenPublication) { p ->
        p.artifact tasks.named("officialExportZip", Zip)
        p.artifact(tasks.named("officialSanitizedExportZip", Zip)) {
            classifier = 'checked'
        }
    }
    publications.create('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 'cuchaz.enigma.gui.Main'

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

        // Enigma 2.x 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>
        }
    }
}