MidnightControls/build.gradle

plugins {
    id 'fabric-loom' version '0.11-SNAPSHOT'
    id 'java-library'
    id 'maven-publish'
    id 'com.github.johnrengelman.shadow' version '7.0.0'
    id 'org.cadixdev.licenser' version '0.6.1'
    id 'com.modrinth.minotaur' version '1.2.+'
}

import net.fabricmc.loom.task.RemapJarTask
import com.google.gson.GsonBuilder
import com.google.gson.JsonObject
import com.modrinth.minotaur.TaskModrinthUpload
import com.modrinth.minotaur.request.VersionType
import com.modrinth.minotaur.responses.ResponseError
import org.apache.http.client.config.CookieSpecs
import org.apache.http.client.config.RequestConfig
import org.apache.http.client.entity.EntityBuilder
import org.apache.http.client.methods.HttpPatch
import org.apache.http.entity.ContentType
import org.apache.http.impl.client.HttpClientBuilder
import org.apache.http.util.EntityUtils

group = project.maven_group
version = "${project.mod_version}+${getMCVersionString()}"
archivesBaseName = project.archives_base_name

// This field defines the Java version your mod target.
def targetJavaVersion = 17

boolean isMCVersionNonRelease() {
    return project.minecraft_version.matches('^\\d\\dw\\d\\d[a-z]$')
            || project.minecraft_version.matches('\\d+\\.\\d+-(pre|rc)(\\d+)')
}

String getMCVersionString() {
    if (isMCVersionNonRelease()) {
        return project.minecraft_version
    }
    def version = project.minecraft_version.split('\\.')
    return version[0] + '.' + version[1]
}

String getTerraformersMCMaven() {
    def terraformersUrl = 'https://maven.terraformersmc.com/'
    if (pingUrl(terraformersUrl))
        return terraformersUrl
    else
        return 'https://maven.kotlindiscord.com/repository/terraformers/'
}

boolean pingUrl(String address) {
    try {
        def conn = (HttpURLConnection) new URL(address).openConnection()
        int responseCode = conn.getResponseCode()
        return (200 <= responseCode && responseCode <= 399)
    } catch (IOException ignored) {
        return false
    }
}

String parseReadme() {
    def excludeRegex = /(?m)<!-- modrinth_exclude\.start -->(.|\n)*?<!-- modrinth_exclude\.end -->/
    def linkRegex = /!\[([A-z_ ]+)]\((images\/[A-z.\/_]+)\)/

    def readme = (String) file('README.md').text
    readme = readme.replaceAll(excludeRegex, '')
    readme = readme.replaceAll(linkRegex, '![$1](https://raw.githubusercontent.com/LambdAurora/midnightcontrols/1.17/$2)')
    return readme
}


repositories {
    mavenLocal()
    mavenCentral()
    maven { url 'https://aperlambda.github.io/maven' }
    maven {
        name 'Gegy'
        url 'https://maven.gegy.dev'
    }
    maven {
        name 'CottonMC'
        url 'https://server.bbkr.space/artifactory/libs-snapshot'
    }
    maven {
        name 'TerraformersMC'
        url getTerraformersMCMaven()
        content {
            includeGroup 'dev.emi'
            includeGroup 'com.terraformersmc'
        }
    }
    maven { url 'https://maven.kosmx.dev' }
    maven { url 'https://maven.shedaniel.me/' }
    maven { url 'https://jitpack.io' }
    maven { url "https://api.modrinth.com/maven" }
}

configurations {
    shadow
    api.extendsFrom shadow
}

dependencies {
    //to change the versions see the gradle.properties file
    minecraft "com.mojang:minecraft:${project.minecraft_version}"
    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

    // Fabric API. This is technically optional, but you probably want it anyway.
    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"

    modImplementation "dev.lambdaurora:spruceui:${project.spruceui_version}"
    include "dev.lambdaurora:spruceui:${project.spruceui_version}"
    api('org.aperlambda:lambdajcommon:1.8.1') {
        exclude group: 'com.google.code.gson'
        exclude group: 'com.google.guava'
    }
    include 'org.aperlambda:lambdajcommon:1.8.1'

    modImplementation "com.terraformersmc:modmenu:${project.modmenu_version}"

    // Compatibility mods
    modImplementation("com.github.EnnuiL:okzoomer:e6a801b1a3") {
        exclude group: 'com.terraformersmc'
        exclude group: 'dev.lambdaurora'
    }
    modImplementation "maven.modrinth:emotecraft:${project.emotecraft_version}"
    modImplementation "io.github.kosmx:bendy-lib:${project.bendylib_version}"

    modImplementation "maven.modrinth:midnightlib:${project.midnightlib_version}"
    include "maven.modrinth:midnightlib:${project.midnightlib_version}"

    shadow 'com.electronwill.night-config:core:3.6.3'
    shadow 'com.electronwill.night-config:toml:3.6.3'
}
loom {
    accessWidenerPath = file("src/main/resources/midnightcontrols.accesswidener")
}

java {
    sourceCompatibility = JavaVersion.toVersion(targetJavaVersion)
    targetCompatibility = JavaVersion.toVersion(targetJavaVersion)

    withSourcesJar()
}

tasks.withType(JavaCompile).configureEach {
    it.options.encoding = 'UTF-8'

    it.options.release.set(targetJavaVersion)
}

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

    filesMatching('fabric.mod.json') {
        expand 'version': project.version
    }
}

jar {
    from('LICENSE') {
        rename { "${it}_${project.archivesBaseName}" }
    }
}

license {
    header file('HEADER')
    include '**/*.java'
}

task publishModrinth(type: TaskModrinthUpload) {
    dependsOn(build)
    onlyIf {
        System.getenv('MODRINTH_TOKEN')
    }

    token = System.getenv('MODRINTH_TOKEN')
    projectId = project.modrinth_id
    versionNumber = version
    versionName = "midnightcontrols ${project.mod_version} (${getMCVersionString()})"
    addGameVersion((String) project.minecraft_version)
    addLoader('fabric')
    versionType = isMCVersionNonRelease() ? VersionType.BETA : VersionType.RELEASE

    // Changelog fetching
    def changelogText = file('CHANGELOG.md').text
    def regexVersion = ((String) project.mod_version).replaceAll('\\.', /\\./).replaceAll('\\+', '\\+')
    def changelogRegex = ~"###? ${regexVersion}\\n\\n(( *- .+\\n)+)"
    def matcher = changelogText =~ changelogRegex

    if (matcher.find()) {
        changelog = matcher.group(1)

        def changelogLines = changelogText.split('\n')
        def linkRefRegex = ~'^\\[([A-z0-9 _\\-/+.]+)]: '
        for (int i = changelogLines.length - 1; i > 0; i--) {
            def line = changelogLines[i]
            if ((line =~ linkRefRegex).find())
                changelog += '\n' + line
            else break
        }
    }

    // Readme
    doFirst {
        final def client = HttpClientBuilder.create().setDefaultRequestConfig(RequestConfig.custom().setCookieSpec(CookieSpecs.IGNORE_COOKIES).build()).build()
        final def patch = new HttpPatch((String) (apiURL + '/v1/mod/' + projectId))
        patch.addHeader("Authorization", token)

        var json = new JsonObject()
        json.addProperty("body", parseReadme())
        patch.setEntity(EntityBuilder.create()
                .setText(json.toString())
                .setContentType(ContentType.APPLICATION_JSON)
                .build())

        final def response = client.execute(patch)
        final int status = response.getStatusLine().getStatusCode()

        final def gson = new GsonBuilder().create()
        if (status == 200) {
            project.getLogger().lifecycle("Successfully updated readme to ${projectId}.")
        } else {
            errorInfo = gson.fromJson(EntityUtils.toString(response.getEntity()), ResponseError.class)
            project.getLogger().error("Upload failed! Status: ${status} Error: ${errorInfo.getError()} Reason: ${errorInfo.getDescription()}")
            throw new GradleException("Upload failed! Status: ${status} Reason: ${errorInfo.getDescription()}")
        }
    }
}

// configure the maven publication
publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            pom {
                name = 'midnightcontrols'
                description = 'Adds better controls, and controller support.'
            }

            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')

                configurations.shadow.allDependencies.each {
                    def dependencyNode = dependenciesNode.appendNode('dependency')

                    dependencyNode.appendNode('groupId', it.group)
                    dependencyNode.appendNode('artifactId', it.name)
                    dependencyNode.appendNode('version', it.version)
                    dependencyNode.appendNode('scope', 'compile')
                }
            }
        }
    }

    repositories {
        mavenLocal()
        maven {
            name 'GithubPackages'
            url uri('https://maven.pkg.github.com/LambdAurora/midnightcontrols')
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
            }
        }
        def midnightcontrolsMaven = System.getenv('midnightcontrols_MAVEN')
        if (midnightcontrolsMaven) {
            maven {
                name 'midnightcontrolsMaven'
                url uri(midnightcontrolsMaven)
                credentials {
                    username = project.findProperty('gpr.user') ?: System.getenv('MAVEN_USERNAME')
                    password = project.findProperty('gpr.key') ?: System.getenv('MAVEN_PASSWORD')
                }
            }
        }
    }
}