build.gradle

buildscript {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }

    dependencies {
        classpath("net.kyori:blossom:1.3.0")
        classpath("org.ow2.asm:asm:9.2")
    }
}

apply plugin: "java"
apply plugin: "net.kyori.blossom"
apply plugin: "signing"

sourceCompatibility = 1.8
targetCompatibility = 1.8

group = "io.github.lxgaming"
archivesBaseName = "_MixinBootstrap"
version = "1.1.1"

blossom {
    replaceToken("@version@", version)
}

configurations {
    compileJar {
        implementation.extendsFrom(compileJar)
    }

    // build.finalizedBy("signJar")
}

repositories {
    mavenCentral()
    maven {
        name = "minecraftforge"
        url = "https://maven.minecraftforge.net/"
    }
    maven {
        name = "spongepowered"
        url = "https://repo.spongepowered.org/repository/maven-public/"
    }
}

dependencies {
    compileOnly("com.google.code.findbugs:jsr305:3.0.2")
    compileOnly("cpw.mods:modlauncher:5.1.2")
    implementation("io.github.lxgaming:classloaderutils:1.0.0")
    compileOnly("net.sf.jopt-simple:jopt-simple:5.0.4")
    compileOnly("org.apache.logging.log4j:log4j-api:2.17.0")
    compileJar("org.ow2.asm:asm-analysis:6.2") {
        transitive = false
    }
    compileJar("org.ow2.asm:asm-util:6.2") {
        transitive = false
    }
    implementation("org.spongepowered:mixin:0.8.5") {
        transitive = false
    }
}

jar {
    dependsOn("patchMixinModule")
    duplicatesStrategy = DuplicatesStrategy.INCLUDE
    manifest {
        attributes(
                "Automatic-Module-Name": "mixinbootstrap",
                "TweakClass": "org.spongepowered.asm.launch.MixinTweaker",
                "TweakOrder": 0
        )
    }

    from ((configurations.runtimeClasspath - configurations.compileJar).findAll({
        it.isDirectory() || it.name.endsWith(".jar")
    }).collect({
        it.isDirectory() ? it : zipTree(it)
    })) {
        exclude("META-INF/services/cpw.mods.modlauncher.*")
        exclude("META-INF/services/org.spongepowered.asm.service.*")
        exclude("META-INF/*.RSA")
        exclude("META-INF/*.SF")
        exclude("module-info.class")
    }

    into ("META-INF/libraries") {
        from (configurations.compileJar.findAll({
            it.name.endsWith(".jar")
        }).collect({
            it
        }))
    }
}

java {
    disableAutoTargetJvm()
}

processResources {
    from("LICENSE")
    rename("LICENSE", "LICENSE-MixinBootstrap")
}

task signJar {
    doFirst {
        if (!project.hasProperty("signing.keyStorePath") || !project.hasProperty("signing.secretKeyRingFile")) {
            project.logger.warn("========== [WARNING] ==========")
            project.logger.warn("")
            project.logger.warn("   This build is not signed!   ")
            project.logger.warn("")
            project.logger.warn("========== [WARNING] ==========")
            throw new StopExecutionException()
        }
    }

    doLast {
        configurations.archives.allArtifacts.files.each {
            ant.signjar(
                jar: it,
                alias: project.property("signing.alias"),
                storepass: project.property("signing.keyStorePassword"),
                keystore: project.property("signing.keyStorePath"),
                keypass: project.property("signing.keyStorePassword"),
                preservelastmodified: project.property("signing.preserveLastModified"),
                tsaurl: project.property("signing.timestampAuthority"),
                digestalg: project.property("signing.digestAlgorithm")
            )
            project.logger.lifecycle("JAR Signed: ${it.name}")

            signing.sign(it)
            project.logger.lifecycle("PGP Signed: ${it.name}")
        }
    }
}

import java.util.zip.ZipFile
import org.objectweb.asm.ClassReader
import org.objectweb.asm.ClassVisitor
import org.objectweb.asm.ClassWriter
import org.objectweb.asm.ModuleVisitor
import org.objectweb.asm.Opcodes

task patchMixinModule {
    doLast {
        configurations.compileClasspath.asFileTree.filter({
            it.name.startsWith("mixin-")
        }).forEach({ file ->
            sourceSets.main.java.classesDirectory.get().file("module-info.class").asFile.withOutputStream { outputStream ->
                ZipFile zipFile = new ZipFile(file)
                ClassReader classReader = new ClassReader(zipFile.getInputStream(zipFile.getEntry("module-info.class")))
                ClassWriter classWriter = new ClassWriter(0)

                classReader.accept(new ClassVisitor(Opcodes.ASM9, classWriter) {
                    @Override
                    ModuleVisitor visitModule(String name, int access, String version) {
                        return new ModuleVisitor(Opcodes.ASM9, super.visitModule("io.github.lxgaming.mixin.launch", access, version)) {
                            @Override
                            void visitExport(String exportPackage, int exportAccess, String... modules) {
                            }
                            @Override
                            void visitProvide(String service, String... providers) {
                                // clean all mixin services
                                if (service == "cpw/mods/modlauncher/api/ITransformationService") {
                                    providers = ["io/github/lxgaming/mixin/launch/MixinTransformationService"]
                                }

                                super.visitProvide(service, providers)
                            }
                        }.with { moduleVisitor ->
                            moduleVisitor.visitRequire("jdk.unsupported", 0, null)
                            moduleVisitor
                        }
                    }
                }, 0)

                outputStream.write(classWriter.toByteArray())
            }
        })
    }
}