Adjust remapping+publishing

convention/src/main/kotlin/jf.autoversion.gradle.kts

@@ -28,7 +28,7 @@ if (File(projectDir, ".git").exists()) {
         }
     }
 }
-if (changelog == "") changelog = "No io.gitlab.jfronny.scripts.getChangelog"
+if (changelog == "") changelog = "No changelog"
 
 val timestamp: Long = if (project.hasProperty("timestamp")) "${project.property("timestamp")}".toLong()
 else (System.currentTimeMillis() / 1000L)

lom/src/main/kotlin/io/gitlab/jfronny/lom/LomPlugin.kt

@@ -5,6 +5,7 @@ import io.gitlab.jfronny.convention.ext.deployDebug
 import io.gitlab.jfronny.convention.ext.versionS
 import io.gitlab.jfronny.lom.ext.*
 import io.gitlab.jfronny.lom.ext.registering
+import net.fabricmc.loom.task.PrepareJarRemapTask
 import net.fabricmc.loom.task.RemapJarTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -22,9 +23,20 @@ class LomPlugin : Plugin<Project> {
 
     private fun Project.applyLom() {
         val devlibs = File(project.buildDir, "devlibs")
-        val args = AfterEvaluateArgs(extensions.create("lom"), null, null)
+        val args = extensions.create<LomExtension>("lom")
 
-        afterEvaluate { lomAfterEvaluate(args) } // Needs to be registered before loom to properly set things up
+        afterEvaluate {
+            // Needs to be registered before loom to properly set things up
+            dependencies {
+                minecraft("com.mojang:minecraft:${args.minecraftVersion.get()}")
+                if (args.yarnBuild != null) mappings("net.fabricmc:yarn:${args.minecraftVersion.get()}+${args.yarnBuild}:v2")
+                else loom.officialMojangMappings()
+                modImplementation("net.fabricmc:fabric-loader:${args.loaderVersion.get()}")
+
+                testmodImplementation(sourceSets.main.output)
+                testmodImplementation(sourceSets.client.output)
+            }
+        }
 
         apply(plugin = "idea")
         apply(plugin = "java-library")
@@ -87,14 +99,14 @@ class LomPlugin : Plugin<Project> {
 
         val inputTask: Jar = tasks.findByName("injectCompiledConfig") as Jar? ?: tasks.jar
 
-        val completeJar by tasks.registering(ShadowJar::class) {
+        tasks.shadow {
             dependsOn(inputTask)
             configurations.clear()
-            configurations.add(project.configurations.shadow)
+            from(project.configurations.shadow, tasks.jar.archiveFile.get())
             archiveClassifier.set("shadow")
             destinationDirectory.set(devlibs)
         }
-        args.completeJar = completeJar
+        val completeJar = tasks.shadow
 
         artifacts.add("dev", tasks.jar.archiveFile.get().asFile) {
             type = "jar"
@@ -112,10 +124,10 @@ class LomPlugin : Plugin<Project> {
 
         val remapMavenJar by tasks.registering(RemapJarTask::class) {
             dependsOn(completeJar)
-            archiveFileName.set("$archiveBaseName-${project.versionS}-maven.jar")
+            inputFile.set(completeJar.archiveFile.get())
+            archiveFileName.set("${archiveBaseName.get()}-${project.versionS}-maven.jar")
             addNestedDependencies.set(false)
         }
-        args.remapMavenJar = remapMavenJar
         tasks.assemble.dependsOn(remapMavenJar)
 
         val testmodJar by tasks.registering(Jar::class) { //TODO include deps
@@ -126,38 +138,16 @@ class LomPlugin : Plugin<Project> {
 
         val remapTestmodJar by tasks.registering(RemapJarTask::class) {
             dependsOn(testmodJar)
-            inputFile.set(testmodJar.archiveFile)
+            inputFile.set(testmodJar.archiveFile.get())
             archiveClassifier.set("testmod")
             addNestedDependencies.set(false)
         }
         tasks.assemble.dependsOn(remapTestmodJar)
-    }
-
-    private fun Project.lomAfterEvaluate(args: AfterEvaluateArgs) {
-        val extension = args.extension
-        val completeJar = args.completeJar!!
-        val remapMavenJar = args.remapMavenJar!!
-
-        tasks.withType<JavaCompile>().configureEach {
-            options.encoding = "UTF-8"
-            options.release.set(17)
-        }
-
-        dependencies {
-            minecraft("com.mojang:minecraft:${extension.minecraftVersion.get()}")
-            if (extension.yarnBuild != null) mappings("net.fabricmc:yarn:${extension.minecraftVersion.get()}+${extension.yarnBuild}:v2")
-            else loom.officialMojangMappings()
-            modImplementation("net.fabricmc:fabric-loader:${extension.loaderVersion.get()}")
-
-            testmodImplementation(sourceSets.main.output)
-            testmodImplementation(sourceSets.client.output)
-        }
 
         tasks.remapJar {
             dependsOn(completeJar)
-
-            inputFile.set(completeJar.archiveFile)
-            archiveFileName.set("$archiveBaseName-${project.versionS}.jar")
+            inputFile.set(completeJar.archiveFile.get())
+            archiveFileName.set("${archiveBaseName.get()}-${project.versionS}.jar")
         }
 
         tasks.processResources {
@@ -169,19 +159,30 @@ class LomPlugin : Plugin<Project> {
         publishing {
             publications {
                 create<MavenPublication>("mavenJava") {
-                    artifact(remapMavenJar) {
-                        builtBy(remapMavenJar)
-                    }
-
-                    artifact(tasks.sourcesJar) {
-                        builtBy(tasks.remapSourcesJar)
-                    }
+                    from(components["java"])
+                    setArtifacts(listOf(remapMavenJar, tasks.sourcesJar))
                 }
             }
         }
         tasks.publish.dependsOn(tasks.build)
         tasks.deployDebug.dependsOn(tasks.publish)
-    }
 
-    private data class AfterEvaluateArgs(val extension: LomExtension, var completeJar: ShadowJar?, var remapMavenJar: RemapJarTask?)
+        afterEvaluate {
+            tasks.withType<JavaCompile>().configureEach {
+                options.encoding = "UTF-8"
+                options.release.set(17)
+            }
+            
+            // Fix prepareRemapJar
+            // Finds remapJar tasks and the corresponding prepareRemapJar tasks and ensures the dependencies of remapJar are run before prepareRemapJar
+            // This ensures the input files exist when the task is run
+            tasks.configureEach {
+                if (this is RemapJarTask) {
+                    this.dependsOn.filterIsInstance<PrepareJarRemapTask>().forEach { prepareTask ->
+                        prepareTask.dependsOn(*this.dependsOn.filter { it != prepareTask }.toTypedArray())
+                    }
+                }
+            }
+        }
+    }
 }

lom/src/main/kotlin/io/gitlab/jfronny/lom/ext/LoomExt.kt

@@ -2,6 +2,7 @@ package io.gitlab.jfronny.lom.ext
 
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import net.fabricmc.loom.task.GenerateSourcesTask
+import net.fabricmc.loom.task.PrepareJarRemapTask
 import net.fabricmc.loom.task.RemapJarTask
 import net.fabricmc.loom.task.RemapSourcesJarTask
 import net.fabricmc.loom.task.UnpickJarTask

lom/src/main/kotlin/io/gitlab/jfronny/lom/ext/ShadowExt.kt

@@ -1,6 +1,12 @@
 package io.gitlab.jfronny.lom.ext
 
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ConfigurationContainer
+import org.gradle.api.tasks.TaskContainer
+import org.gradle.kotlin.dsl.named
 
-val ConfigurationContainer.shadow: Configuration get() = named("shadow").get()
+val ConfigurationContainer.shadow: Configuration get() = named("shadow").get()
+
+val TaskContainer.shadow: ShadowJar get() = named<ShadowJar>("shadowJar").get()
+fun TaskContainer.shadow(configure: ShadowJar.() -> Unit) = named<ShadowJar>("shadowJar").configure(configure)