build.gradle

plugins {
    id 'java'
    id 'checkstyle'
    id 'maven-publish'
    id 'com.modrinth.minotaur' version '2.8.7'
    id 'com.matthewprenger.cursegradle' version '1.4.0'
    id 'com.github.johnrengelman.shadow' version '8.1.1'
    id 'fabric-loom' version '1.6-SNAPSHOT'
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'checkstyle'
    apply plugin: 'maven-publish'
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: 'fabric-loom'

    group = project.maven_group
    version = project.mod_version
    base { archivesName = project.mod_id }

    java { sourceCompatibility = targetCompatibility = JavaVersion.VERSION_21 }

    // Declare dependencies
    configurations { shade }
    dependencies {
        // Fabric
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

        // Mods
        modRuntimeOnly "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"

        // Code Quality
        compileOnly "org.jetbrains:annotations:${project.jetbrains_annotations_version}"
        testImplementation "org.junit.jupiter:junit-jupiter-api:${project.junit_jupiter_version}"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${project.junit_jupiter_version}"
    }

    // Perform tests using the JUnit test suite
    test {
        useJUnitPlatform()
    }

    // Produce additional distributions
    java {
        withSourcesJar()
        withJavadocJar()
    }

    // Produce a fat-jar of all shaded dependencies
    shadowJar {
        configurations = [project.configurations.shade]
        destinationDirectory.set(layout.buildDirectory.dir('devlibs'))
    }

    remapJar {
        dependsOn tasks.shadowJar
        inputFile.set(tasks.shadowJar.archiveFile)
    }

    components.java.withVariantsFromConfiguration(configurations.shadowRuntimeElements) { skip() }

    // Add the licence to all distributions
    tasks.withType(Jar).configureEach {
        it.from rootProject.file('LICENCE.txt')
    }

    // Process any resources
    processResources {
        inputs.property 'id', project.mod_id
        inputs.property 'name', project.mod_name
        inputs.property 'description', project.mod_description
        inputs.property 'version', project.version

        // fabric.mod.json
        filesMatching('fabric.mod.json') {
            expand([
                'id': project.mod_id,
                'name': project.mod_name,
                'description': project.mod_description,
                'version': project.version,
            ])
        }
    }

    // Perform linting using Checkstyle
    checkstyle {
        configFile rootProject.file('.checkstyle.xml')
        toolVersion project.checkstyle_version
    }

    // Add any additional repositories
    repositories {
        mavenCentral()
        maven { name 'dv8tion'; url 'https://m2.dv8tion.net/releases' }
        maven { name 'Fabric'; url 'https://maven.fabricmc.net/' }
        maven { name 'Modrinth'; url 'https://api.modrinth.com/maven' }
        maven { name 'Nucleoid'; url 'https://maven.nucleoid.xyz/' }
        maven { name 'Shedaniel'; url 'https://maven.shedaniel.me/' }
    }

    // Read the `CHANGELOG.md` for the project version's changelog notes if present
    ext.getChangelogNotes = { ->
        final File changelog = project.file("CHANGELOG.md")
        if (changelog.canRead()) {
            def match = changelog.text =~ "(?ms)^## \\[\\Q${project.version}\\E].*?(?=^## |\\Z)"
            if (match.find() && !match.group().isBlank()) return match.group().trim()
        }
        return "For a list of changes, please refer to https://github.com/${project.github_repo}/releases/tag/v${project.version}"
    }

    // Define how packages are published
    publishing {
        // Declare all publications
        publications {
            mavenJava(MavenPublication) {
                from components.java
                pom {
                    name = project.mod_name
                    description = project.mod_description
                    url = "https://github.com/${project.github_repo}"
                    licenses { license { name = 'MIT'; url = 'https://opensource.org/licenses/MIT' } }
                    developers {
                        developer {
                            name = 'Axieum'
                            email = 'imaxieum@gmail.com'
                            url = 'https://github.com/axieum'
                        }
                    }
                    scm {
                        connection = "scm:git:git://github.com/${project.github_repo}.git"
                        developerConnection = "scm:git:ssh://git@github.com:${project.github_repo}.git"
                        url = "https://github.com/${project.github_repo}"
                    }
                    issueManagement { system = 'GitHub'; url = "https://github.com/${project.github_repo}/issues" }
                    ciManagement { system = 'GitHub'; url = "https://github.com/${project.github_repo}/actions" }
                    properties = [
                        'mod_id': project.mod_id,
                        'minecraft_version': project.minecraft_version,
                        'loader_version': project.loader_version,
                        'yarn_mappings': project.yarn_mappings,
                    ]
                }
            }
        }

        // Add repositories to publish to
        repositories {
            // GitHub Packages (https://pkg.github.com)
            maven {
                name 'GitHub'
                url "https://maven.pkg.github.com/${project.github_repo}"
                credentials {
                    username System.getenv('GITHUB_ACTOR')
                    password System.getenv('GITHUB_TOKEN')
                }
            }
        }
    }
}

// Nest all subproject artifacts within the main/bundle distribution
dependencies {
    subprojects.each {
        implementation project(path: ":${it.name}", configuration: 'namedElements')
        implementation project(path: ":${it.name}", configuration: 'shade')
        include project("${it.name}:")
    }
}

// Define how artifacts are published to CurseForge (https://curseforge.com)
curseforge {
    // Set the API token from the environment
    apiKey System.getenv('CURSEFORGE_TOKEN') ?: ''

    // Declare all projects
    project {
        // Set the project id
        id = project.cf_project_id
        // Set the release type
        releaseType = project.version.contains('alpha') ? 'alpha' : project.version.contains('beta') ? 'beta' : 'release'
        // Set the release notes
        changelog = project.getChangelogNotes()
        // Add all supported game versions
        project.cf_game_versions.split(', ').each { addGameVersion it }
        // Add the main artifact
        mainArtifact(remapJar) { displayName = "${project.mod_name} v${project.version}" }
        // Add any additional artifacts
        addArtifact remapSourcesJar
        addArtifact javadocJar
        subprojects.each {
            addArtifact it.remapJar
            addArtifact it.remapSourcesJar
            addArtifact it.javadocJar
        }
        // Add any dependencies
        relations {
            if (project.cf_relations_required) project.cf_relations_required.split(', ').each { requiredDependency it }
            if (project.cf_relations_optional) project.cf_relations_optional.split(', ').each { optionalDependency it }
            if (project.cf_relations_embedded) project.cf_relations_embedded.split(', ').each { embeddedLibrary it }
            if (project.cf_relations_tools) project.cf_relations_tools.split(', ').each { tool it }
            if (project.cf_relations_incompatible) project.cf_relations_incompatible.split(', ').each { incompatible it }
        }
    }

    // Configure other options
    options {
        forgeGradleIntegration = false
        debug = (System.getenv('CURSEFORGE_DEBUG') ?: 'false').toBoolean()
    }
}

// Define how artifacts are published to Modrinth (https://modrinth.com)
import com.modrinth.minotaur.dependencies.ModDependency
modrinth {
    // Set the API token from the environment
    token = System.getenv('MODRINTH_TOKEN') ?: ''
    // Set whether debug mode is enabled
    debugMode = (System.getenv('MODRINTH_DEBUG') ?: 'false').toBoolean()
    // Set the project id
    projectId = project.mr_project_id
    // Set the release name
    versionName = "${project.mod_name} v${project.version}"
    // Set the release type
    versionType = project.version.contains('alpha') ? 'alpha' : project.version.contains('beta') ? 'beta' : 'release'
    // Set the release version
    versionNumber = project.version
    // Set the release notes
    changelog = project.getChangelogNotes()
    // Set the project body sync target
    syncBodyFrom = rootProject.file('README.md').getText()
    // Add all supported mod loaders
    loaders = ['fabric']
    // Add all supported game versions
    project.mr_game_versions.split(', ').each { gameVersions.add it }
    // Add the main artifact
    uploadFile = remapJar
    // Add any additional artifacts
    additionalFiles.add remapSourcesJar
    // additionalFiles.add javadocJar
    subprojects.each {
        additionalFiles.add it.remapJar
        additionalFiles.add it.remapSourcesJar
        // additionalFiles.add it.javadocJar
    }
    // Add any dependencies
    if (project.mr_relations_required) dependencies.addAll project.mr_relations_required.split(', ').collect { new ModDependency(it, 'required') }
    if (project.mr_relations_optional) dependencies.addAll project.mr_relations_optional.split(', ').collect { new ModDependency(it, 'optional') }
    if (project.mr_relations_incompatible) dependencies.addAll project.mr_relations_incompatible.split(', ').collect { new ModDependency(it, 'incompatible') }
}

publish.finalizedBy tasks.curseforge, tasks.modrinth