build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.ow2.asm:asm:9.7'
        classpath 'org.ow2.asm:asm-tree:9.7'
    }
}

plugins {
    id 'java'
    id 'idea'
    id 'eclipse'
    id 'maven-publish'
    id 'net.minecraftforge.licenser' version '1.0.1'
    id 'net.minecraftforge.gradleutils' version '[2.3,2.4)'
}

group = 'net.minecraftforge'
archivesBaseName = 'srg2source'
version = gradleutils.tagOffsetVersion
println('Version: ' + version)

java {
    toolchain.languageVersion = JavaLanguageVersion.of(17)
    withSourcesJar()
}

configurations {
    shadow
    implementation.extendsFrom shadow
}

repositories {
    //mavenLocal()
    maven gradleutils.forgeMaven
    mavenCentral()
}

dependencies {
    implementation(libs.securemodules)
    implementation(libs.nulls)
    shadow(libs.bundles.asm)
    shadow(libs.jopt.simple) // easy CLI parsing
    shadow(libs.srgutils) //Because tons of projects all parsing SRG files is annoying
    shadow(libs.bundles.eclipse) // necessary eclipse AST stuff
    implementation(libs.ml) // We need to patch eclipse to allow sources from more then raw files

    testImplementation(libs.junit.api)
    testImplementation(libs.jimfs)
    testRuntimeOnly(libs.bundles.junit.runtime)
}

changelog {
    from '8.0'
}

tasks.named('jar', Jar).configure {
    exclude 'data/**'
    manifest {
        attributes([
            'Automatic-Module-Name': 'net.minecraftforge.srg2source',
            'Main-Class': 'net.minecraftforge.srg2source.ConsoleTool'
        ] as LinkedHashMap)
        attributes([
            'Specification-Title':   'Srg2Source',
            'Specification-Vendor':  'Forge Development LLC',
            'Specification-Version':  gradleutils.gitInfo.tag,
            'Implementation-Title':  'Srg2Source',
            'Implementation-Vendor': 'Forge Development LLC',
            'Implementation-Version': project.version
        ] as LinkedHashMap, 'net/minecraftforge/srg2source/')
    }
}

tasks.register('shadowJarPatched', Jar).configure {
    dependsOn patchJDT
    archiveClassifier = 'fatjar'
    manifest = jar.manifest
    
    from(zipTree(patchJDT.output))
    from(sourceSets.main.output) {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }
  
    from { configurations.shadow.collect { it.isDirectory() ? it : zipTree(it) } } {
        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    }
    exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA', 'module-info.class')
}

license {
    header = file('LICENSE-header.txt')
    include 'net/minecraftforge/'
}

import java.util.zip.*
import org.objectweb.asm.*
import org.objectweb.asm.tree.*

//TODO: Eclipse complains about unused messages. Find a way to make it shut up.
abstract class PatchJDTClasses extends DefaultTask {
    static def COMPILATION_UNIT_RESOLVER = 'org/eclipse/jdt/core/dom/CompilationUnitResolver'
    static def RANGE_EXTRACTOR = 'net/minecraftforge/srg2source/extract/RangeExtractor'
    static def RESOLVE_METHOD = 'resolve([Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;Lorg/eclipse/jdt/core/dom/FileASTRequestor;ILjava/util/Map;I)V'
    static def GET_CONTENTS = 'org/eclipse/jdt/internal/compiler/util/Util.getFileCharContent(Ljava/io/File;Ljava/lang/String;)[C'
    static def HOOK_DESC_RESOLVE = '(Ljava/lang/String;Ljava/lang/String;)[C'

    @Input abstract SetProperty<String> getTargets()
    @InputFiles @Classpath abstract ConfigurableFileCollection getLibraries()
    @OutputFile abstract RegularFileProperty getOutput()

    @TaskAction
    void patchClass() {
        def toProcess = targets.get().collect()
        new ZipOutputStream(new FileOutputStream(output.get().getAsFile())).withCloseable{ zout ->
            libraries.getFiles().stream().filter{ !it.isDirectory() }.each { lib ->
                new ZipFile(lib).withCloseable { zin ->
                    def remove = []
                    toProcess.each{ target ->
                        def entry = zin.getEntry(target+'.class')
                        if (entry == null)
                            return

                        def node = new ClassNode()
                        def reader = new ClassReader(zin.getInputStream(entry))
                        reader.accept(node, 0)

                        //CompilationUnitResolver allows batch compiling, the problem is it is hardcoded to read the contents from a File.
                        //So we patch this call to redirect to us, so we can get the contents from our InputSupplier
                        if (COMPILATION_UNIT_RESOLVER.equals(target)) {
                            logger.lifecycle('Transforming: ' + target + ' From: ' + lib)
                            def resolve = node.methods.find{ RESOLVE_METHOD.equals(it.name + it.desc) }
                            if (resolve == null)
                                throw new RuntimeException('Failed to patch ' + target + ': Could not find method ' + RESOLVE_METHOD)
                            for (int x = 0; x < resolve.instructions.size(); x++) {
                                def insn = resolve.instructions.get(x)
                                if (insn.type == AbstractInsnNode.METHOD_INSN) {
                                    if (GET_CONTENTS.equals(insn.owner + '.' + insn.name + insn.desc)) {
                                        if (
                                            resolve.instructions.get(x - 5).opcode == Opcodes.NEW &&
                                            resolve.instructions.get(x - 4).opcode == Opcodes.DUP &&
                                            resolve.instructions.get(x - 3).opcode == Opcodes.ALOAD &&
                                            resolve.instructions.get(x - 2).opcode == Opcodes.INVOKESPECIAL &&
                                            resolve.instructions.get(x - 1).opcode == Opcodes.ALOAD
                                        ) {
                                            resolve.instructions.set(resolve.instructions.get(x - 5), new InsnNode(Opcodes.NOP)); // NEW File
                                            resolve.instructions.set(resolve.instructions.get(x - 4), new InsnNode(Opcodes.NOP)); // DUP
                                            resolve.instructions.set(resolve.instructions.get(x - 2), new InsnNode(Opcodes.NOP)); // INVOKESTATIC <init>
                                            insn.owner = RANGE_EXTRACTOR
                                            insn.desc = HOOK_DESC_RESOLVE
                                            //logger.lifecycle('Patched ' + node.name)
                                            remove.add(target)
                                        } else {
                                            throw new IllegalStateException('Found Util.getFileCharContents call, with unexpected context')
                                        }
                                    }
                                }
                            }
                        } else if (RANGE_EXTRACTOR.equals(target)) {
                            logger.lifecycle('Tansforming: ' + target + ' From: ' + lib)
                            def marker = node.methods.find{ 'hasBeenASMPatched()Z'.equals(it.name + it.desc) }
                            if (marker == null)
                                throw new RuntimeException('Failed to patch ' + target + ': Could not find method hasBeenASMPatched()Z')
                            marker.instructions.clear()
                            marker.instructions.add(new InsnNode(Opcodes.ICONST_1))
                            marker.instructions.add(new InsnNode(Opcodes.IRETURN))
                            //logger.lifecycle('Patched: ' + node.name)
                            remove.add(target)
                        }

                        def writer = new ClassWriter(0)
                        node.accept(writer)

                        def nentry = new ZipEntry(entry.name)
                        nentry.time = 0
                        zout.putNextEntry(nentry)
                        zout.write(writer.toByteArray())
                        zout.closeEntry()
                    }
                    toProcess.removeAll(remove)
                }
            }
            if (!toProcess.isEmpty())
                throw new IllegalStateException('Patching class failed: ' + toProcess)
        }
    }
}

tasks.register('unpatchedJar', Jar).configure {
    from sourceSets.main.output
    archiveClassifier = 'unpatched'
}

tasks.register('patchJDT', PatchJDTClasses).configure {
    targets.add(PatchJDTClasses.COMPILATION_UNIT_RESOLVER)
    targets.add(PatchJDTClasses.RANGE_EXTRACTOR)
    libraries.from(unpatchedJar.archiveFile)
    libraries.from(configurations.shadow.filter{ !it.isDirectory() })
    output = project.layout.buildDirectory.file("patch_jdt.jar")
}

publishing {
    publications.register('mavenJava', MavenPublication) {
        artifact jar
        artifact shadowJarPatched
        artifact sourcesJar
        pom {
            name = 'Srg2Source'
            description = 'Srg2Source library for ForgeGradle'
            url = 'https://github.com/MinecraftForge/Srg2Source'

            gradleutils.pom.setGitHubDetails(pom, 'Srg2Source')

            license gradleutils.pom.Licenses.LGPLv2_1

            developers {
                developer gradleutils.pom.Developers.LexManos
            }
        }
    }

    repositories {
        maven gradleutils.publishingForgeMaven
    }
}
// We need to write the manifest to the binary file so we have properly versioned packaged at dev time.
tasks.register('writeManifest') {
    doLast {
        if (plugins.findPlugin('net.minecraftforge.gradle.patcher')) // Forge project
            universalJar.manifest.writeTo(rootProject.file('src/main/resources/META-INF/MANIFEST.MF'))
        else
            jar.manifest.writeTo(project.file('src/main/resources/META-INF/MANIFEST.MF'))
    }
}

tasks.register('generateResources') {
    dependsOn('writeManifest')
}

// Make sure out manifests get written before compiling the code, IDEA calls this task if you tell it to use the gradle build.
tasks.withType(JavaCompile).configureEach {
    dependsOn 'generateResources'
    dependsOn 'processResources' // Needed because we merge the output of this with the output of the compile task. And gradle detects downstream tasks using the output without a hard dep
    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
    options.warnings = false // Shutup deprecated for removal warnings
}

// Merge the resources and classes into the same directory. We'll need to split them at runtime because
// Minecraft and Forge are in the same sourceSet as they are inter dependent.. for now..
sourceSets.each {
    def dir = layout.buildDirectory.dir("classes/java/$it.name")
    it.output.resourcesDir = dir
    it.java.destinationDirectory = dir
}

eclipse {
    // Run everytime eclipse builds the code
    //autoBuildTasks writeManifest
    // Run when importing the project
    synchronizationTasks generateResources, writeManifest
}