build.gradle

plugins {
    id 'groovy'
    id 'net.fabricmc.fabric-loom' version "${loom_version}" apply false
    id "com.hypherionmc.modutils.modpublisher" version "2.2.1"
}

build {
    dependsOn ':ec-core:build'
}

ext.env = loadenv()

String getenv(String key) {
    return ext.env.getOrDefault(key, "NOT FOUND")
}

tasks.named('jar').configure {
    dependsOn(tasks.named('compileTestGroovy'))
}

allprojects {
    apply plugin: 'net.fabricmc.fabric-loom'
    apply plugin: 'maven-publish'
    apply plugin: 'idea'

    group = project.maven_group
    String vers_suffix = getenv("VERSION_SUFFIX")
    String full_version = vers_suffix != 'NOT FOUND' && vers_suffix != ''
        ? "${project.mod_version}-mc${project.minecraft_version}+${vers_suffix}"
        : "${project.mod_version}-mc${project.minecraft_version}"

    version = full_version
    base.archivesName = "${project.mod_id}"
    println "version: $full_version"
    println "base.archivesName: ${base.archivesName.get()}"

    repositories {
        gradlePluginPortal()
        mavenCentral()
//        mavenLocal()
        maven { name 'Fabric'; url 'https://maven.fabricmc.net/' }
        maven { url 'https://maven.nucleoid.xyz' } // Used by FabricPlaceholderAPI
        maven {
            name = 'Ladysnake Mods'
            url = 'https://maven.ladysnake.org/releases'
            content {
                includeGroup 'io.github.ladysnake'
                includeGroupByRegex 'org\\.ladysnake.*'
            }
        }
        maven {
            name = 'jpcode'
            url = 'https://maven.jpcode.dev/'
            content {
                includeGroup 'io.github.ladysnake'
                includeGroupByRegex 'org\\.ladysnake.*'
            }
        }
        maven { url "https://api.modrinth.com/maven" } // for vanish
    }

    loom {
        splitEnvironmentSourceSets()

        mods {
            "${project.mod_id}" {
                sourceSet sourceSets.main
            }
        }
    }

    // Common dependencies for all projects
    dependencies {
        // Fabric
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        implementation "net.fabricmc:fabric-loader:${project.loader_version}"
        implementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"
        implementation "eu.pb4:placeholder-api:${project.placeholder_api_version}"

        // Code Quality
        compileOnly "org.jetbrains:annotations:${project.jetbrains_annotations_version}"
        testImplementation platform("org.junit:junit-bom:${project.junit_bom_version}")
        testImplementation 'org.junit.jupiter:junit-jupiter'
        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
        testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
    }

    processResources {
        inputs.property 'id', project.mod_id
        inputs.property 'name', project.mod_name
        inputs.property 'version', project.version

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

    tasks.withType(JavaCompile).configureEach {
        // ensure that the encoding is set to UTF-8, no matter what the system default is
        // this fixes some edge cases with special characters not displaying correctly
        // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
        // If Javadoc is generated, this must be specified in that task too.
        it.options.encoding = "UTF-8"
        // java version
        it.options.release.set(25)
    }

    test {
        useJUnitPlatform()
    }

    java {
        withSourcesJar()

        sourceCompatibility = JavaVersion.VERSION_25
        targetCompatibility = JavaVersion.VERSION_25
    }

    jar {
        inputs.property "archivesName", project.base.archivesName

        from("LICENSE") {
            rename { "${it}_${inputs.properties.archivesName}"}
        }
    }

    publishing {
        publications {
            create("mavenJava", MavenPublication) {
                artifactId = project.mod_id
                groupId = project.maven_group
                version = project.version
                from components.java
            }
        }
        // Add repositories to publish to
        repositories {
            mavenLocal { }
            maven {
                name 'GitHub'
                url "https://maven.pkg.github.com/${project.gh_owner}/${project.gh_repo}"
                credentials {
                    username = getenv('GITHUB_ACTOR')
                    password = getenv('GITHUB_TOKEN')
                }
            }
        }
    }
}

// Root-project-specific dependencies
dependencies {
    implementation "me.lucko:fabric-permissions-api:${project.permissions_api_version}"

    // JIJ Dependencies (include for packaging)
    implementation "me.lucko:fabric-permissions-api:${project.permissions_api_version}"
    include "me.lucko:fabric-permissions-api:${project.permissions_api_version}"
    include "eu.pb4:placeholder-api:${project.placeholder_api_version}"
    implementation "org.yaml:snakeyaml:${project.snakeyaml_version}"
    include "org.yaml:snakeyaml:${project.snakeyaml_version}"
    implementation "io.github.ladysnake:PlayerAbilityLib:${pal_version}"
    include "io.github.ladysnake:PlayerAbilityLib:${pal_version}"

    // mod compatibility
    compileOnly  "maven.modrinth:vanish:${project.vanish_version}"

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

// ModPublisher Configuration
publisher {
    apiKeys {
        modrinth getenv("MODRINTH")
        curseforge getenv("CURSEFORGE")
        github getenv("GITHUB")
    }

    setDebug(false)

    setCurseID(project.cf_project_id)
    setModrinthID(project.modrinth_project_id)

    setVersionType(project.version.contains('alpha') ? 'alpha'
        : project.version.contains('beta') ? 'beta'
        : 'release')

    setChangelog(readLatestChangelogSection())
    setProjectVersion(project.version as String)
    setDisplayName(project.version as String)

    setGameVersions(project.game_versions.split(',').collect { it.trim() })

    setLoaders("fabric")
    setCurseEnvironment("both")

    setArtifact(jar)
    setJavaVersions([JavaVersion.VERSION_25])

    // Add subproject artifacts as additional files
    subprojects.each { subproject ->
        addAdditionalFile(subproject.jar)
    }

    github {
        repo("${project.gh_owner}/${project.gh_repo}")
        tag(project.version as String)
        target("1.21.x")
    }

    modrinthDepends {
        if (project.hasProperty('mr_relations_required') && project.mr_relations_required?.trim()) {
            project.mr_relations_required.split(',').each { dep ->
                required dep.trim()
            }
        }
        if (project.hasProperty('mr_relations_optional') && project.mr_relations_optional?.trim()) {
            project.mr_relations_optional.split(',').each { dep ->
                optional dep.trim()
            }
        }
        if (project.hasProperty('mr_relations_embedded') && project.mr_relations_embedded?.trim()) {
            project.mr_relations_embedded.split(',').each { dep ->
                embedded dep.trim()
            }
        }
        if (project.hasProperty('mr_relations_incompatible') && project.mr_relations_incompatible?.trim()) {
            project.mr_relations_incompatible.split(',').each { dep ->
                incompatible dep.trim()
            }
        }
    }

    curseDepends {
        if (project.hasProperty('cf_relations_required') && project.cf_relations_required?.trim()) {
            project.cf_relations_required.split(',').each { dep ->
                required dep.trim()
            }
        }
        if (project.hasProperty('cf_relations_optional') && project.cf_relations_optional?.trim()) {
            project.cf_relations_optional.split(',').each { dep ->
                optional dep.trim()
            }
        }
        if (project.hasProperty('cf_relations_embedded') && project.cf_relations_embedded?.trim()) {
            project.cf_relations_embedded.split(',').each { dep ->
                embedded dep.trim()
            }
        }
        if (project.hasProperty('cf_relations_incompatible') && project.cf_relations_incompatible?.trim()) {
            project.cf_relations_incompatible.split(',').each { dep ->
                incompatible dep.trim()
            }
        }
    }
}

tasks.named('publishCurseforge').configure {
    doFirst {
        def key = getenv('CURSEFORGE')
        if (key == 'NOT FOUND' || key.isEmpty()) {
            throw new GradleException("CURSEFORGE API key is required for publishing to CurseForge")
        }
    }
}

tasks.named('publishModrinth').configure {
    doFirst {
        def key = getenv('MODRINTH')
        if (key == 'NOT FOUND' || key.isEmpty()) {
            throw new GradleException("MODRINTH API key is required for publishing to Modrinth")
        }
    }
}

tasks.named('publishGitHub').configure {
    doFirst {
        def key = getenv('GITHUB')
        if (key == 'NOT FOUND' || key.isEmpty()) {
            throw new GradleException("GITHUB API key is required for publishing to GitHub")
        }
    }
}

generatePomFileForMavenJavaPublication {}

def static loadenv(String path = ".env") {
    def env = [:]

    def file = new File(path)
    if (file.exists()) {
        file.eachLine { line ->
            def (name, value) = line.tokenize("=")
            env[name.trim()] = value.trim()
        }
    }
    for (el in System.getenv()) {
        env[el.key] = el.value
    }
    return env
}

ext.cachedChangelog = null

String readChangelogFromFile() {
    if (ext.has('cachedChangelog')) {
        return ext.cachedChangelog
    }

    String changelogFilePath = './changelog.md'
    var file = new File(changelogFilePath)
    if (!file.exists()) {
        logger.warn("'%s' not found.", changelogFilePath)
        ext.cachedChangelog = "changelog file not found"
        return ext.cachedChangelog
    }

    ext.cachedChangelog = file.getText('UTF-8')
    return ext.cachedChangelog
}

String readLatestChangelogSection() {
    String fullChangelog = readChangelogFromFile()

    if (fullChangelog == "changelog file not found") {
        return fullChangelog
    }

    String[] sections = fullChangelog.split('--- --- ---')
    String mostRecentSection = sections[0].trim()

    var dashIdx = project.mod_version.indexOf('-')
    var plusIdx = project.mod_version.indexOf('+')
    var indexOfMainVersionEnd
        = dashIdx != -1 && plusIdx != -1 ? Math.min(dashIdx, plusIdx)
        : dashIdx != -1                  ? dashIdx
        : plusIdx != -1                  ? plusIdx
        :                                  project.mod_version.length()

    var mod_main_version = project.mod_version.substring(0, indexOfMainVersionEnd)

    if (!mostRecentSection.contains("v$mod_main_version")) {
        throw new RuntimeException("Changelog does not contain a section for the current version")
    }

    String suffix = """---

If you discover any bugs, you can report them in the [Issue Tracker](https://github.com/John-Paul-R/Essential-Commands/issues).

Additional conversation can be had in the [dev room discord](https://discord.jpcode.dev/essential-commands).

"""

    return mostRecentSection + '\n\n' + suffix
}