Sync with Framework

.github/workflows/check-build.yml

@@ -5,14 +5,12 @@ on:
   push:
     paths: [
       '**src/**',
-      '**/*gradle*',
-      LICENSE
+      '**/*gradle*'
     ]
   pull_request:
     paths: [
       '**src/**',
-      '**/*gradle*',
-      LICENSE
+      '**/*gradle*'
     ]
   workflow_dispatch:
 

.github/workflows/release.yml

@@ -34,7 +34,8 @@ jobs:
         if: ${{ runner.os != 'Windows' }}
         run: chmod +x ./gradlew
       - name: Build
-        run: ./gradlew build neoforge:githubRelease neoforge:modrinth neoforge:curseforge fabric:githubRelease fabric:modrinth fabric:curseforge --stacktrace
+#        run: ./gradlew build neoforge:publishGithub fabric:publishGithub --stacktrace
+        run: ./gradlew build neoforge:publishGithub neoforge:publishModrinth neoforge:publishCurseforge fabric:publishGithub fabric:publishModrinth fabric:publishCurseforge --stacktrace
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.2
+
+- Updated to mc1.21.4

README.md

@@ -25,12 +25,10 @@ Adds a keybind to resend the previous message or command.
 
 </center></div>
 
-### License
-
-[Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0)
-
 ### Contact
 
 [![Discord Server](https://img.shields.io/discord/1103153365216669797?logo=discord&label=Discord%20Server&color=%235865F2)](https://discord.terminalmc.dev)
 
 [![GitHub Issues](https://img.shields.io/github/issues/TerminalMC/Resend?logo=github&label=GitHub%20Issues)](https://github.com/TerminalMC/Resend/issues)
+
+[![License](https://img.shields.io/github/license/TerminalMC/Resend?label=License&logo=github&logoColor=white)](https://github.com/TerminalMC/Resend/blob/HEAD/LICENSE.txt)

build.gradle

@@ -1,139 +1,158 @@
 plugins {
     id("fabric-loom") version("${loom_version}") apply(false)
     id("net.neoforged.moddev") version("${moddev_version}") apply(false)
-    id("com.modrinth.minotaur") version("${minotaur_version}")
-    id("net.darkhax.curseforgegradle") version("${curseforgegradle_version}")
-    id("com.github.breadmoirai.github-release") version("${githubrelease_version}")
+    id("me.modmuss50.mod-publish-plugin") version("${mpp_version}")
     id("org.ajoberstar.grgit.service") version("${grgitservice_version}")
     id("org.cadixdev.licenser") version("${licenser_version}")
 }
 
 subprojects {
     version = mod_version
     group = mod_group
-
-    // License headers
-    apply(plugin: "org.cadixdev.licenser")
-    license {
-        // This can be done in multiloader-common.gradle but only if the
-        // "matching" method is not used (throws a pile of weird errors).
-        // Also, NeoForge's update of the plugin can't handle matching at all.
-        include("**/*.java") // Java files only
-        header = rootProject.file("LICENSE_HEADER")
-        properties {
-            project_name = mod_name
-            owner_name = mod_owner
-            year = java.time.LocalDate.now().getYear().toString()
+
+    if (name == "common") {
+        // License headers
+        apply(plugin: "org.cadixdev.licenser")
+        String licenseDir = "src/main/resources/assets/${mod_id}/license/"
+        license {
+            // This can be done in multiloader-common.gradle but only if the
+            // "matching" method is not used (throws a pile of weird errors).
+            // Also, NeoForge's update of the plugin can't handle matching at all.
+            include("**/*.java") // Java files only
+            header = project.file(licenseDir + "HEADER.txt")
+            properties {
+                project_name = mod_name
+                owner_name = mod_owner
+                year = java.time.LocalDate.now().getYear().toString()
+            }
         }
-    }
-
-    // Publishing
-    if (name != "common") {
-        apply(plugin: "com.modrinth.minotaur")
-        apply(plugin: "net.darkhax.curseforgegradle")
-        apply(plugin: "com.github.breadmoirai.github-release")
+    } else {
+        // Publishing
+        apply(plugin: "me.modmuss50.mod-publish-plugin")
         apply(plugin: "org.ajoberstar.grgit.service")
 
         afterEvaluate {
-            modrinth {
-                token = System.getenv().MODRINTH_TOKEN ? System.getenv().MODRINTH_TOKEN : "empty"
-                projectId = modrinth_id
-                versionNumber = mod_version
-                versionType = release_type
-                versionName = "v${mod_version}-${capsLoader(name)}"
-                changelog = rootProject.file("changelog.md").text
-                uploadFile = name == "fabric" ? remapJar : jar
-                loaders = project.property("release_mod_loaders_${name}").split(",") as List
-                gameVersions = project.property("release_game_versions_${name}").split(",") as List
-
-                def deps = []
-                if (project.hasProperty("release_required_dep_ids_${name}_mr")) {
-                    project.property("release_required_dep_ids_${name}_mr").split(",").each { String id ->
-                        deps << new com.modrinth.minotaur.dependencies.ModDependency(id, "required")
-                    }
+            publishMods {
+                file = project.name == "fabric" ? remapJar.archiveFile : jar.archiveFile
+                version = mod_version
+                type = me.modmuss50.mpp.ReleaseType.of(release_type)
+                displayName = "v${mod_version}-${capsLoader(project.name)}"
+                modLoaders.addAll(project.property("release_mod_loaders_${project.name}").split(","))
+                maxRetries = 5
+                github {
+                    dryRun = providers.environmentVariable("GITHUB_TOKEN").getOrNull() == null
+                    accessToken = providers.environmentVariable("GITHUB_TOKEN")
+                    parent project(":").tasks.named("publishGithub")
+                    additionalFiles.from(sourcesJar.archiveFile)
                 }
-                if (project.hasProperty("release_optional_dep_ids_${name}_mr")) {
-                    project.property("release_optional_dep_ids_${name}_mr").split(",").each { String id ->
-                        deps << new com.modrinth.minotaur.dependencies.ModDependency(id, "optional")
+                modrinth {
+                    dryRun = providers.environmentVariable("MODRINTH_TOKEN").getOrNull() == null
+                    accessToken = providers.environmentVariable("MODRINTH_TOKEN")
+                    projectId = modrinth_id
+                    minecraftVersions.addAll(project.property("release_game_versions_${project.name}").split(","))
+                    changelog = versionChangelog()
+                    if (project.hasProperty("release_required_dep_ids_${project.name}_mr")) {
+                        project.property("release_required_dep_ids_${project.name}_mr").split(",").each { String mrId ->
+                            requires { id = mrId }
+                        }
                     }
-                }
-                if (project.hasProperty("release_incompatible_dep_ids_${name}_mr")) {
-                    project.property("release_incompatible_dep_ids_${name}_mr").split(",").each { String id ->
-                        deps << new com.modrinth.minotaur.dependencies.ModDependency(id, "incompatible")
+                    if (project.hasProperty("release_optional_dep_ids_${project.name}_mr")) {
+                        project.property("release_optional_dep_ids_${project.name}_mr").split(",").each { String mrId ->
+                            optional { id = mrId }
+                        }
                     }
-                }
-                dependencies = deps
-                syncBodyFrom = rootProject.file("README.md").text
-            }
-            tasks.modrinth.onlyIf { System.getenv().MODRINTH_TOKEN }
-            tasks.modrinth.dependsOn(build, tasks.modrinthSyncBody)
-            tasks.modrinthSyncBody.onlyIf { System.getenv().MODRINTH_TOKEN }
-
-            task curseforge(type: net.darkhax.curseforgegradle.TaskPublishCurseForge) {
-                apiToken = System.getenv().CURSEFORGE_TOKEN ? System.getenv().CURSEFORGE_TOKEN : "empty"
-
-                disableVersionDetection()
-                String module = project.name
-
-                def file = upload(curseforge_id, module == "fabric" ? remapJar : jar)
-                file.displayName = "v${mod_version}-${capsLoader(module)}"
-                file.releaseType = release_type
-                file.changelog = rootProject.file("changelog.md").text
-                file.changelogType = "markdown"
-                project.property("release_mod_loaders_${module}").split(",").each { String id ->
-                    file.addModLoader(id)
-                }
-                project.property("release_game_versions_${module}").split(",").each { String id ->
-                    file.addGameVersion(id, module)
-                }
-
-                if (project.hasProperty("release_required_dep_ids_${module}_cf")) {
-                    project.property("release_required_dep_ids_${module}_cf").split(",").each { String id ->
-                        file.addRequirement(id)
+                    if (project.hasProperty("release_incompatible_dep_ids_${project.name}_mr")) {
+                        project.property("release_incompatible_dep_ids_${project.name}_mr").split(",").each { String mrId ->
+                            incompatible { id = mrId }
+                        }
                     }
-                }
-                if (project.hasProperty("release_optional_dep_ids_${module}_cf")) {
-                    project.property("release_optional_dep_ids_${module}_cf").split(",").each { String id ->
-                        file.addOptional(id)
+                    if (project.hasProperty("release_embedded_dep_ids_${project.name}_mr")) {
+                        project.property("release_embedded_dep_ids_${project.name}_mr").split(",").each { String mrId ->
+                            embeds { id = mrId }
+                        }
                     }
+                    // Sync Modrinth description with GitHub README
+                    projectDescription = providers.fileContents(layout.projectDirectory.file("README.md")).asText
                 }
-                if (project.hasProperty("release_incompatible_dep_ids_${module}_cf")) {
-                    project.property("release_incompatible_dep_ids_${module}_cf").split(",").each { String id ->
-                        file.addIncompatibility(id)
+                curseforge {
+                    dryRun = providers.environmentVariable("CURSEFORGE_TOKEN").getOrNull() == null
+                    accessToken = providers.environmentVariable("CURSEFORGE_TOKEN")
+                    projectId = curseforge_id
+                    projectSlug = curseforge_slug
+                    minecraftVersions.addAll(project.property("release_game_versions_${project.name}").split(","))
+                    changelog = versionChangelog()
+                    if (project.hasProperty("release_required_dep_ids_${project.name}_cf")) {
+                        project.property("release_required_dep_ids_${project.name}_cf").split(",").each { String slug ->
+                            requires(slug)
+                        }
+                    }
+                    if (project.hasProperty("release_optional_dep_ids_${project.name}_cf")) {
+                        project.property("release_optional_dep_ids_${project.name}_cf").split(",").each { String slug ->
+                            optional(slug)
+                        }
+                    }
+                    if (project.hasProperty("release_incompatible_dep_ids_${project.name}_cf")) {
+                        project.property("release_incompatible_dep_ids_${project.name}_cf").split(",").each { String slug ->
+                            incompatible(slug)
+                        }
+                    }
+                    if (project.hasProperty("release_embedded_dep_ids_${project.name}_cf")) {
+                        project.property("release_embedded_dep_ids_${project.name}_cf").split(",").each { String slug ->
+                            embeds(slug)
+                        }
                     }
                 }
             }
-            tasks.curseforge.onlyIf { System.getenv().CURSEFORGE_TOKEN }
-            tasks.curseforge.dependsOn(build)
-
-            githubRelease {
-                token = System.getenv().GITHUB_TOKEN ? System.getenv().GITHUB_TOKEN : "empty"
-                owner = github_repo_owner
-                repo = github_repo
-                tagName = "v${mod_version}"
-                prerelease = release_type == "alpha" || release_type == "beta"
-                releaseName = "v${mod_version}"
+        }
+    }
+}
 
-                String changelog = "\nChangelog\n" + rootProject.file("changelog.md").text
-                String versions = "MC versions\n"
-                if (project.hasProperty("release_game_versions_fabric"))
-                    versions = String.format("%s - Fabric: %s\n", versions,
-                            project.property("release_game_versions_fabric"))
-                if (project.hasProperty("release_game_versions_neoforge"))
-                    versions = String.format("%s - NeoForge: %s\n", versions,
-                            project.property("release_game_versions_neoforge"))
-                body = versions + changelog
+publishMods {
+    // This task is necessary to allow publishing files from multiple 
+    // subprojects to a single GitHub release.
+    version = mod_version
+    type = me.modmuss50.mpp.ReleaseType.of(release_type)
+    github {
+        dryRun = providers.environmentVariable("GITHUB_TOKEN").getOrNull() == null
+        accessToken = providers.environmentVariable("GITHUB_TOKEN")
+        repository = github_repo
+        commitish = grgitService.service.get().grgit.branch.current().name
+        tagName = "v${mod_version}"
+        allowEmptyFiles = true
+        // Include compatible MC version lists in description
+        String versions = "## MC versions\n\n"
+        if (project.hasProperty("release_game_versions_fabric"))
+            versions = String.format("%s - Fabric: %s\n", versions,
+                    project.property("release_game_versions_fabric"))
+        if (project.hasProperty("release_game_versions_neoforge"))
+            versions = String.format("%s - NeoForge: %s\n", versions,
+                    project.property("release_game_versions_neoforge"))
+        changelog = versions + "\n\n## Changelog\n\n" + versionChangelog()
+    }
+}
 
-                body = rootProject.file("changelog.md").text
-                targetCommitish = grgitService.service.get().grgit.branch.current().name
-                overwrite = false
-                allowUploadToExisting = true
-                releaseAssets = List.of(name == "fabric" ? remapJar : jar, sourcesJar)
+String versionChangelog() {
+    List<String> lines = rootProject.file("CHANGELOG.md").readLines()
+    StringBuilder builder = new StringBuilder()
+    if ("${mod_version}".startsWith(lines.get(2).substring(3))) {
+        for (int i = 4; i < lines.size(); i++) {
+            String line = lines.get(i)
+            if (line.isBlank()) {
+                // pass
+            } else if (line.startsWith("## ")) {
+                break
+            }
+            else {
+                if (!builder.isEmpty()) builder.append("\n")
+                builder.append(line)
             }
-            tasks.githubRelease.onlyIf { System.getenv().GITHUB_TOKEN }
-            tasks.githubRelease.dependsOn(build)
         }
+    } else {
+        throw new IllegalArgumentException(
+                String.format("Mod version '%s' does not start with changelog version '%s'", 
+                        mod_version, lines.get(2).substring(3)))
     }
+    return builder.toString()
 }
 
 static String capsLoader(String loader) {

buildSrc/src/main/groovy/multiloader-common.gradle

@@ -38,10 +38,6 @@ repositories {
         )
         filter { includeGroup("org.parchmentmc.data") }
     }
-    maven {
-        name = "Modrinth"
-        url = "https://api.modrinth.com/maven"
-    }
 }
 
 // Declare capabilities on the outgoing configurations.
@@ -58,13 +54,13 @@ repositories {
 }
 
 sourcesJar {
-    from(rootProject.file("LICENSE")) {
+    from(rootProject.file("LICENSE.txt")) {
         rename { "${it}_${mod_name}" }
     }
 }
 
 jar {
-    from(rootProject.file("LICENSE")) {
+    from(rootProject.file("LICENSE.txt")) {
         rename { "${it}_${mod_name}" }
     }
 

common/build.gradle

@@ -5,8 +5,7 @@ plugins {
 
 dependencies {
     compileOnly("org.spongepowered:mixin:${mixin_version}")
-    compileOnly("io.github.llamalad7:mixinextras-common:${mixinextras_version}")
-    annotationProcessor("io.github.llamalad7:mixinextras-common:${mixinextras_version}")
+    compileOnly(annotationProcessor("io.github.llamalad7:mixinextras-common:${mixinextras_version}"))
 }
 
 neoForge {

common/src/main/resources/assets/resend/lang/en_us.json

@@ -1,8 +1,8 @@
 {
   "resend.name": "Resend",
 
-  "modmenu.descriptionTranslation.framework": "${mod_description}",
-  "fml.menu.mods.info.description.framework": "${mod_description}",
+  "modmenu.descriptionTranslation.resend": "${mod_description}",
+  "fml.menu.mods.info.description.resend": "${mod_description}",
 
   "key.resend.group": "Resend",
   "key.resend.group.resend": "Resend Last Message or Command"

fabric/build.gradle

@@ -13,6 +13,9 @@ dependencies {
     // Fabric loader and API
     modImplementation("net.fabricmc:fabric-loader:${fabric_loader_version}")
     modImplementation("net.fabricmc.fabric-api:fabric-api:${fabric_api_version}")
+
+    // JiJ MixinExtras if required to be newer than minimum loader-provided version
+//    include(implementation(annotationProcessor("io.github.llamalad7:mixinextras-fabric:${mixinextras_version}")))
 }
 
 loom {

fabric/src/main/resources/fabric.mod.json

@@ -50,7 +50,7 @@
   "custom": {
     "modmenu": {
       "links": {
-          "Contact": "${contact_url}"
+        "Contact": "${contact_url}"
       }
     },
     "formatSpec": {