ferry-mpp.gradle

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath "me.modmuss50:mod-publish-plugin:1.1.0"
        classpath "net.dumbcode.gradlehook:GradleHook:2.0.2"
        classpath "org.kohsuke:github-api:1.330"
        classpath "org.ajoberstar.grgit:grgit-gradle:5.3.2"
    }
}

apply plugin: me.modmuss50.mpp.MppPlugin
apply plugin: net.dumbcode.gradlehook.GradleWebhookPlugin
apply plugin: org.ajoberstar.grgit.gradle.GrgitPlugin

ext.changelogFile = file(layout.buildDirectory.file("ferryReleaseChangelog.txt"))
ext.jarTask = findProperty('jarTask') ?: 'jar'
def curseReleaseType = "release"
def publications = getPublications(rootProject)
def stabilitySuffix = ""
def typeALPHA
def typeBETA
def typeSTABLE

rootProject.setVersion(getVersion())


// Publishing configuration

publishMods {
    // Set the main file to be uploaded
    //file = jar.archiveFile

    // Markdown changelog
    // This gets reconfigured later by the generateChangelog task.
    changelog = "No Changelog Available"

    // Defaults to the Gradle project version
    //version = getVersion()

    // Specify the release type
    // This gets reconfigured later by the generateChangelog task.
    type = ALPHA

    // The display name/release title, this defaults to the Gradle project name + version
    // This will typically be overridden for each publication later on...
    if (project.hasProperty("releaseTitle")) {
        displayName = project.getProperty("releaseTitle")
    } else {
        displayName = "${project.project_name} v${project.version} for ${project.minecraft_version}"
    }

    // A ConfigurableFileCollection of additional files that are uploaded alongside the main file
    //additionalFiles.from(jar.archiveFile)

    // The max number of times to retry on server error, defaults to 3.
    //maxRetries = 5

    // When dry run is enabled the release assets will be saved to the build directory for testing.
    if (project.hasProperty("dryRun")) {
        dryRun = true
    }

    // Set the brand color for all targets to the project's brand color.
    // ... what happened to this property? ...
    //brandColor = Integer.decode(project.project_color)

    def options_modrinth = modrinthOptions {
        if (providers.environmentVariable("MODRINTH_TOKEN").isPresent()) {
            accessToken = providers.environmentVariable("MODRINTH_TOKEN").get()
        } else {
            accessToken = "undefined"
            if (!dryRun) {
                dryRun = true
            }
        }

        projectId = project.modrinth_id
        announcementTitle = "${project.modrinth_emote} Modrinth"

        // A list of the versions the release supports
        splitProperty("modrinth_game_versions").each {
            minecraftVersions.add(it)
        }

        // Dependencies
        splitProperty("modrinth_required_dependencies").each {
            requires(it)
        }
        splitProperty("modrinth_optional_dependencies").each {
            optional(it)
        }
        splitProperty("modrinth_incompatible_dependencies").each {
            incompatible(it)
        }
        splitProperty("modrinth_embedded_dependencies").each {
            embeds(it)
        }
    }

    def options_curseforge = curseforgeOptions {
        if (providers.environmentVariable("CURSEFORGE_TOKEN").isPresent()) {
            accessToken = providers.environmentVariable("CURSEFORGE_TOKEN").get()
        } else {
            accessToken = "undefined"
            if (!dryRun) {
                dryRun = true
            }
        }

        projectId = project.curseforge_id
        projectSlug = project.curseforge_slug
        announcementTitle = "${project.curseforge_emote} CurseForge"

        // A list of the versions the release supports
        splitProperty("curseforge_game_versions").each {
            minecraftVersions.add(it)
        }

        // Dependencies
        splitProperty("curseforge_required_dependencies").each {
            requires(it)
        }
        splitProperty("curseforge_optional_dependencies").each {
            optional(it)
        }
        splitProperty("curseforge_incompatible_dependencies").each {
            incompatible(it)
        }
        splitProperty("curseforge_embedded_dependencies").each {
            embeds(it)
        }
    }

    if (project.hasProperty("github") && providers.environmentVariable("GITHUB_REPOSITORY").isPresent()) {
        github {
            if (providers.environmentVariable("GITHUB_TOKEN").isPresent()) {
                accessToken = providers.environmentVariable("GITHUB_TOKEN").get()
            } else {
                accessToken = "undefined"
                if (!dryRun) {
                    dryRun = true
                }
            }

            announcementTitle = (project.github_emote != null ? project.github_emote + " " : "") + "Download from GitHub"
            repository = providers.environmentVariable("GITHUB_REPOSITORY").get()

            commitish = getBranch()

            publications.each { Publication publication ->
                additionalFiles.from(publication.getArchive())
            }
        }
    }

    if (project.hasProperty("modrinth")) {
        publications.each { Publication publication ->
            modrinth("${publication.getPlatform()}Modrinth") {
                from options_modrinth

                announcementTitle = publication.getAnnouncementTitle("Modrinth", project.modrinth_emote)
                displayName = publication.getDisplayName()
                file = publication.getArchive()
                modLoaders.add(publication.getPlatform())

                if (publication.getPlatform() == "fabric") {
                    modLoaders.add("quilt")
                }
            }
        }
    }

    if (project.hasProperty("curseforge")) {
        publications.each { Publication publication ->
            curseforge("${publication.getPlatform()}Curseforge") {
                from options_curseforge

                announcementTitle = publication.getAnnouncementTitle("CurseForge", project.curseforge_emote)
                displayName = publication.getDisplayName()
                file = publication.getArchive()
                modLoaders.add(publication.getPlatform())

                if (publication.getPlatform() == "fabric") {
                    modLoaders.add("quilt")
                }
            }
        }
    }

    if (project.hasProperty("discord")) {
        discord {
            if (!providers.environmentVariable("DISCORD_ANNOUNCEMENT_WEBHOOK").isPresent()) {
                //dryRun = true
                dryRunWebhookUrl = providers.environmentVariable("DISCORD_ANNOUNCEMENT_WEBHOOK_DRY_RUN")
                webhookUrl = "undefined"
            } else {
                webhookUrl = providers.environmentVariable("DISCORD_ANNOUNCEMENT_WEBHOOK")
            }

            if (project.use_project_username.toBoolean()) {
                avatarUrl = project.project_logo
                username = project.project_name
            } else if (project.hasProperty("project_owner")) {
                username = project.project_owner
            }

            style {
                link = "INLINE"
                look = "MODERN"
                color = project.project_color
                thumbnailUrl = project.project_logo
            }

            content = changelog.map {
                "### [" + project.project_name + stabilitySuffix + "](" + project.project_url + ")\n" +
                "" + project.project_name + " v" + project.version + " for " + project.minecraft_version + " Released\n" +
                "### Changes:\n" + it + "\n" +
                "### Downloads:\n"
            }
        }
    }

    typeALPHA = ALPHA
    typeBETA = BETA
    typeSTABLE = STABLE
}

class Publication {
    private String jarTask
    private String platform
    private Project project
    private boolean single

    Publication(Project project, String platform, String jarTask) {
        assert platform != null && platform.length() > 0

        this.jarTask = jarTask
        this.platform = platform
        this.project = project
        this.single = (project.hasProperty("single_platform") && platform == project.getProperty("single_platform"))
    }

    String getPlatform() {
        return platform
    }

    RegularFileProperty getArchive() {
        return single
                ? project.tasks.named(jarTask, Jar).get().archiveFile as RegularFileProperty
                : project.project(":${platform}").tasks.named(jarTask, Jar).get().archiveFile as RegularFileProperty
    }

    String getAnnouncementTitle(String name, String emote) {
        assert name != null && name.length() > 0
        return ((emote != null ? emote + " " : "") + name + (single ? "" : " - " + platform.capitalize()))
    }

    String getDisplayName() {
        return single
                ? "${project.project_name} v${project.version} for ${project.minecraft_version}" as String
                : "${project.project_name} ${platform.capitalize()} v${project.version} for ${project.minecraft_version}" as String
    }
}

ArrayList<Publication> getPublications(Project project) {
    if (project.hasProperty("single_platform")) {
        assert (project.getProperty("single_platform") as String ?: '').length() > 0
        return [ new Publication(project, project.getProperty("single_platform") as String, project.getProperty("jarTask") as String) ]
    } else {
        assert (project.getProperty("enabled_platforms") as String ?: '').length() > 0
        return splitProperty("enabled_platforms").collect { platform -> new Publication(project, platform, project.getProperty("jarTask") as String) }
    }
}


// Changelog generation and persistence

tasks.register('generateChangelog') {
    def changes = StringBuilder.getDeclaredConstructor().newInstance()
    if (!project.hasProperty("lastTag") || !project.hasProperty("currentTag")) {
        println "Missing lastTag or currentTag parameters, aborting changelog creation"
        return
    }
    def lastTag = project.getProperty("lastTag")
    def currentTag = project.getProperty("currentTag")
    def commits = "git log --max-count=$project.changelog_max_commit_search --pretty=format:\"%b\" $lastTag..$currentTag".execute()
    println "Last version: $lastTag"
    println "Current version: $currentTag"

    def releaseType = project.default_release_type
    if (currentTag.contains("-alpha")) {
        releaseType = "alpha"
        curseReleaseType = "alpha"
        stabilitySuffix = " (Alpha)"
    } else if (currentTag.contains("-beta")) {
        releaseType = "beta"
        curseReleaseType = "beta"
        stabilitySuffix = " (Beta)"
    } else if (currentTag.contains("-pre")) {
        releaseType = "pre"
        curseReleaseType = "beta"
        stabilitySuffix = " (Pre-Release)"
    } else if (currentTag.contains("-rc")) {
        releaseType = "rc"
        curseReleaseType = "beta"
        stabilitySuffix = " (Release Candidate)"
    } else if (!currentTag.contains("-")) {
        releaseType = "stable"
    }
    println "Release type: ${releaseType}"

    commits.in.readLines().each { line -> // Loops over the lines the git log command returns
        def processedLine = line.toString()
        if (processedLine.startsWith("\"")) {
            processedLine = processedLine.substring(1)
        }
        if (processedLine.endsWith("\"")) {
            processedLine = processedLine.substring(0, processedLine.length() - 1)
        }
        println "Reading line: $processedLine"

        if (processedLine.startsWith("- ")) {
            println "Adding changelog line:"
            println "  $processedLine"
            if (changes.length() == 0) {
                changes << processedLine
            } else {
                changes << "\n$processedLine"
            }
        }
    }
    commits.err.eachLine { line -> println line }
    commits.waitFor()
    println "Changelog:"
    def releaseChangelog = changes.toString()
    if (releaseChangelog.isEmpty()) {
        releaseChangelog = "No Changelog Available"
    }
    println releaseChangelog

    // Persist the changelog to disk.
    changelogFile.getParentFile().mkdirs()
    changelogFile.createNewFile()
    changelogFile.text = releaseChangelog

    // Do MPP config which depends on the changelog:
    doLast {
        publishMods.changelog = releaseChangelog

        if (releaseType == "stable") {
            publishMods.type = typeSTABLE
        } else if (releaseType == "beta" || releaseType == "pre" || releaseType == "rc") {
            publishMods.type = typeBETA
        } else {
            publishMods.type = typeALPHA
        }
    }
}

// The changelog must be generated prior to publishing mods.
tasks.publishMods.dependsOn(generateChangelog)


// Support functions

String getBranch() {
    def branch = providers.environmentVariable("GITHUB_REF").getOrNull()
    if (branch != null) {
        return branch.substring(branch.lastIndexOf("/") + 1)
    }

    if (grgit == null) {
        return "unknown"
    }

    branch = grgit.branch.current().name
    return branch.substring(branch.lastIndexOf("/") + 1)
}

String getVersion() {
    def version = "unknown"
    if (project.hasProperty("currentTag")) {
        return project.currentTag.replace("v", "")
    }
    def branchLines = "git branch --show-current".execute().in.readLines()
    if (!branchLines.isEmpty()) {
        version = branchLines.get(0)
    }

    def tagLines = "git describe --tags --exact-match --abbrev=0".execute().in.readLines()
    def release = false
    if (!tagLines.isEmpty()) {
        def matcher = tagLines.get(0) =~ /v([0-9].[0-9].[0-9])/
        if (matcher.find()) {
            version = matcher.group(1) // gets 1st match group of 1st match
            release = true
        }
    }
    if (!release) {
        def lastTag = "git describe --tags --abbrev=0".execute().in.readLines()
        def lastCommit = "git rev-parse --short HEAD".execute().in.readLines()
        if (!lastTag.isEmpty() && !lastCommit.isEmpty()) {
            version = lastTag.get(0).replace("v", "") + "+" + version + "." + lastCommit.get(0)
        }
    }
    return version
}

String[] splitProperty(String property) {
    String value = project.findProperty(property)

    if (value == null) {
        return new String[0]
    }

    return value.split(', *').findAll { !it.isBlank() }
}