Update Upstream

0036e06 Alter the CUI lifecycle to be more consistent and reliable (1633)

worldedit-fabric/build.gradle.kts

@@ -1,15 +1,33 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import net.fabricmc.loom.LoomGradleExtension
 import net.fabricmc.loom.task.RemapJarTask
 
+buildscript {
+    repositories {
+        mavenCentral()
+        maven {
+            name = "Fabric"
+            url = uri("https://maven.fabricmc.net/")
+        }
+    }
+    dependencies {
+        classpath("net.fabricmc:fabric-loom:${versions.loom}")
+    }
+}
+
 applyPlatformAndCoreConfiguration()
 applyShadowConfiguration()
 
 apply(plugin = "fabric-loom")
 apply(plugin = "java-library")
 
-val minecraftVersion = "1.15.2"
-val yarnMappings = "1.15.2+build.14:v2"
-val loaderVersion = "0.7.8+build.189"
+configure<LoomGradleExtension> {
+    accessWidener("src/main/resources/worldedit.accesswidener")
+}
+
+val minecraftVersion = "1.16.3"
+val yarnMappings = "1.16.3+build.1:v2"
+val loaderVersion = "0.10.8"
 
 configurations.all {
     resolutionStrategy {
@@ -17,32 +35,77 @@ configurations.all {
     }
 }
 
+val fabricApiConfiguration: Configuration = configurations.create("fabricApi")
+
+repositories {
+    maven {
+        name = "Fabric"
+        url = uri("https://maven.fabricmc.net/")
+    }
+}
+
 dependencies {
     "api"(project(":worldedit-core"))
-    "implementation"(enforcedPlatform("org.apache.logging.log4j:log4j-bom:2.8.1") {
-        because("Mojang provides Log4J at 2.8.1")
-    })
+    "implementation"("org.apache.logging.log4j:log4j-slf4j-impl:2.8.1")
 
     "minecraft"("com.mojang:minecraft:$minecraftVersion")
     "mappings"("net.fabricmc:yarn:$yarnMappings")
-    "modCompile"("net.fabricmc:fabric-loader:$loaderVersion")
+    "modImplementation"("net.fabricmc:fabric-loader:$loaderVersion")
 
-    listOf(
-        "net.fabricmc.fabric-api:fabric-api-base:0.1.2+28f8190f42",
-        "net.fabricmc.fabric-api:fabric-events-interaction-v0:0.2.6+12515ed975",
-        "net.fabricmc.fabric-api:fabric-events-lifecycle-v0:0.1.2+b7f9825de8",
-        "net.fabricmc.fabric-api:fabric-networking-v0:0.1.7+12515ed975"
-    ).forEach {
+    // [1] declare fabric-api dependency...
+    "fabricApi"("net.fabricmc.fabric-api:fabric-api:0.29.3+1.16")
+
+    // [2] Load the API dependencies from the fabric mod json...
+    @Suppress("UNCHECKED_CAST")
+    val fabricModJson = file("src/main/resources/fabric.mod.json").bufferedReader().use {
+        groovy.json.JsonSlurper().parse(it) as Map<String, Map<String, *>>
+    }
+    val wantedDependencies = (fabricModJson["depends"] ?: error("no depends in fabric.mod.json")).keys
+        .filter { it == "fabric-api-base" || it.contains(Regex("v\\d$")) }
+        .map { "net.fabricmc.fabric-api:$it" }
+    logger.lifecycle("Looking for these dependencies:")
+    for (wantedDependency in wantedDependencies) {
+        logger.lifecycle(wantedDependency)
+    }
+    // [3] and now we resolve it to pick out what we want :D
+    val fabricApiDependencies = fabricApiConfiguration.incoming.resolutionResult.allDependencies
+        .onEach {
+            if (it is UnresolvedDependencyResult) {
+                throw kotlin.IllegalStateException("Failed to resolve Fabric API", it.failure)
+            }
+        }
+        .filterIsInstance<ResolvedDependencyResult>()
+        // pick out transitive dependencies
+        .flatMap {
+            it.selected.dependencies
+        }
+        // grab the requested versions
+        .map { it.requested }
+        .filterIsInstance<ModuleComponentSelector>()
+        // map to standard notation
+        .associateByTo(
+            mutableMapOf(),
+            keySelector = { "${it.group}:${it.module}" },
+            valueTransform = { "${it.group}:${it.module}:${it.version}" }
+        )
+    fabricApiDependencies.keys.retainAll(wantedDependencies)
+    // sanity check
+    for (wantedDep in wantedDependencies) {
+        check(wantedDep in fabricApiDependencies) { "Fabric API library $wantedDep is missing!" }
+    }
+
+    fabricApiDependencies.values.forEach {
         "include"(it)
         "modImplementation"(it)
     }
 
+    // No need for this at runtime
+    "modCompileOnly"("me.lucko:fabric-permissions-api:0.1-SNAPSHOT")
+
     // Hook these up manually, because Fabric doesn't seem to quite do it properly.
-    "compileClasspath"("net.fabricmc:sponge-mixin:${project.versions.mixin}")
+    "compileOnly"("net.fabricmc:sponge-mixin:${project.versions.mixin}")
     "annotationProcessor"("net.fabricmc:sponge-mixin:${project.versions.mixin}")
     "annotationProcessor"("net.fabricmc:fabric-loom:${project.versions.loom}")
-
-    "testCompile"("org.mockito:mockito-core:3.11.0")
 }
 
 configure<BasePluginConvention> {
@@ -64,18 +127,17 @@ tasks.named<Copy>("processResources") {
     }
 }
 
-tasks.named<Jar>("jar") {
-    manifest {
-        attributes("Class-Path" to CLASSPATH,
-                   "WorldEdit-Version" to project.version)
-    }
-}
+addJarManifest(includeClasspath = true)
 
 tasks.named<ShadowJar>("shadowJar") {
     archiveClassifier.set("dist-dev")
     dependencies {
+        relocate("org.slf4j", "com.sk89q.worldedit.slf4j")
+        relocate("org.apache.logging.slf4j", "com.sk89q.worldedit.log4jbridge")
         relocate("org.antlr.v4", "com.sk89q.worldedit.antlr4")
 
+        include(dependency("org.slf4j:slf4j-api"))
+        include(dependency("org.apache.logging.log4j:log4j-slf4j-impl"))
         include(dependency("org.antlr:antlr4-runtime"))
     }
 }
@@ -95,6 +157,7 @@ tasks.register<RemapJarTask>("remapShadowJar") {
     input.set(shadowJar.archiveFile)
     archiveFileName.set(shadowJar.archiveFileName.get().replace(Regex("-dev\\.jar$"), ".jar"))
     addNestedDependencies.set(true)
+    remapAccessWidener.set(true)
 }
 
 tasks.named("assemble").configure {