build.gradle

plugins {
    id 'java'
    id 'eclipse'
    id 'idea'
    id 'maven-publish'
    id 'dev.architectury.loom' version '0.10.0-SNAPSHOT' apply false
    id 'org.cadixdev.licenser' version '0.6.1'
    id "org.ajoberstar.grgit" version "3.1.1"
    id 'com.matthewprenger.cursegradle' version "1.4.0"
}

import net.fabricmc.loom.task.RunClientTask

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

logger.lifecycle("Building cloth-api: " + version)
archivesBaseName = "cloth-api"

def getBranch() {
    if (System.getenv().GIT_BRANCH) {
        def branch = System.getenv().GIT_BRANCH
        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: 'signing'
    apply plugin: 'dev.architectury.loom'
    apply plugin: 'org.cadixdev.licenser'

    sourceCompatibility = targetCompatibility = 1.8

    group = "me.shedaniel.cloth.api"

    ext {
        shouldGenerateData = false
    }

    sourceSets {
        testmod {
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath
        }
        main {
            resources {
                srcDir 'src/generated/resources'
            }
        }
        datagen {
            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath
        }
    }

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

    dependencies {
        minecraft "com.mojang:minecraft:$project.minecraft_version"
        mappings "me.shedaniel:legacy-yarn:${project.yarn_version}:v2"
        modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
        modImplementation "net.fabricmc.fabric-api:fabric-api:${rootProject.fabric_version}"
        compileOnly "com.google.code.findbugs:jsr305:3.0.2"
        modImplementation "me.shedaniel.cloth:basic-math:${project.cloth_basic_math}"
    }

    configurations {
        dev
    }

    jar {
        classifier = "dev"
    }

    afterEvaluate {
        remapJar {
            input = file("${project.buildDir}/libs/$archivesBaseName-${version}-dev.jar")
            archiveName = "${archivesBaseName}-${version}.jar"
        }

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

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

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

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

        if (shouldGenerateData) {
            task generateData(type: RunClientTask, dependsOn: downloadAssets) {
                classpath = configurations.runtimeClasspath
                classpath sourceSets.main.output
                classpath sourceSets.datagen.output
            }

            build.dependsOn generateData
        }
    }

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

    task javadocs(type: Javadoc) {
        source = sourceSets.main.allJava
    }

    task javadocsJar(type: Jar, dependsOn: javadocs) {
        archiveClassifier.set("javadocs")
        javadocs.failOnError false
        from javadocs.destinationDir
    }
}

subprojects {
    version = rootProject.version

    dependencies {
        testmodImplementation sourceSets.main.output
        datagenImplementation sourceSets.main.output
    }

    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 {
            create("${archivesBaseName}_mavenJava", MavenPublication) {
                afterEvaluate {
                    artifact(file("${project.buildDir}/libs/$archivesBaseName-${version}-maven.jar")) {
                        builtBy remapMavenJar
                    }
                    artifact(sourcesJar) {
                        builtBy remapSourcesJar
                    }
                    artifact javadocsJar
                }
            }
        }

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

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

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

task licenseFormatAll
subprojects { p -> licenseFormatAll.dependsOn("${p.path}:licenseFormat") }
subprojects.each { remapJar.dependsOn("${it.path}:remapJar") }

sourceSets {
    testmod
    datagen
}

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

        testmodImplementation project("${it.name}:").sourceSets.testmod.output
    }
    
    include "me.shedaniel.cloth:basic-math:${project.cloth_basic_math}"
}

curseforge {
    apiKey = project.hasProperty('apiKey') ? project.property('apiKey') : System.getenv('CF_API_KEY')
    if (apiKey != null)
        project {
            id = '317121'
            changelog = 'A changelog can be found at https://github.com/shedaniel/cloth-api/commits'
            releaseType = 'release'
            addGameVersion '1.16-Snapshot'
            addGameVersion '1.16.2'
            addGameVersion 'Java 8'
            addGameVersion 'Fabric'
            mainArtifact(file("${project.buildDir}/libs/${archivesBaseName}-${version}.jar")) {
                displayName = "[Fabric $project.minecraft_version] v$project.version"
            }
            afterEvaluate {
                uploadTask.dependsOn("remapJar")
            }
        }
    options {
        forgeGradleIntegration = false
        javaVersionAutoDetect = false
    }
}