build.gradle

plugins {
    id 'fabric-loom' version '1.9-SNAPSHOT' apply false
    id 'maven-publish'
    id 'gradle-build-utils' version '1.7.0'
}

Properties props = buildUtils.loadProperties('publish.properties')

ext {
    versionPattern = "^[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][a-zA-Z0-9.]+)?\$"
}

version = buildUtils.gitVersion()

allprojects {
    group = project.maven_group

    apply plugin: 'java'
    apply plugin: 'maven-publish'

    def initFile = file('init.gradle')

    ext {
        isMc = true
    }

    if (initFile.exists()) {
        apply from: initFile
    }

    if (ext.isMc) {
        apply plugin: 'fabric-loom'
    }

    repositories {
        mavenCentral()

        maven {
            url "https://repo.lclpnet.work/repository/internal"
        }
    }

    dependencies {
        compileOnly 'org.jetbrains:annotations:24.1.0'
    }

    if (ext.isMc) {
        dependencies {
            minecraft "com.mojang:minecraft:${project.minecraft_version}"
            mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
            modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

            modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
        }
    }

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

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

    tasks.withType(JavaCompile).configureEach {
        it.options.release = 21
    }

    java {
        // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
        withSourcesJar()

        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }

    [jar, sourcesJar].each {
        it.from(rootProject.file('LICENSE')) {
            rename { "${it}_${project.archivesBaseName}"}
        }
    }

    publishing {
        buildUtils.setupPublishRepository(repositories, props)
    }
}

subprojects {
    version = getSubprojectVersion(project)

    if (!ext.isMc) {
        configureNonLoomProject(project)
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifactId = project.archivesBaseName

                from components.java
            }
        }
    }

    publishMavenJavaPublicationToMavenRepository.onlyIf {
        return !checkProjectIsDeployed(project, props)
    }
}

import work.lclpnet.build.task.GithubDeploymentTask

def env = System.getenv()

tasks.register("github", GithubDeploymentTask) {
    dependsOn tasks.remapJar

    config {
        token = env.get("GITHUB_TOKEN")
        repository = env.get("GITHUB_REPOSITORY")
    }

    release {
        title = "[$project.minecraft_version] Kibu $project.version"
        tag = buildUtils.latestTag()
    }

    assets.add(tasks.remapJar.archiveFile.get())
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifactId = project.archivesBaseName

            from components.java

            pom {
                name = 'Kibu'
                description = 'Modding library for FabricMC.'
            }
        }
    }
}

// main jar must remap after all the subprojects
subprojects.each {
    if (it.ext.isMc) {
        remapJar.dependsOn("${it.path}:remapJar")
    }
}

sourceSets {
    testmod {
        compileClasspath += main.compileClasspath + main.getOutput()
        runtimeClasspath += main.runtimeClasspath + main.getOutput()
    }
}

loom {
    runs {
        named('server') {
            source 'testmod'
        }

        named('client') {
            source 'testmod'
        }
    }
}

dependencies {
    afterEvaluate {
        subprojects.each {
            api project(path: it.path, configuration: "namedElements")
        }
    }
}

// add subprojects as nested jar to the main jar
remapJar {
    afterEvaluate {
        subprojects.each {
            if (it.ext.isMc) {
                nestedJars.from project(it.path).tasks.named("remapJar")
            } else {
                nestedJars.from project(it.path).tasks.named("jar")
            }
        }
    }
}

processTestmodResources {
    inputs.property "version", project.version
    inputs.property "loader_version", project.loader_version

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

def checkProjectIsDeployed(Project project, Properties props) {
    def url = "${getDeployUrl(props)}/${project.group.toString().replace('.', '/')}/${project.archivesBaseName}/maven-metadata.xml"

    String xml
    try {
        xml = new URL(url).text
    } catch (Throwable ignored) {
        return false
    }

    def meta = new groovy.xml.XmlSlurper().parseText(xml)
    def versions = meta.versioning.versions.version*.text()

    return versions.contains(project.version)
}

def getDeployUrl(Properties props) {
    Map<String, String> env = System.getenv()

    if (env.containsKey("DEPLOY_URL")) {
        return env.get("DEPLOY_URL")
    } else if (props.containsKey('mavenHost')) {
        return props.getProperty('mavenHost')
    } else {
        return "file:///${rootProject.projectDir}/repo"
    }
}

static def getSubprojectVersion(Project project) {
    def version = project.getProperties()["${project.getName()}-version"]

    if (!version) {
        throw new IllegalStateException("Could not find version for project ${project.getName()}")
    }

    boolean local = System.getProperty("build.local") == "true"
    def suffix = (local ? '+local' : '')

    if (!project.ext.isMc) {
        return version + suffix
    }

    def versionString = version.toString()
    def snapshotSuffix = "-SNAPSHOT"

    if (versionString.endsWith(snapshotSuffix)) {
        return versionString.substring(0, versionString.length() - snapshotSuffix.length()) + "+" + project.minecraft_version + suffix + snapshotSuffix
    }

    return versionString + "+" + project.minecraft_version + suffix
}

static def configureNonLoomProject(Project project) {
    // non-loom subprojects need to have a "namedElements" configuration that provides the project artifacts
    project.configurations {
        namedElements
    }

    // add the project artifacts to the namedElements configuration
    project.apply {
        project.artifacts(artifactHandler -> artifactHandler.add("namedElements", project.getTasks().named("jar")));
    }
}

def moduleDependencies(project, List<String> dependencies) {
    // for each subproject dependency, collect the 'namedElements' configuration
    def deps = dependencies.iterator().collect {
        project.dependencies.project(path: ":$it", configuration: 'namedElements')
    }

    // now add the actual dependency to the project
    project.dependencies {
        deps.each {
            api it
        }
    }
}