ViaFabric/build.gradle

// todo migrate this code to kotlin

import com.google.gson.JsonParser
import net.fabricmc.loom.task.RemapJarTask

import java.nio.file.Files

// Stolen https://github.com/FabricMC/fabric/blob/1.17/build.gradle
plugins {
    id "java"
    id "maven-publish"
    id "org.ajoberstar.grgit" version "3.1.1"
    id "com.matthewprenger.cursegradle" version "1.4.0"
    id "fabric-loom" version "0.10-SNAPSHOT" apply false
}

def ENV = System.getenv()
def vvVer = "4.1.2-SNAPSHOT"
def yamlVer = "1.30"

description = "Client-side and server-side ViaVersion implementation for Fabric"
version = "0.4.5+" + ENV.GITHUB_RUN_NUMBER + "-" + getBranch()
logger.lifecycle("Building ViaFabric: $version")

def getBranch() {
    def ENV = System.getenv()
    if (ENV.GITHUB_REF) {
        def branch = ENV.GITHUB_REF
        return branch.substring(branch.lastIndexOf("/") + 1)
    }

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

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

allprojects {
    apply plugin: "maven-publish"
    apply plugin: "fabric-loom"

    tasks.withType(JavaCompile).configureEach {
        it.options.release.set(8)
    }

    group = "com.viaversion.fabric"
    version = rootProject.version

    repositories {
        mavenCentral()
        maven { url = "https://repo.viaversion.com/" }
        maven { url = "https://maven.fabricmc.net/" }
        maven { url = "https://maven.legacyfabric.net/" }
        maven { url = "https://maven.terraformersmc.com/releases/" }
        maven { url = "https://jitpack.io/" }
    }

    dependencies {
        // transitive = false because Guava is conflicting on runClient
        implementation("com.viaversion:viaversion:$vvVer") { transitive = false }
        implementation("org.yaml:snakeyaml:$yamlVer")

        modImplementation("net.fabricmc:fabric-loader:0.12.12")
    }

    processResources {
        filesMatching("fabric.mod.json") {
            it.expand(rootProject.properties)
        }
    }

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

subprojects {
    dependencies {
        implementation rootProject
    }

    task remapMavenJar(type: Copy, dependsOn: remapJar) {
        afterEvaluate {
            from("${project.buildDir}/libs/$archivesBaseName-${version}.jar")
            into("${project.buildDir}/libs/")
            rename { String fn -> "$archivesBaseName-${version}-maven.jar" }
        }
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
            }
        }

        setupRepositories(repositories)
    }
}

task remapMavenJar(type: RemapJarTask, dependsOn: jar) {
    afterEvaluate {
        input = jar.archiveFile
        archiveFileName = "${archivesBaseName}-${version}-maven.jar"
        addNestedDependencies.set(false)
    }
}

build.dependsOn remapMavenJar

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(remapMavenJar) {
                builtBy remapMavenJar
            }

            artifact(sourcesJar) {
                builtBy remapSourcesJar
            }

            pom.withXml {
                def depsNode = asNode().appendNode("dependencies")
                subprojects.each {
                    def depNode = depsNode.appendNode("dependency")
                    depNode.appendNode("groupId", it.group)
                    depNode.appendNode("artifactId", it.name)
                    depNode.appendNode("version", it.version)
                    depNode.appendNode("scope", "compile")
                }
            }
        }
    }

    setupRepositories(repositories)
}

static void setupRepositories(RepositoryHandler repositories) {
    //repositories.mavenLocal() // uncomment for testing
    def ENV = System.getenv()
    if (ENV.MAVEN_URL) {
        repositories.maven {
            url ENV.MAVEN_URL
            credentials {
                username ENV.MAVEN_USERNAME
                password ENV.MAVEN_PASSWORD
            }
        }
    }
}

subprojects.each {
    remapJar.dependsOn("${it.path}:remapJar")
}

dependencies {
    // dummy version
    minecraft("com.mojang:minecraft:1.14.4")
    mappings("net.fabricmc:yarn:1.14.4+build.18:v2")

    include("com.viaversion:viaversion:$vvVer")
    include("org.yaml:snakeyaml:$yamlVer")
    include("com.github.TinfoilMC:ClientCommands:1.1.0")

    subprojects.each {
        include project("${it.name}:")
    }
}

processResources {
    filesMatching("assets/*/lang/*.lang") {
        HashMap<String, String> langMap = new HashMap<>()
        Files.list(rootProject.file("src/main/resources/assets/viafabric/lang").toPath())
                .filter(path -> path.toString().endsWith(".json"))
                .forEach(path -> {
                    String legacyFile = "\n" + String.join("\n", JsonParser
                            .parseReader(Files.newBufferedReader(path)).asJsonObject.entrySet().stream()
                            .map(entry -> entry.key + "=" + entry.value.asString)
                            .toArray(String[]::new))
                    langMap.put(path.getFileName().toString().replace(".json", ""), legacyFile)
                })
        it.expand(langMap)
    }
}

curseforge {
    if (ENV.CURSEFORGE_API_KEY) {
        apiKey = ENV.CURSEFORGE_API_KEY
    }

    project {
        id = "391298"
        changelog = "A changelog can be found at https://github.com/ViaVersion/ViaFabric/commits"
        releaseType = "alpha"
        Arrays.<String> asList("1.18.1", "1.17.1", "1.16.5", "1.15.2", "1.14.4", "1.8.9",
                "Java 8", "Java 9", "Java 10", "Java 11", "Java 12", "Java 13", "Java 14", "Java 15", "Java 16", "Java 17", "Fabric")
                .forEach { ver -> addGameVersion(ver) }

        mainArtifact(remapJar) {
            displayName = "[${getBranch()}] ViaFabric " + rootProject.version
            relations {
                optionalDependency("fabric-api")
                //optionalDependency("legacy-fabric-api")
                embeddedLibrary("cotton-client-commands")
            }
        }

        afterEvaluate {
            uploadTask.dependsOn("remapJar")
        }
    }

    options {
        forgeGradleIntegration = false
    }
}

if (getBranch() == "main" && ENV.CURSEFORGE_API_KEY && !ENV.CURSEFORGE_API_KEY.isEmpty()) {
    defaultTasks("clean", "build", "curseforge")
} else {
    defaultTasks("clean", "build")
}