build.gradle

plugins {
    id 'java'
    id 'maven-publish'
    id 'idea'
    id 'eclipse'
    id 'fabric-loom' version '0.4-SNAPSHOT'
    id 'com.matthewprenger.cursegradle' version '1.4.0'
    id 'net.dumbcode.gradlehook' version '1.3.1'
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

archivesBaseName = project.archive_name
version = project.mod_version
group = project.maven_group

def ENV = System.getenv()
version = version + "+" + (ENV.BUILD_NUMBER ? ("build." + ENV.BUILD_NUMBER) : "custom")

version = version + "-" + project.minecraft_version

repositories {
    mavenLocal()
}

dependencies {
    minecraft "com.mojang:minecraft:${project.minecraft_version}"
    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
    modCompile "net.fabricmc:fabric-loader:${project.loader_version}"
    modCompile "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
    modCompile "com.terraformersmc:terraform:${project.terraform_version}"
    modCompile "com.terraformersmc:shapes:${project.shapes_version}"
    modCompile "com.terraformersmc:dossier:${project.dossier_version}"

    include "com.terraformersmc:shapes:${project.shapes_version}"
    include "com.terraformersmc:terraform:${project.terraform_version}"

    compileOnly "com.google.code.findbugs:jsr305:3.0.2"
}

processResources {
    inputs.property "version", project.version

    from(sourceSets.main.resources.srcDirs) {
        include "fabric.mod.json"
        expand "version": project.version
    }

    from(sourceSets.main.resources.srcDirs) {
        exclude "fabric.mod.json"
    }
}

tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = "sources"
    from sourceSets.main.allSource
}

jar {
    from "LICENSE"
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            afterEvaluate {
                artifact remapJar
            }
        }
    }

    repositories {
        if (project.hasProperty('mavenPass')) {
            maven {
                url = "http://mavenupload.modmuss50.me/"
                credentials {
                    username = "buildslave"
                    password = project.getProperty('mavenPass')
                }
            }
        }
    }
}


import com.matthewprenger.cursegradle.CurseArtifact

def fullChangelogBuilder = StringBuilder.newInstance()
def curseReleaseType = "release"
def releaseChangelog = "No Changelog Available"
def stabilitySuffix = ""

task buildAndAttemptRelease {

}

buildAndAttemptRelease {
    def changes = StringBuilder.newInstance()
    def proc = "git log --max-count=$project.changelog_max_commit_search --pretty=format:\"%s\"".execute()
    def latestCommit = true
    def release = false
    def cancel = false
    def releaseType = project.default_release_type

    proc.in.eachLine { line -> // Loops over the lines the git log command returns
        def processedLine = line.toString()
        if (cancel) {
            return
        }
        if (latestCommit) {
            if (processedLine.contains("#release")) {
                if (processedLine.contains("#release stable")) {
                    releaseType = "stable"
                } else if (processedLine.contains("#release beta")) {
                    releaseType = "beta"
                    curseReleaseType = "beta"
                    stabilitySuffix = " (Beta)"
                } else if (processedLine.contains("#release alpha")) {
                    releaseType = "alpha"
                    curseReleaseType = "alpha"
                    stabilitySuffix = " (Alpha)"
                }
                release = true
            }
        }
        if (!latestCommit && processedLine.contains("#release")) {
            // Cancel if it finds another release (that isn't the first one)
            cancel = true
            return
        }
        if (release) {
            if (project.changelog_type == "commit_change_tags") {
                def splitLine = processedLine.split(/\#change /)
                println "Adding changelog lines for commit $processedLine"
                def firstSplit = true
                splitLine.each { string ->
                    println " Commit: $processedLine - has string: $string"
                    if (firstSplit) {
                        firstSplit = false
                        return
                    }
                    if (string.startsWith("\"")) {
                        try {
                            def matches = string =~ /"(.*?)"/
                            def message = matches[0][1]
                            println "   Read as message: $message"
                            if (!message.isAllWhitespace()) {
                                if (changes.length() == 0) {
                                    changes << "- $message"
                                } else {
                                    changes << "\n- $message"
                                }
                            }
                        } catch (Exception e) {
                            println "Exception adding changelog message: $string"
                        }
                    }
                }
            } else if (project.changelog_type == "literal_commits") {
                if (project.changelog_hide_unimportant_commits.toBoolean() && processedLine.startsWith("Merge") && processedLine.contains("branch")) {
                    return
                }
                if (changes.length() == 0) {
                    changes << "- $processedLine"
                } else {
                    changes << "\n- $processedLine"
                }
            }
        }
        if (latestCommit) {
            latestCommit = false
        }
    }
    proc.err.eachLine { line -> println line }
    proc.waitFor()
    if (release) {
        println "This build IS scheduled to be released"
        releaseChangelog = changes.toString()
        println releaseChangelog
        dependsOn tasks.getByName("curseforge")
    } else {
        println "This build is NOT scheduled to be released"
    }
    dependsOn build
}

curseforge {
    apiKey = project.hasProperty('terraformersmc_curse_api_key') ? project.property('terraformersmc_curse_api_key') : "###"
    project {
        id = project.curseforge_id
        releaseType = curseReleaseType
        project.curseforge_game_versions.split(", ").each {
            String gameVersion -> addGameVersion gameVersion
        }
        changelog = releaseChangelog
        mainArtifact(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar"))
        mainArtifact.displayName = "$project.project_name v$project.mod_version for $project.minecraft_version"
        addArtifact sourcesJar
        additionalArtifacts.forEach { artifact -> artifact.displayName = "$project.project_name v$project.mod_version for $project.minecraft_version"}
        relations {
            if (!project.curseforge_required_dependencies.isEmpty()) {
                project.curseforge_required_dependencies.split(", ").each {
                    String dep -> requiredDependency dep
                }
            }
            if (!project.curseforge_optional_dependencies.isEmpty()) {
                project.curseforge_optional_dependencies.split(", ").each {
                    String dep -> optionalDependency dep
                }
            }
        }
        afterEvaluate {
            uploadTask.dependsOn(remapJar)
        }
    }
    options {
        forgeGradleIntegration = false
    }
}

tasks.getByName("curseforge").doLast {
    if (project.hasProperty('terraformersmc_announcements_webhook')) {
        println "Preparing webhook"
        def fileId = (tasks.getByName("curseforge$curseforge_id").property("mainArtifact") as CurseArtifact).fileID
        def curseforge_download = "https://www.curseforge.com/minecraft/mc-mods/$project.curseforge_slug/files/$fileId"
        def github_download = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        def release_url = curseforge_download
        def discordChangelog = createDiscordChangelog(release_url)

        def result = DiscordBuilder.createForm {
            if (project.use_project_username.toBoolean()) {
                avatar_url = project.project_logo
                username = project.project_name
            }
            embed {
                color = Integer.decode(project.project_color)
                author {
                    name = project.project_name + stabilitySuffix
                    url = project.project_url
                }
                thumbnail { url = project.project_logo }
                title = "$project.project_name v$project.mod_version for $project.minecraft_version Released"
                url = release_url
                field {
                    name = "Changes:"
                    value = discordChangelog
                }
                field {
                    name = "Downloads:"
                    value = "[$curseforge_emote CurseForge]($curseforge_download)"
                }
                footer {
                    text = "A $project.loader_name Mod"
                    icon_url = project.loader_icon
                }
            }
        }.send(project.property('terraformersmc_announcements_webhook'))

        println "Discord Webhook Response: " + result.responseCode
    }
}

// Truncates changelogs for the Discord Webhook
ext.createDiscordChangelog = { fullChangelogUrl ->
    def webhookChangelog = StringBuilder.newInstance()
    def changelogLines = releaseChangelog.split("\n")
    def maxLines = Integer.decode(project.discord_webhook_changelog_line_limit)
    if (changelogLines.length <= maxLines) {
        return releaseChangelog
    } else {
        def lines = 0
        changelogLines.find { line ->
            if (webhookChangelog.length() == 0) {
                webhookChangelog << line
            } else {
                webhookChangelog << "\n$line"
            }
            lines++
            if (lines >= maxLines) {
                webhookChangelog << "\n(+ " + (changelogLines.length - lines) + " more) See [Full Changelog]($fullChangelogUrl)"
                return true;
            }
        }
    }
    return webhookChangelog.toString()
}