fix: glue for forge, automatic loader kind recognition and no split sources on forge unfortunately

jfmod/src/main/kotlin/io/gitlab/jfronny/scripts/JfModExtension.kt

@@ -23,8 +23,9 @@ interface JfModExtension: LomExtension {
     }
 
     fun isMod(proj: Project) = proj.extensions.findByName("jfModule") != null
-    fun isFabric(proj: Project) = (proj.extensions.findByName("lom") as? LomExtension)?.isFabric ?: false
+    fun isFabric(proj: Project) = if (proj == this) isFabric else (proj.extensions.findByName("lom") as? LomExtension)?.isFabric ?: false
-    fun isForge(proj: Project) = (proj.extensions.findByName("lom") as? LomExtension)?.isForge ?: false
+    fun isForge(proj: Project) = if (proj == this) isForge else (proj.extensions.findByName("lom") as? LomExtension)?.isNeoForge ?: false
+    fun isNeoForge(proj: Project) = if (proj == this) isNeoForge else (proj.extensions.findByName("lom") as? LomExtension)?.isNeoForge ?: false
     fun curseforge(closure: Action<CurseForge>) = closure.execute(curseforge)
     fun modrinth(closure: Action<Modrinth>) = closure.execute(modrinth)
 

jfmod/src/main/kotlin/jfmod.module.gradle.kts

@@ -20,7 +20,7 @@ insertEarlyAfterEvaluate {
 
     if (!isRoot) versionS = rootProject.versionS
 
-    if (!hasProperty("loom.platform")) {
+    if (rootArgs.loaderKind.get() == lomArgs.loaderKind.get()) {
         // Platform is set manually. User will need to configure lom themselves too
         lom {
             copyFrom(rootArgs)

lom/src/main/kotlin/io/gitlab/jfronny/scripts/LoaderKind.kt

@@ -0,0 +1,11 @@
+package io.gitlab.jfronny.scripts
+
+import java.util.*
+
+enum class LoaderKind {
+    NEOFORGE, FORGE, FABRIC;
+
+    companion object {
+        fun fromString(str: String) = valueOf(str.uppercase(Locale.getDefault()))
+    }
+}

lom/src/main/kotlin/io/gitlab/jfronny/scripts/LomExt.kt

@@ -22,5 +22,6 @@ val TaskContainer.sourcesJar get() = named<Jar>("sourcesJar")
 
 fun DependencyHandler.devProject(path: String): Dependency = project(path, "dev")
 
-val LomExtension.isFabric: Boolean get() = fabricLoaderVersion.isPresent
+val LomExtension.isFabric: Boolean get() = loaderKind.get() == LoaderKind.FABRIC
-val LomExtension.isForge: Boolean get() = neoforgeVersion.isPresent
+val LomExtension.isForge: Boolean get() = loaderKind.get() == LoaderKind.FORGE
+val LomExtension.isNeoForge: Boolean get() = loaderKind.get() == LoaderKind.NEOFORGE

lom/src/main/kotlin/io/gitlab/jfronny/scripts/LomExtension.kt

@@ -5,6 +5,9 @@ import org.gradle.api.provider.Property
 import java.util.*
 
 interface LomExtension {
+    val loaderKind: Property<LoaderKind>
+    val minecraftVersion: Property<String>
+    val loaderVersion: Property<String>
     val yarnBuild: Property<String>
 
     fun yarn(yarnBuild: String) {
@@ -15,23 +18,19 @@ interface LomExtension {
         yarnBuild.set(null)
     }
 
-    val minecraftVersion: Property<String>
-    val fabricLoaderVersion: Property<String>
-    val neoforgeVersion: Property<String>
-
     fun check(proj: Project) {
         yarnBuild.finalizeValue()
         minecraftVersion.finalizeValue()
-        fabricLoaderVersion.finalizeValue()
+        loaderVersion.finalizeValue()
-        neoforgeVersion.finalizeValue()
+        loaderKind.finalizeValue()
-        require(!(fabricLoaderVersion.isPresent && neoforgeVersion.isPresent)) { "fabricLoaderVersion and forgeVersion are mutually exclusive" }
-        require(fabricLoaderVersion.isPresent || neoforgeVersion.isPresent) { "fabricLoaderVersion or forgeVersion must be set" }
     }
 
     fun copyFrom(ext: LomExtension) {
+        if (loaderKind != ext.loaderKind) {
+            throw IllegalArgumentException("Cannot copy from a config meant for a different loader")
+        }
         yarnBuild.set(ext.yarnBuild)
         minecraftVersion.set(ext.minecraftVersion)
-        fabricLoaderVersion.set(ext.fabricLoaderVersion)
+        loaderVersion.set(ext.loaderVersion)
-        neoforgeVersion.set(ext.neoforgeVersion)
     }
 }

lom/src/main/kotlin/lom.gradle.kts

@@ -13,10 +13,16 @@ plugins {
 
 val devlibs = project.layout.buildDirectory.dir("devlibs").get().asFile
 
+// Register lom extension with recognised loom platform
+val args = extensions.create<LomExtension>("lom")
+args.loaderKind = LoaderKind.fromString(prop("loom.platform", "fabric"))
+args.loaderKind.finalizeValue()
+
 // Configure loom for stricter dev env
 loom {
     runtimeOnlyLog4j.set(true)
-    splitEnvironmentSourceSets()
+    // Other loaders unfortunately don't support this yet
+    if (args.isFabric) splitEnvironmentSourceSets()
     silentMojangMappingsLicense()
 }
 
@@ -78,18 +84,23 @@ repositories {
 }
 
 // Register common dependencies
-val args = extensions.create<LomExtension>("lom")
 earlyAfterEvaluate {
     args.check(this)
     dependencies {
         minecraft("com.mojang:minecraft:${args.minecraftVersion.get()}")
         if (args.yarnBuild.isPresent) mappings("net.fabricmc:yarn:${args.minecraftVersion.get()}+${args.yarnBuild.get()}:v2")
         else loom.officialMojangMappings()
-        if (!hasProperty("loom.platform") || property("loom.platform") == "fabric") {
+        when (args.loaderKind.get()) {
-            modImplementation("net.fabricmc:fabric-loader:${args.fabricLoaderVersion.get()}")
+            LoaderKind.NEOFORGE -> {
-            testImplementation("net.fabricmc:fabric-loader-junit:${args.fabricLoaderVersion.get()}")
+                "neoForge"("net.neoforged:neoforge:${args.loaderVersion.get()}")
-        } else if (property("loom.platform") == "neoforge") {
+            }
-            "neoForge"("net.minecraftforge:forge:${args.minecraftVersion.get()}-${args.neoforgeVersion.get()}")
+            LoaderKind.FORGE -> {
+                "forge"("net.minecraftforge:forge:${args.minecraftVersion.get()}-${args.loaderVersion.get()}")
+            }
+            LoaderKind.FABRIC -> {
+                modImplementation("net.fabricmc:fabric-loader:${args.loaderVersion.get()}")
+                testImplementation("net.fabricmc:fabric-loader-junit:${args.loaderVersion.get()}")
+            }
         }
 
         testmodImplementation(sourceSets.main.get().output)