Merge pull request #180 from refinedmods/feat/GH-176/config-cache

Config cache support

Author: raoulvdberge

.github/workflows/publish-release.yml

@@ -162,7 +162,7 @@ jobs:
       - name: Setup Java
         uses: refinedmods/refinedarchitect/.github/actions/setup-java@develop
       - name: Deploy to CurseForge
-        run: ./gradlew publishCurseForge
+        run: ./gradlew publishCurseforge
 
   deploy-modrinth:
     name: Deploy to Modrinth
@@ -179,7 +179,7 @@ jobs:
       - name: Setup Java
         uses: refinedmods/refinedarchitect/.github/actions/setup-java@develop
       - name: Deploy to Modrinth
-        run: ./gradlew modrinth
+        run: ./gradlew publishModrinth
 
   announce-discord:
     name: Announce to Discord

CHANGELOG.md

@@ -7,6 +7,14 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+-   Support for the Gradle config cache.
+
+### Changed
+
+-   The CurseForge and Modrinth publishing has been updated to use modmuss' mod-publish-plugin.
+
 ## [0.18.0] - 2024-09-09
 
 ### Fixed

gradle.properties

@@ -1,2 +1,6 @@
 # Gradle
 org.gradle.jvmargs=-Xmx1G
+org.gradle.configureondemand=true
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+org.gradle.configuration-cache.problems=warn

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

refinedarchitect-plugin/build.gradle.kts

@@ -25,13 +25,12 @@ repositories {
 }
 
 dependencies {
-    implementation("net.neoforged:moddev-gradle:2.0.5-beta")
-    implementation("fabric-loom:fabric-loom.gradle.plugin:1.7-SNAPSHOT")
+    implementation("net.neoforged:moddev-gradle:2.0.27-beta")
+    implementation("fabric-loom:fabric-loom.gradle.plugin:1.8.0-alpha.9")
     implementation("gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.1.8")
     implementation("info.solidsoft.gradle.pitest:gradle-pitest-plugin:1.15.0")
     implementation("org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:4.4.1.3373")
-    implementation("net.darkhax.curseforgegradle:CurseForgeGradle:1.1.18")
-    implementation("com.modrinth.minotaur:Minotaur:2.8.7")
+    implementation("me.modmuss50:mod-publish-plugin:0.7.3")
 }
 
 publishing {

refinedarchitect-plugin/src/main/kotlin/BaseExtension.kt

@@ -1,13 +1,15 @@
-import com.modrinth.minotaur.Minotaur
-import com.modrinth.minotaur.ModrinthExtension
 import info.solidsoft.gradle.pitest.PitestPlugin
 import info.solidsoft.gradle.pitest.PitestPluginExtension
-import net.darkhax.curseforgegradle.TaskPublishCurseForge
+import me.modmuss50.mpp.ModPublishExtension
+import me.modmuss50.mpp.MppPlugin
+import me.modmuss50.mpp.ReleaseType
+import net.fabricmc.loom.task.RemapJarTask
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.*
 import org.sonarqube.gradle.SonarExtension
 import org.sonarqube.gradle.SonarQubePlugin
@@ -25,49 +27,50 @@ open class BaseExtension(private val project: Project) {
         if (options.maven == true) {
             enableMavenPublishing()
         }
-        options.curseForge?.let { enableCurseForgePublishing(it) }
-        options.modrinth?.let { enableModrinthPublishing(it) }
-    }
-
-    private fun enableCurseForgePublishing(projectId: String) {
-        project.tasks.register<TaskPublishCurseForge>("publishCurseForge") {
-            apiToken = System.getenv("CURSEFORGE_TOKEN")
-            val isNeoForge = project.pluginManager.hasPlugin("net.neoforged.moddev")
-            val mainFile = upload(projectId, project.tasks.getByName(if (isNeoForge) "jar" else "remapJar"))
-            mainFile.releaseType = if (project.version.toString().contains("beta")) "beta" else if (project.version.toString().contains("alpha")) "alpha" else "release"
-            mainFile.changelog = System.getenv("RELEASE_CHANGELOG")
-            mainFile.changelogType = "markdown"
-            mainFile.displayName = "v" + project.version.toString()
-            mainFile.addGameVersion(mcVersion)
-            // https://github.com/refinedmods/refinedarchitect/issues/149
-            if (isNeoForge) {
-                mainFile.addModLoader("NeoForge")
-            } else {
-                mainFile.addRequirement("fabric-api")
-            }
-        }
-    }
-
-    private fun enableModrinthPublishing(projId: String) {
-        project.plugins.apply(Minotaur::class.java)
-        val isNeoForge = project.pluginManager.hasPlugin("net.neoforged.moddev")
-        project.extensions.getByType<ModrinthExtension>().apply {
-            token.set(System.getenv("MODRINTH_TOKEN"))
-            projectId.set(projId)
-            uploadFile = project.tasks.getByName(if (isNeoForge) "jar" else "remapJar")
-            versionType.set(if (project.version.toString().contains("beta")) "beta" else if (project.version.toString().contains("alpha")) "alpha" else "release")
-            versionNumber.set(project.version.toString())
-            versionName.set("v" + project.version)
-            // https://github.com/refinedmods/refinedarchitect/issues/149
-            if (isNeoForge) {
-                loaders.add("neoforge")
-                gameVersions.add(mcVersion)
-            } else {
-                dependencies.apply {
-                    required.project("fabric-api")
+        if (options.curseForge != null || options.modrinth != null) {
+            project.plugins.apply(MppPlugin::class)
+            project.extensions.getByType(ModPublishExtension::class).apply {
+                val isNeoForge = project.pluginManager.hasPlugin("net.neoforged.moddev")
+                if (isNeoForge) {
+                    val jar by project.tasks.getting(Jar::class)
+                    file.set(jar.archiveFile)
+                    modLoaders.add("NeoForge")
+                } else {
+                    val remapJar by project.tasks.getting(RemapJarTask::class)
+                    file.set(remapJar.archiveFile)
+                    modLoaders.add("Fabric")
+                }
+                type.set(
+                    if (project.version.toString()
+                            .contains("beta")
+                    ) ReleaseType.BETA else if (project.version.toString()
+                            .contains("alpha")
+                    ) ReleaseType.ALPHA else ReleaseType.STABLE
+                )
+                changelog.set(System.getenv("RELEASE_CHANGELOG"))
+                displayName.set("v" + project.version.toString())
+                options.curseForge?.let {
+                    curseforge {
+                        accessToken.set(System.getenv("CURSEFORGE_TOKEN"))
+                        minecraftVersions.add(mcVersion)
+                        changelogType.set("markdown")
+                        projectId.set(it)
+                        if (!isNeoForge) {
+                            requires("fabric-api")
+                        }
+                    }
+                }
+                options.modrinth?.let {
+                    modrinth {
+                        accessToken.set(System.getenv("MODRINTH_TOKEN"))
+                        projectId.set(it)
+                        minecraftVersions.add(mcVersion)
+                        if (!isNeoForge) {
+                            requires("fabric-api")
+                        }
+                    }
                 }
             }
-            changelog.set(System.getenv("RELEASE_CHANGELOG"))
         }
     }
 
@@ -81,7 +84,7 @@ open class BaseExtension(private val project: Project) {
             coverageThreshold.set(80)
         }
         project.dependencies.add("testRuntimeOnly", "org.junit.platform:junit-platform-launcher")
-                ?.because("required for pitest")
+            ?.because("required for pitest")
     }
 
     fun testing() {
@@ -131,7 +134,10 @@ open class BaseExtension(private val project: Project) {
                 property("sonar.projectKey", projectKey)
                 property("sonar.organization", organization)
                 property("sonar.host.url", "https://sonarcloud.io")
-                property("sonar.coverage.jacoco.xmlReportPaths", "${project.layout.buildDirectory.get()}/reports/jacoco/codeCoverageReportAggregate/codeCoverageReportAggregate.xml")
+                property(
+                    "sonar.coverage.jacoco.xmlReportPaths",
+                    "${project.layout.buildDirectory.get()}/reports/jacoco/codeCoverageReportAggregate/codeCoverageReportAggregate.xml"
+                )
             }
         }
     }

refinedarchitect-plugin/src/main/kotlin/FabricExtension.kt

@@ -1,6 +1,5 @@
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.get
@@ -56,6 +55,11 @@ open class FabricExtension(private val project: Project) : BaseExtension(project
             source(project.configurations["commonJava"])
         }
         project.tasks.withType<ProcessResources>().configureEach {
+            val properties = mapOf("version" to project.version)
+            inputs.properties(properties)
+            filesMatching(listOf("fabric.mod.json")) {
+                expand(properties)
+            }
             dependsOn(project.configurations["commonResources"])
             from(project.configurations["commonResources"])
         }

refinedarchitect-plugin/src/main/kotlin/NeoForgeExtension.kt

@@ -4,9 +4,10 @@ import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.tasks.Jar
 import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.withType
 import org.gradle.language.jvm.tasks.ProcessResources
-import net.neoforged.moddevgradle.dsl.NeoForgeExtension as NfExtension
+import net.neoforged.moddevgradle.dsl.NeoForgeExtension as NeoForge
 
 open class NeoForgeExtension(private val project: Project) : BaseExtension(project) {
     var modId: String? = null
@@ -17,7 +18,16 @@ open class NeoForgeExtension(private val project: Project) : BaseExtension(proje
         project.configurations["commonJava"].isCanBeConsumed = modId == null
         project.configurations["commonResources"].isCanBeResolved = true
         project.configurations["commonResources"].isCanBeConsumed = modId == null
-        project.extensions.getByType<NfExtension>().apply {
+        val generateModMetadata = project.tasks.register("generateModMetadata", ProcessResources::class) {
+            val properties = mapOf("version" to project.version)
+            inputs.properties(properties)
+            expand(properties)
+            from("src/main/templates")
+            into("build/generated/sources/modMetadata")
+        }
+        sourceSets["main"].resources.srcDir(generateModMetadata)
+        sourceSets["main"].resources.srcDirs.add(project.file("src/generated/resources"))
+        project.extensions.getByType<NeoForge>().apply {
             version.set(neoForgeVersion)
             addModdingDependenciesTo(sourceSets["test"])
             if (modId != null) {
@@ -40,15 +50,17 @@ open class NeoForgeExtension(private val project: Project) : BaseExtension(proje
                 minecraftVersion.set(parchmentMcVersion)
                 mappingsVersion.set(parchmentVersion)
             }
+            ideSyncTask(generateModMetadata)
         }
-        sourceSets["main"].resources.srcDirs.add(project.file("src/generated/resources"))
         project.tasks.withType<JavaCompile>().configureEach {
             dependsOn(project.configurations["commonJava"])
             source(project.configurations["commonJava"])
         }
         project.tasks.withType<ProcessResources>().configureEach {
-            dependsOn(project.configurations["commonResources"])
-            from(project.configurations["commonResources"])
+            if (name != "generateModMetadata") {
+                dependsOn(project.configurations["commonResources"])
+                from(project.configurations["commonResources"])
+            }
         }
         project.tasks.withType<Jar>().configureEach {
             from("../LICENSE.md")
@@ -58,7 +70,7 @@ open class NeoForgeExtension(private val project: Project) : BaseExtension(proje
     fun gameTests() {
         project.dependencies.add("testImplementation", "net.neoforged:testframework:${neoForgeVersion}")
         val sourceSets = project.extensions.getByType<JavaPluginExtension>().sourceSets
-        project.extensions.getByType<NfExtension>().apply {
+        project.extensions.getByType<NeoForge>().apply {
             runs {
                 register("gameTestServer") {
                     type.set("gameTestServer")
@@ -74,7 +86,7 @@ open class NeoForgeExtension(private val project: Project) : BaseExtension(proje
     }
 
     fun dataGeneration(sourceProject: Project = project) {
-        project.extensions.getByType<NfExtension>().apply {
+        project.extensions.getByType<NeoForge>().apply {
             runs {
                 create("data") {
                     data()

refinedarchitect-plugin/src/main/kotlin/refinedarchitect.gradle.kts

@@ -52,14 +52,6 @@ checkstyle {
     toolVersion = "10.17.0"
 }
 
-tasks.withType<ProcessResources> {
-    inputs.property("version", project.version)
-
-    filesMatching(listOf("fabric.mod.json", "META-INF/neoforge.mods.toml")) {
-        expand("version" to project.version)
-    }
-}
-
 artifacts {
     add("commonJava", sourceSets["main"].java.sourceDirectories.singleFile)
     add("commonResources", sourceSets["main"].resources.sourceDirectories.singleFile)