build.gradle

import groovy.json.JsonOutput

plugins {
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    id 'net.neoforged.moddev' version '2.0.77'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
    withSourcesJar()
    withJavadocJar()
}

group = 'io.codechicken'
base {
    archivesName = 'CodeChickenLib'
}

sourceSets.main.resources.srcDirs += "src/main/generated"

mod_version = "${mod_version}." + (System.getenv("BUILD_NUMBER") ?: "1")
version = "${mc_version}-${mod_version}"
println "Starting build of ${archivesBaseName}, Version: ${mod_version}"
println "Using Forge: ${forge_version}, for Minecraft: ${mc_version}"

neoForge {
    enable {
        version = forge_version
        enabledSourceSets += sourceSets.test
    }

    accessTransformers {
        publish file("src/main/resources/META-INF/accesstransformer.cfg")
    }

    runs {
        client {
            client()
        }
        server {
            server()
        }
        data {
            data()
            programArguments.addAll '--mod', 'codechickenlib', '--all', '--output', file("src/main/generated").absolutePath, '--existing', file("src/main/resources").absolutePath
        }
    }

    mods {
        codechickenlib {
            sourceSet sourceSets.main
        }
    }
}

processResources {
    inputs.property 'mod_version', mod_version
    inputs.property 'mc_version', mc_version

    filesMatching('META-INF/neoforge.mods.toml') {
        expand 'file': ['jarVersion': mod_version],
                'mc_version': mc_version,
                'forge_version': forge_version,
                'lang_version': forge_version.split('\\.')[0]
    }
}

repositories {
    mavenLocal()
    maven { url "https://maven.covers1624.net/" }
    maven { url "https://maven.blamejared.com/" }
    maven { url "https://api.modrinth.com/maven" }
}

dependencies {
    jarJar(api('net.covers1624:Quack')) {
        version {
            strictly '[0.4.10,0.5)'
            prefer '0.4.10.105'
        }
    }

    compileOnly 'maven.modrinth:embeddium:1.0.15+mc1.21.1'

    compileOnly("mezz.jei:jei-${mc_version}-neoforge:${jei_version}") {
        transitive false
    }

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
}

test {
    useJUnitPlatform()
}

def commonManifest = {
    attributes 'Specification-Title': base.archivesName.get()
    attributes 'Specification-Vendor': 'covers1624'
    attributes 'Specification-Version': "1"
    attributes 'Implementation-Title': base.archivesName.get()
    attributes 'Implementation-Vendor': 'covers1624'
    attributes 'Implementation-Version': mod_version
    attributes 'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
    attributes 'MixinConfigs': 'mixins.codechickenlib.json'
}

def publishingMetadata = project.layout.buildDirectory.file("libs/${base.archivesName.get()}-$version-publishing.json")
def publishingMetadataTask = tasks.register("publishingMetadata") {
    outputs.file(publishingMetadata)
    doFirst {
        publishingMetadata.get().asFile.text = JsonOutput.prettyPrint(JsonOutput.toJson([
                [
                        'displayName' : "CodeChicken Lib ${version}",
                        'mcVersion'   : "${mc_version}",
                        'version'     : "${mod_version}",
                        'classifier'  : null,
                        'modLoader'   : ['neoforge'],
                        'curseforgeId': '242818',
                        'modrinthId'  : '2gq0ALnz'
                ]
        ]))
    }
}

jar {
    finalizedBy 'signJar'
    manifest commonManifest

    from file("LICENSE")
}

tasks.register("signJar") {
    dependsOn("jar")

    doFirst {
        def args = [:]
        args['jar'] = jar.archiveFile.get().asFile
        if (System.getenv("KEY_STORE")) {
            args['keyStore'] = System.getenv("KEY_STORE")
            file(System.getenv("KEY_STORE_PROPS")).withReader {
                def props = new Properties()
                props.load(it)
                args.putAll(props)
            }
        } else if (project.hasProperty('keyStore')) {
            args['keyStore'] = project.getProperty('keyStore')
            args['alias'] = project.getProperty('keyStoreAlias')
            args['storePass'] = project.getProperty('keyStorePass')
            args['keyPass'] = project.getProperty('keyStoreKeyPass')
        } else {
            println "No signing properties."
            state.setOutcome(org.gradle.api.internal.tasks.TaskExecutionOutcome.UP_TO_DATE)
            didWork = false
            return
        }
        project.ant.invokeMethod('signjar', args)
    }
}

javadoc {
    options.addBooleanOption("Xdoclint:none", true)
}

publishing {
    repositories {
        if (System.getenv('MAVEN_PASS')) {
            maven {
                url "https://nexus.covers1624.net/repository/maven-releases/"
                credentials {
                    username 'covers1624'
                    password System.getenv('MAVEN_PASS')
                }
            }
        }
    }

    publications {
        CodeChickenLib(MavenPublication) {
            groupId project.group
            artifactId project.base.archivesName.get()
            version project.version

            from components['java']

            artifact(publishingMetadata) {
                builtBy publishingMetadataTask
                classifier 'publishing'
            }

            pom {
                name = base.archivesName.get()
                description = base.archivesName.get()
                url = "https://github.com/TheCBProject/${base.archivesName.get()}"
                scm {
                    url = "https://github.com/TheCBProject/${base.archivesName.get()}"
                    connection = "scm:git:git@github.com:TheCBProject/${base.archivesName.get()}.git"
                }

                issueManagement {
                    system = 'github'
                    url = "https://github.com/TheCBProject/${base.archivesName.get()}/issues"
                }
                licenses {
                    license {
                        name = "GNU Lesser Public License (GPL), Version 2.1"
                        url = "https://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt"
                        distribution = 'repo'
                    }
                }
                developers {
                    developer {
                        id = 'covers1624'
                        name = 'covers1624'
                    }
                }
                developers {
                    developer {
                        id = 'chicken-bones'
                        name = 'chicken-bones'
                    }
                }
            }
        }
    }
}

signing {
    if (System.getenv('GPG_PRIVATE_KEY')) {
        useInMemoryPgpKeys(
                new File(System.getenv('GPG_PRIVATE_KEY')).text,
                System.getenv('GPG_PRIVATE_KEY_PASS')
        )
    } else if (project.hasProperty('gpgPrivateKey')) {
        useInMemoryPgpKeys(
                new File(project.getProperty('gpgPrivateKey')).text,
                project.getProperty('gpgPrivateKeyPass')
        )
    } else {
        return
    }
    sign publishing.publications.CodeChickenLib
}