RoughlyEnoughItems/build.gradle

plugins {
    id("forgified-fabric-loom") version("0.6.66") apply false
    id("maven-publish")
    id("java")
    id("java-library")
    id("net.minecrell.licenser") version("0.4.1")
    id("com.matthewprenger.cursegradle") version("1.4.0")
}

import net.fabricmc.loom.task.RemapJarTask

import java.text.SimpleDateFormat

archivesBaseName = "RoughlyEnoughItems"

def runNumber = (System.getenv("GITHUB_RUN_NUMBER") == null ? "9999" : System.getenv("GITHUB_RUN_NUMBER"))
version = rootProject.base_version + "." + runNumber

group = "me.shedaniel"

allprojects {
    apply plugin: 'maven-publish'
    apply plugin: 'forgified-fabric-loom'
    apply plugin: 'net.minecrell.licenser'

    sourceCompatibility = targetCompatibility = 1.8

    loom {
        silentMojangMappingsLicense()
//        shareCaches = true
    }

    repositories {
        maven { url "https://maven.shedaniel.me" }
        maven { url "https://maven.terraformersmc.com/releases" }
    }

    processResources {
        filesMatching('fabric.mod.json') {
            expand 'version': project.version
        }
        inputs.property "version", project.version
    }

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

    jar {
        from rootProject.file("LICENSE")
    }

    dependencies {
        minecraft("com.mojang:minecraft:${project.minecraft_version}")
        mappings(loom.officialMojangMappings())
        modApi("net.fabricmc:fabric-loader:${project.fabricloader_version}")
        modApi(fabricApi.module("fabric-api-base", project.fabric_api))
        include(fabricApi.module("fabric-api-base", project.fabric_api))
        modApi(fabricApi.module("fabric-resource-loader-v0", project.fabric_api))
        modApi(fabricApi.module("fabric-networking-v0", project.fabric_api))
        modApi(fabricApi.module("fabric-lifecycle-events-v1", project.fabric_api))
        modApi(fabricApi.module("fabric-rendering-fluids-v1", project.fabric_api))
        modRuntime("net.fabricmc.fabric-api:fabric-api:${project.fabric_api}")
        modApi("me.shedaniel.cloth.api:cloth-client-events-v0:${cloth_client_events_v0_version}") {
            transitive(false)
        }
        include("me.shedaniel.cloth.api:cloth-client-events-v0:${cloth_client_events_v0_version}") {
            transitive(false)
        }
        modApi("me.shedaniel.cloth:cloth-config-fabric:${cloth_config_version}") {
            exclude(module: "fabric-api")
        }
        modApi("org.jetbrains:annotations:19.0.0")
        modCompileOnly("com.terraformersmc:modmenu:${modmenu_version}") {
            transitive(false)
        }
        modRuntime("com.terraformersmc:modmenu:${modmenu_version}") {
            transitive(false)
        }
        modRuntime("me.shedaniel:SmoothScrollingEverywhere:3.0.3-unstable") {
            transitive(false)
        }
    }

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

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

subprojects {
    group = rootProject.group
    version = rootProject.version

    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" }
        }
    }

    configurations {
        dev
        remapped
    }

    jar {
        classifier("dev")
    }

    remapJar {
        classifier(null)
    }

    artifacts {
        dev file: file("${project.buildDir}/libs/$archivesBaseName-${version}-dev.jar"), type: "jar", builtBy: jar
        remapped file: file("${project.buildDir}/libs/$archivesBaseName-${version}.jar"), type: "jar", builtBy: remapJar
    }

    publishing {
        publications {
            create("${archivesBaseName}_mavenJava", MavenPublication) {
                afterEvaluate {
                    artifact(file("${project.buildDir}/libs/$archivesBaseName-${version}-maven.jar")) {
                        builtBy remapMavenJar
                    }
                    artifact(sourcesJar) {
                        builtBy remapSourcesJar
                    }
                }
            }
        }

        repositories {
            if (System.getenv("MAVEN_PASS") != null) {
                maven {
                    url = "https://deploy.shedaniel.me/"
                    credentials {
                        username = "shedaniel"
                        password = System.getenv("MAVEN_PASS")
                    }
                }
            }
        }
    }
}

task licenseFormatAll
subprojects { licenseFormatAll.dependsOn("${path}:licenseFormat") }
subprojects { rootProject.remapJar.dependsOn("${path}:remapJar") }

task remapMavenJar(type: RemapJarTask, dependsOn: jar) {
    input.set(file("${project.buildDir}/libs/${archivesBaseName}-${version}-dev.jar"))
    archiveName = "${archivesBaseName}-${version}-maven.jar"
    addNestedDependencies.set(false)
}

dependencies {
    subprojects.each {
        compile project(path: ":${it.name}", configuration: "dev")
        include project(path: ":${it.name}", configuration: "remapped")
    }
}

def releaseChangelog = "No changelog"

/* Thank you modmenu & fablabs */
task releaseOnCf {
    def df = new SimpleDateFormat("yyyy-MM-dd HH:mm")
    df.setTimeZone(TimeZone.getTimeZone("UTC"))
    def branch
    if (System.env.BRANCH_NAME) {
        branch = System.env.BRANCH_NAME
        branch = branch.substring(branch.lastIndexOf("/") + 1)
    } else {
        branch = "git rev-parse --abbrev-ref HEAD".execute().in.text.trim()
    }
    if (branch == "HEAD") {
        branch = "git rev-parse --short HEAD".execute().in.text.trim()
    }
    def time = df.format(new Date())
    def changes = new StringBuilder()
    changes << "<h2>REI v$project.version for $project.supported_version</h2>Updated at <b>$time</b>.<br><a href=\"https://www.github.com/shedaniel/RoughlyEnoughItems/commits/$branch\">Click here for changelog</a>"
    def proc = "git log --max-count=200 --pretty=format:%s".execute()
    proc.in.eachLine { line ->
        def processedLine = line.toString()
        if (!processedLine.contains("New translations") && !processedLine.contains("Merge") && !processedLine.contains("branch")) {
            changes << "<br>- ${processedLine.capitalize()}"
        }
    }
    proc.waitFor()
    releaseChangelog = changes.toString()
    dependsOn tasks.getByName("curseforge")
}

curseforge {
    if (project.hasProperty('danielshe_curse_api_key') || System.getenv('danielshe_curse_api_key') != null) {
        apiKey = project.hasProperty('danielshe_curse_api_key') ? project.property('danielshe_curse_api_key') : System.getenv('danielshe_curse_api_key')
        project {
            id = "310111"
            releaseType = "release"
            changelogType = "html"
            changelog = releaseChangelog
            addGameVersion "1.16-Snapshot"
            addGameVersion "1.16.4"
            addGameVersion "1.16.5"
            addGameVersion "Java 8"
            addGameVersion "Fabric"
            relations {
                requiredDependency "fabric-api"
                requiredDependency "cloth-config"
                embeddedLibrary "cloth-api"
            }
            mainArtifact(file("${project.buildDir}/libs/${project.archivesBaseName}-${project.version}.jar")) {
                displayName = "[Fabric $project.supported_version] v$project.version"
            }
            addArtifact(file("${project.buildDir}/libs/${project.archivesBaseName}-${project.version}-sources.jar")) {
                displayName = "[Fabric $project.supported_version] v$project.version Sources"
            }
            afterEvaluate {
                uploadTask.dependsOn("build")
            }
        }
    }
    options {
        forgeGradleIntegration = false
        javaVersionAutoDetect = false
    }
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(file("${project.buildDir}/libs/$archivesBaseName-${version}-maven.jar")) {
                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")
                }
            }
        }
    }

    repositories {
        if (System.getenv("MAVEN_PASS") != null) {
            maven {
                url = "https://deploy.shedaniel.me/"
                credentials {
                    username = "shedaniel"
                    password = System.getenv("MAVEN_PASS")
                }
            }
        }
    }
}