migrate to modpublisher

Author: John-Paul-R

.github/workflows/publish.yml

@@ -127,13 +127,13 @@ jobs:
         env:
           CURSEFORGE: ${{ secrets.CURSEFORGE }}
           IS_PIPELINE: true
-        run: gradle publishCurseForge
+        run: gradle publishCurseforge
 
       - name: 📤 Create GitHub Release
         env:
           GITHUB: ${{ secrets.GITHUB_TOKEN }}
           IS_PIPELINE: true
-        run: gradle publishGithubRelease
+        run: gradle publishGithub
 
       - name: 🧨 Cleanup Gradle cache
         run: |

build.gradle

@@ -2,9 +2,7 @@ plugins {
     id 'groovy'
     id 'fabric-loom' version "${loom_version}"
     id 'maven-publish'
-    id "com.modrinth.minotaur" version "2.+"
-    id 'io.github.themrmilchmann.curseforge-publish' version "0.8.0"
-    id "com.github.breadmoirai.github-release" version "2.3.7"
+    id "com.hypherionmc.modutils.modpublisher" version "2.1.6"
     // id 'checkstyle'
 }
 
@@ -27,7 +25,6 @@ allprojects {
     apply plugin: 'fabric-loom'
     apply plugin: 'idea'
 
-
     group = project.maven_group
     String vers_suffix = getenv("VERSION_SUFFIX")
     String full_version = vers_suffix != 'NOT FOUND' && vers_suffix != ''
@@ -54,44 +51,32 @@ allprojects {
 
         subprojects.each {
             implementation project(path: ":${it.name}", configuration: "namedElements")
-            include project("${it.name}:") // nest within distribution
+            include project("${it.name}:")
         }
     }
 
-    // Perform tests using the JUnit test suite
     test {
         useJUnitPlatform()
     }
 
-    // Produce a sources distribution
     java {
         withSourcesJar()
     }
 
-    // Add the licence to all distributions
     tasks.withType(Jar).configureEach {
         it.from rootProject.file('LICENCE')
     }
 
-    // Process any resources
     processResources {
         inputs.property 'id', project.mod_id
         inputs.property 'name', project.mod_name
         inputs.property 'version', project.version
 
-        // fabric.mod.json
         filesMatching('fabric.mod.json') {
             expand(['id': project.mod_id, 'name': project.mod_name, 'version': project.version])
         }
     }
 
-    // checkstyle {
-    //     // use one common config file for all subprojects
-    //     configFile = project(':').file('.checkstyle.xml')
-    //     configProperties = [ "suppressionFile" : project(':').file('.checkstyle-suppressions.xml')]
-    // }
-
-    // Add any additional repositories
     repositories {
         gradlePluginPortal()
         mavenCentral()
@@ -103,9 +88,7 @@ allprojects {
         // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
         // See https://docs.gradle.org/current/userguide/declaring_repositories.html
         // for more information about repositories.
-        maven { url 'https://maven.nucleoid.xyz' }
-        // Used by FabricPlaceholderAPI
-
+        maven { url 'https://maven.nucleoid.xyz' } // Used by FabricPlaceholderAPI
         maven {
             name = 'Ladysnake Mods'
             url = 'https://maven.ladysnake.org/releases'
@@ -118,9 +101,8 @@ allprojects {
     }
 }
 
-// Root project specific dependencies
+// Root-project-specific dependencies
 dependencies {
-    // Root-only dependencies (not needed by ec-core)
     modImplementation "me.lucko:fabric-permissions-api:${project.permissions_api_version}"
 
     // included in fabriclocader 1.15+, kept here for compat on older loaders, I think
@@ -138,10 +120,9 @@ dependencies {
     // mod compatibility
     modCompileOnly  "maven.modrinth:vanish:${project.vanish_version}"
 
-    // Subprojects
     subprojects.each {
         implementation project(path: ":${it.name}", configuration: "namedElements")
-        include project("${it.name}:") // nest within distribution
+        include project("${it.name}:")
     }
 }
 
@@ -155,37 +136,26 @@ tasks.withType(JavaCompile).configureEach {
     it.options.release.set(21)
 }
 
-//jar {
-//    from("LICENSE") {
-//        rename { "${it}_${project.archivesBaseName}"}
-//    }
-//}
-
-// Define how packages are published
 publishing {
-    // Declare all publications
     publications {
         mavenJava(MavenPublication) {
             artifactId = project.mod_id
             groupId = project.maven_group
             version = project.version
-            // Main
             artifact(remapJar) { builtBy remapJar }
-            // Sources
             artifact(sourcesJar) {
                 builtBy remapSourcesJar
             }
         }
     }
     // Add repositories to publish to
     repositories {
-        // GitHub Packages (https://pkg.github.com)
         mavenLocal {
 
         }
         maven {
             name 'GitHub'
-            url "https://maven.pkg.github.com/${project.github_repo}"
+            url "https://maven.pkg.github.com/${project.gh_owner}/project.gh_repo"
             credentials {
                 username = getenv('GITHUB_ACTOR')
                 password = getenv('GITHUB_TOKEN')
@@ -194,165 +164,93 @@ publishing {
     }
 }
 
-
-import com.github.breadmoirai.githubreleaseplugin.GithubReleaseTask
-import com.modrinth.minotaur.TaskModrinthUpload
-import com.modrinth.minotaur.request.VersionType
-import io.github.themrmilchmann.gradle.publish.curseforge.ChangelogFormat
-import io.github.themrmilchmann.gradle.publish.curseforge.GameVersion
-import io.github.themrmilchmann.gradle.publish.curseforge.ReleaseType
-
-modrinth {
-    token = getenv("MODRINTH")
-    // An environment property called MODRINTH that is your token, set via Gradle CLI, GitHub Actions, Idea Run Configuration, or other
-    projectId = project.modrinth_project_id
-    versionNumber = (String) project.version // Will fail if Modrinth has this version already
-    versionType = project.version.contains('alpha') ? VersionType.ALPHA.toString()
-        : project.version.contains('beta') ? VersionType.BETA.toString()
-        : VersionType.RELEASE.toString()
-
-    // On fabric with loom, use 'remapJar' instead of 'jar'
-    uploadFile = remapJar
-
-    // This is the java jar task. If it can't find the jar, try 'jar.outputs.getFiles().asPath' in place of 'jar'
-    gameVersions = List.of(project.mr_game_versions.split(','))
-    changelog = readLatestChangelogSection()
-    loaders = ['fabric']
-
-    debugMode = false
-    project.version
-    dependencies {
-        if (project.mr_relations_required?.trim()) project.mr_relations_required.split(',').each { required.project(it.trim()) }
-        if (project.mr_relations_optional?.trim()) project.mr_relations_optional.split(',').each { optional.project(it.trim()) }
-        if (project.mr_relations_embedded?.trim()) project.mr_relations_embedded.split(',').each { embedded.project(it.trim()) }
-        if (project.mr_relations_incompatible?.trim()) project.mr_relations_incompatible.split(',').each { incompatible.project(it.trim()) }
+// ModPublisher Configuration
+publisher {
+    apiKeys {
+        modrinth getenv("MODRINTH")
+        curseforge getenv("CURSEFORGE")
+        github getenv("GITHUB")
     }
-}
 
+    setDebug(false)
 
-//type:
-tasks.register("publishModrinth", TaskModrinthUpload) { // Make sure it runs after build!
-    description 'Uploads all Modrinth projects'
-    group 'upload'
+    setCurseID(project.cf_project_id)
+    setModrinthID(project.modrinth_project_id)
 
-    onlyIf {
-        // Only attempt to run this task if the MODRINTH variable is set in .env, otherwise SKIP it
-        env.containsKey("MODRINTH")
-    }
-}
+    setVersionType(project.version.contains('alpha') ? 'alpha'
+        : project.version.contains('beta') ? 'beta'
+        : 'release')
 
-curseforge {
-    apiToken = getenv("CURSEFORGE")
+    setChangelog(readLatestChangelogSection())
+    setProjectVersion(project.version as String)
+    setDisplayName(project.version as String)
 
-    publications {
-        register("main") {
-            projectId = project.cf_project_id
+    setGameVersions(project.game_versions.split(',').collect { it.trim() })
 
-            // Convert game versions from comma-separated string to GameVersion objects
-            project.cf_game_versions.split(',').each { version ->
-                gameVersions.add(new GameVersion("minecraft-java-edition", version.trim()))
-            }
+    setLoaders("fabric")
+    setCurseEnvironment("both")
 
-            artifacts.register("main") {
-                displayName = "${project.version}"
-
-                // Convert release type to enum
-                releaseType = project.version.contains('alpha') ? ReleaseType.ALPHA
-                    : project.version.contains('beta') ? ReleaseType.BETA
-                    : ReleaseType.RELEASE
-
-                // Set up changelog (pointing to GitHub releases instead of inline text)
-                changelog {
-                    format = ChangelogFormat.TEXT
-                    content = "For a list of changes, please refer to https://github.com/${project.github_repo}/releases/tag/${project.version}"
-                }
-
-                from(remapJar)
-
-                // Convert relations configuration
-                relations {
-                    if (project.cf_relations_required) {
-                        project.cf_relations_required.split(',').each { dep ->
-                            requiredDependency(dep.trim())
-                        }
-                    }
-                    if (project.cf_relations_optional) {
-                        project.cf_relations_optional.split(',').each { dep ->
-                            optionalDependency(dep.trim())
-                        }
-                    }
-                    if (project.cf_relations_embedded) {
-                        project.cf_relations_embedded.split(',').each { dep ->
-                            embeddedLibrary(dep.trim())
-                        }
-                    }
-                    if (project.cf_relations_tools) {
-                        project.cf_relations_tools.split(',').each { dep ->
-                            tool(dep.trim())
-                        }
-                    }
-                    if (project.cf_relations_incompatible) {
-                        project.cf_relations_incompatible.split(',').each { dep ->
-                            incompatible(dep.trim())
-                        }
-                    }
-                }
-            }
+    setArtifact(remapJar)
+    setJavaVersions([JavaVersion.VERSION_21])
 
-            // Add additional artifacts from subprojects
-            subprojects.eachWithIndex { subproject, index ->
-                artifacts.register("subproject${index}") {
-                    from(subproject.remapJar)
-                    displayName = "${subproject.name} - ${project.version}"
-                    releaseType = project.version.contains('alpha') ? ReleaseType.ALPHA
-                        : project.version.contains('beta') ? ReleaseType.BETA
-                        : ReleaseType.RELEASE
-                }
-            }
-        }
+    // Add subproject artifacts as additional files
+    subprojects.each { subproject ->
+        addAdditionalFile(subproject.remapJar)
     }
-}
 
-tasks.register("publishCurseForge") {
-    description 'Uploads to CurseForge'
-    group 'upload'
-
-    dependsOn 'publishMainPublicationToCurseForge'
-
-    onlyIf {
-        env.containsKey("CURSEFORGE")
+    github {
+        repo = "${project.gh_owner}/${project.gh_repo}"
+        tag = project.version as String
+        target = "1.21.x"
     }
-}
 
-tasks.register("publishGithubRelease", GithubReleaseTask) {
-    description 'Creates a GitHub Release for the project'
-    group 'upload'
+    modrinthDepends {
+        if (project.hasProperty('mr_relations_required') && project.mr_relations_required?.trim()) {
+            project.mr_relations_required.split(',').each { dep ->
+                required dep.trim()
+            }
+        }
+        if (project.hasProperty('mr_relations_optional') && project.mr_relations_optional?.trim()) {
+            project.mr_relations_optional.split(',').each { dep ->
+                optional dep.trim()
+            }
+        }
+        if (project.hasProperty('mr_relations_embedded') && project.mr_relations_embedded?.trim()) {
+            project.mr_relations_embedded.split(',').each { dep ->
+                embedded dep.trim()
+            }
+        }
+        if (project.hasProperty('mr_relations_incompatible') && project.mr_relations_incompatible?.trim()) {
+            project.mr_relations_incompatible.split(',').each { dep ->
+                incompatible dep.trim()
+            }
+        }
+    }
 
-    onlyIf {
-        env.containsKey("GITHUB")
+    curseDepends {
+        if (project.hasProperty('cf_relations_required') && project.cf_relations_required?.trim()) {
+            project.cf_relations_required.split(',').each { dep ->
+                required dep.trim()
+            }
+        }
+        if (project.hasProperty('cf_relations_optional') && project.cf_relations_optional?.trim()) {
+            project.cf_relations_optional.split(',').each { dep ->
+                optional dep.trim()
+            }
+        }
+        if (project.hasProperty('cf_relations_embedded') && project.cf_relations_embedded?.trim()) {
+            project.cf_relations_embedded.split(',').each { dep ->
+                embedded dep.trim()
+            }
+        }
+        if (project.hasProperty('cf_relations_incompatible') && project.cf_relations_incompatible?.trim()) {
+            project.cf_relations_incompatible.split(',').each { dep ->
+                incompatible dep.trim()
+            }
+        }
     }
 }
-githubRelease {
-    token = getenv("GITHUB") // This is your personal access token with Repo permissions
-    // You get this from your user settings > developer settings > Personal Access Tokens
-    owner = project.gh_owner // default is the last part of your group. Eg group: "com.github.breadmoirai" => owner: "breadmoirai"
-    repo = project.gh_repo // by default this is set to your project name
-    tagName = project.version as String // by default this is set to "v${project.version}"
-    targetCommitish = "1.21.x" // by default this is set to "master"
-    releaseName = project.version as String // Release title, by default this is the same as the tagName
-    body = readLatestChangelogSection() // by default this is empty
-    draft = false // by default this is false
-    prerelease = false // by default this is false
-    releaseAssets base.libsDirectory
-        .getAsFileTree()
-        .matching((PatternFilterable pattern) -> pattern.include("**/*${project.version}.jar"))
-    //jar.outputs.getFiles().asPath//
-    overwrite = false // by default false; if set to true, will delete an existing release with the same tag and name
-    dryRun = false // by default false; you can use this to see what actions would be taken without making a release
-    apiEndpoint = "https://api.github.com" // should only change for github enterprise users
-    client // This is the okhttp client used for http requests
-    allowUploadToExisting = false
-}
+
 
 generatePomFileForMavenJavaPublication {}