build.gradle

import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.util.function.Predicate

buildscript {
    repositories {
        maven { url = 'https://maven.parchmentmc.org' }
        mavenCentral()
    }
    dependencies {
        classpath 'org.parchmentmc:librarian:1.+'
    }
}
plugins {
    id 'scala'
    id 'net.minecraftforge.gradle' version '5.+'
    id 'maven-publish'
    id "com.github.breadmoirai.github-release" version "2.4.1"
    id "com.matthewprenger.cursegradle" version "1.4.0"
    id "com.modrinth.minotaur" version "2.+"
}
apply plugin: 'org.parchmentmc.librarian.forgegradle'

def scala_version = String.valueOf(getProperty("scala_version"))
def build_number = String.valueOf(getProperty("build_number"))
version = "${scala_version}-build-${build_number}"
group = "com.kotori316" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
archivesBaseName = "ScalableCatsForce"

java.toolchain.languageVersion = JavaLanguageVersion.of(17)
jarJar.enable()

minecraft {
    mappings channel: 'parchment', version: ((project.parchmentMapping + "-" + minecraftVersion()) as String)
    runs {
        client {
            workingDirectory project.file('Minecraft')

            // Recommended logging data for a userdev environment
            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'

            // Recommended logging level for the console
            property 'forge.logging.console.level', 'info'
            property "mixin.debug", "true"

            mods {
                "scala-library-object" {
                    source sourceSets.main
                }
            }
        }

        server {
            workingDirectory project.file('run-server')

            // Recommended logging data for a userdev environment
            property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'

            // Recommended logging level for the console
            property 'forge.logging.console.level', 'info'

            mods {
                "scala-library-object" {
                    source sourceSets.main
                }
            }
        }
        data {
            workingDirectory project.file('run-server')
            property 'forge.logging.markers', 'REGISTRIES,REGISTRYDUMP'
            property 'forge.logging.console.level', 'debug'
            forceExit false

            if (Boolean.valueOf(System.getenv("GITHUB_ACTIONS")))
                args '--mod', "slp_test,scala-library-object,scala-library-java", '--dev'
            else
                args '--mod', "slp_test", '--all'

            mods {
                "slp_test" {
                    source sourceSets.main
                }
            }
        }
    }
}

sourceSets {
    main {
        scala {
            exclude "/com/kotori316/scala_lib/example/**"
        }
        java {
            srcDir 'src/main/java'
        }
    }
}

private String forgeVersion() {
    return (java.util.Optional.ofNullable(System.getenv("CI_FORGE"))
            .filter(Predicate.isEqual("fixed").negate()) | () -> java.util.Optional.of(project.forgeVersion))
            .map { version -> "net.minecraftforge:forge:" + version }
            .orElse(null)
}

private String minecraftVersion() {
    String v = forgeVersion()
    return v.substring(v.lastIndexOf(":") + 1, v.lastIndexOf("-"))
}

repositories {
    mavenLocal()
    maven {
        name = "Azure-SLP"
        url = uri("https://pkgs.dev.azure.com/Kotori316/minecraft/_packaging/mods/maven/v1")
        content {
            it.includeVersion("org.typelevel", "cats-core_2.13", String.valueOf(project.cats_version))
            it.includeVersion("org.typelevel", "cats-kernel_2.13", String.valueOf(project.cats_version))
            it.includeVersion("org.typelevel", "cats-free_2.13", String.valueOf(project.cats_version))
        }
    }
}

dependencies {
    String scala_major = scala_version.substring(0, scala_version.lastIndexOf("."))
    String cats_version = getProperty("cats_version")

    minecraft(forgeVersion())
    // https://mvnrepository.com/artifact/org.scala-lang/scala-library
    implementation(group: 'org.scala-lang', name: 'scala-library', version: scala_version)
    // https://mvnrepository.com/artifact/org.typelevel/cats-core
    implementation(group: 'org.typelevel', name: "cats-core_" + scala_major, version: cats_version)
    implementation(group: 'org.typelevel', name: "cats-free_" + scala_major, version: cats_version)

    // Jar in Jar
    jarJar(group: 'org.scala-lang', name: 'scala-library', version: "[$scala_version, 3.0)")
    jarJar(group: 'org.typelevel', name: "cats-core_" + scala_major, version: "[$cats_version, 3.0)")
    jarJar(group: 'org.typelevel', name: "cats-kernel_" + scala_major, version: "[$cats_version, 3.0)")
    jarJar(group: 'org.typelevel', name: "cats-free_" + scala_major, version: "[$cats_version, 3.0)")

    // Test Dependencies.
    final def JUPITER_VERSION = '5.8.2'
    testImplementation(group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: JUPITER_VERSION)
    testImplementation(group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: JUPITER_VERSION)
    testRuntimeOnly(group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: JUPITER_VERSION)
    testImplementation(group: 'org.junit.platform', name: 'junit-platform-launcher', version: '1.8.2')

}

test {
    useJUnitPlatform()

    testLogging {
        events "skipped", "failed", "standardOut", "standardError"
        exceptionFormat 'full'
    }
}

jar {
    manifest {
        attributes([
                'FMLModType'           : 'LANGPROVIDER',
                'Automatic-Module-Name': 'kotori_scala',
        ])
        attributes([
                "Specification-Title"     : project.name,
                "Specification-Vendor"    : "Kotori316",
                "Specification-Version"   : "1", // We are version 1 of ourselves
                "Implementation-Title"    : project.name,
                "Implementation-Version"  : project.version,
                "Implementation-Vendor"   : "Kotori316",
                "Implementation-Timestamp": ZonedDateTime.now().format(DateTimeFormatter.ISO_INSTANT),
        ])
    }
    archiveClassifier.set('dev')
}

task normalJar(type: Jar) {
}

task srcJar(type: Jar) {
    from sourceSets.main.allSource
    archiveClassifier.set('sources')
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// Tell the artifact system about our extra jars
artifacts {
    archives srcJar
}

tasks.jarJar.configure {
    archiveClassifier.set("with-library")
}

// ---------- Publish ----------

curseforge {
    apiKey = project.hasProperty("curseforge_additional-enchanted-miner_key") ? getProperty("curseforge_additional-enchanted-miner_key") : ""
    project {
        id = '320926'
        changelogType = 'markdown'
        changelog = getChangelog()
        releaseType = 'release'
        addGameVersion(minecraftVersion())
        mainArtifact(tasks.jarJar)
        addArtifact jar
        addArtifact srcJar
    }
    options {
        curseGradleOptions.debug = false // defaults to false
        javaVersionAutoDetect = false
    }
}

githubRelease {
    repo.set('SLP')
    token = project.findProperty("githubToken") ?: System.getenv("REPO_TOKEN") ?: ""
    targetCommitish.set(project.branch as String)
    prerelease.set(project.version.toString().contains("SNAPSHOT"))
    body.set(getChangelog())
    releaseAssets = files(
            tasks.jarJar,
            jar,
            srcJar,
    )
    dryRun.set(false)
}

modrinth {
    token = project.findProperty("modrinthToken") ?: System.getenv("MODRINTH_TOKEN") ?: ""
    projectId = "scalable-cats-force"
    versionType = "release"
    uploadFile = tasks.jarJar
    gameVersions = [minecraftVersion()]
    loaders = ["forge"]
    changelog = project.getChangelog()
    debugMode = false
}

publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/Kotori316/SLP")
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("GITHUB_ACTOR") ?: ""
                password = project.findProperty("githubToken") ?: System.getenv("REPO_TOKEN")
            }
        }
        maven {
            name = "AzureRepository"
            url = uri("https://pkgs.dev.azure.com/Kotori316/minecraft/_packaging/mods/maven/v1")
            credentials {
                username = project.findProperty("azureUserName") ?: System.getenv("AZURE_USER_NAME") ?: ""
                password = project.findProperty("azureToken") ?: System.getenv("AZURE_TOKEN") ?: "TOKEN"
            }
        }
    }
    publications {
        mavenJava(MavenPublication) {
            artifactId = archivesBaseName.toLowerCase()
            from components.java
            artifact tasks.jarJar
            artifact srcJar

            pom {
                name = archivesBaseName
                description = "Scala Loading library build with Minecraft ${minecraftVersion()} and Forge ${forgeVersion()}"
                url = 'https://github.com/Kotori316/SLP'
                packaging = "jar"
            }
        }
    }
}

def getChangelog() {
    String t = """For Minecraft ${minecraftVersion()}
Built with forge ${forgeVersion()}

This mod provides language provider, "kotori_scala".

Scala: $scala_version
Cats: ${project.cats_version}, modified version of 2.7.0
"""
    return t
}

// --------- Github Actions ----------

static void start_group(String name) {
    println("::group::${name}")
}

@SuppressWarnings('SpellCheckingInspection')
static void end_group() {
    println("::endgroup::")
}

task data() {
    doLast {
        println("Java: ${System.getProperty('java.version')} JVM: ${System.getProperty('java.vm.version')}" +
                "(${System.getProperty('java.vendor')}) Arch: ${System.getProperty('os.arch')}")
        println("Scala: $scala_version, ${scala_version.getClass()}")
        println("Build Number: $build_number, ${build_number.getClass()}")
        println("Version: $version, ${version.getClass()}")
        println("Scala Loading library build with Minecraft ${minecraftVersion()} and Forge ${forgeVersion()}")
        println("Forge: ${forgeVersion()}")
        println("Minecraft: ${minecraftVersion()}")
        print(System.lineSeparator() * 2)
        println("All Dependencies")
        getProject().getConfigurations().forEach { con ->
            if (!con.dependencies.isEmpty()) {
                start_group(con.name)
                for (Object o : con.dependencies) {
                    println(o)
                }
                end_group()
            }
        }
        print(System.lineSeparator() * 2)
        start_group("Dependencies to be included in pom")
        getProject().getConfigurations().implementation.dependencies.each { Dependency dep ->
            if (!dep.name.contains("junit")) {
                printf("Group: %s, ArtifactId: %s, Version: %s%n", dep.group, dep.name, dep.version)
            } else {
                printf("JUNIT - Group: %s, ArtifactId: %s, Version: %s%n", dep.group, dep.name, dep.version)
            }
        }
        end_group()
        start_group("Publishing Information")
        publishing.properties.each { Map.Entry<?, ?> entry ->
            printf("%s -> %s (key: %s, value: %s)%n", entry.key, entry.value, entry.getKey().getClass(), entry.getValue().getClass())
        }
        end_group()
        start_group("Repositories")
//        publishing.properties.get("repositories").getClass().getMethods().each { println(it) }
//        publishing.properties.get("repositories").getClass().getInterfaces().each { println(it) }
        publishing.properties.get("repositories").getAsMap().each { Map.Entry<String, Object> e -> printf("%s=%s%n", e.key, e.value.getUrl()) }
//        (publishing.properties.get("repositories") as Collection<Object>).toArray()[0].getClass().getMethods().each {println(it)}
        end_group()
        start_group("Changelog")
        println(getChangelog())
        end_group()
    }
}