build.gradle

plugins {
    id 'net.neoforged.gradle.userdev' version '7.0.145'
    id 'net.darkhax.curseforgegradle' version '1.0.8'
    id 'com.github.kt3k.coveralls' version '2.12.0'
    id 'com.diffplug.spotless' version '6.25.0'
	id 'com.modrinth.minotaur' version '2.+'
}

apply plugin: 'idea'
apply plugin: 'maven-publish'
apply plugin: 'jacoco'

import net.neoforged.gradle.common.tasks.PotentiallySignJar
import net.darkhax.curseforgegradle.Constants
import net.darkhax.curseforgegradle.TaskPublishCurseForge

// Determine build number
String build_number = "DEV" // this will be referenced as simply build_number from now on.
if (System.getenv().BUILD_NUMBER)
    build_number = System.getenv().BUILD_NUMBER
if (System.getenv().GITHUB_RUN_ID)
    build_number = System.getenv().GITHUB_RUN_NUMBER
if (System.getenv().RELEASE)
    build_number = "RELEASE"
logger.lifecycle "BUILDING VERSION: " + build_number

// Include build number in version
if (build_number.equals("RELEASE"))
    version = "${project.mod_version}"
else
    version = "${project.mod_version}-${build_number}"

base {
    archivesName = "${mod_id}-${minecraft_version}-neoforge"
}

java {
    toolchain.languageVersion = JavaLanguageVersion.of(java_version)
}
compileJava.options.compilerArgs << "-Xmaxerrs" << "9999"

// Load secrets
def getSecrets() {
    Properties props = new Properties()
    if (file('./secrets.properties').exists()) {
        props.load(new FileInputStream(file('./secrets.properties')))
    }
    return props
}
def getCurseforgeKey() {
    if(secrets.curseforge_key) {
        return secrets.curseforge_key
    } else if(System.getenv().GITHUB_ACTIONS && System.getenv().CURSEFORGE_KEY_SECRET) {
        return System.getenv().CURSEFORGE_KEY_SECRET
    } else {
        return "DUMMY"
    }
}
def getModrinthKey() {
    if(secrets.modrinth_key) {
        return secrets.modrinth_key
    } else if(System.getenv().GITHUB_ACTIONS && System.getenv().MODRINTH_KEY_SECRET) {
        return System.getenv().MODRINTH_KEY_SECRET
    } else {
        return "DUMMY"
    }
}
def getChangelog() {
    if (System.getenv().RELEASE) {
        return file("./resources/changelog/${project.minecraft_version}-${project.mod_version}.txt").getText();
    } else {
        return "Changes since last release: ${project.github_url}/compare/${project.minecraft_version}-${project.mod_version}...${System.getenv().GITHUB_SHA}"
    }
}
//ext {
    Properties secrets = getSecrets();
    secrets.curseforgeKey = getCurseforgeKey();
    secrets.modrinthKey = getModrinthKey();
    secrets.changelog = getChangelog();
    secrets.build_number = build_number;
//}

sourceSets {
    main
    test
    test_vanilla_capability_entityitem {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
    test_vanilla_capability_inventorystate {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
    test_vanilla_capability_itemitemhandler {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
    test_vanilla_capability_recipehandler {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
    test_vanilla_capability_temperature {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
    test_vanilla_capability_worker {
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
        resources { srcDir 'src/test_common/resources' }
    }
}
sourceSets.main.resources { srcDir 'src/generated/resources' }

configurations {
    test_vanilla_capability_entityitemImplementation.extendsFrom(implementation)
    test_vanilla_capability_entityitemRuntimeOnly.extendsFrom(runtimeOnly)
    test_vanilla_capability_inventorystateImplementation.extendsFrom(implementation)
    test_vanilla_capability_inventorystateRuntimeOnly.extendsFrom(runtimeOnly)
    test_vanilla_capability_itemitemhandlerImplementation.extendsFrom(implementation)
    test_vanilla_capability_itemitemhandlerRuntimeOnly.extendsFrom(runtimeOnly)
    test_vanilla_capability_recipehandlerImplementation.extendsFrom(implementation)
    test_vanilla_capability_recipehandlerRuntimeOnly.extendsFrom(runtimeOnly)
    test_vanilla_capability_temperatureImplementation.extendsFrom(implementation)
    test_vanilla_capability_temperatureRuntimeOnly.extendsFrom(runtimeOnly)
    test_vanilla_capability_workerImplementation.extendsFrom(implementation)
    test_vanilla_capability_workerRuntimeOnly.extendsFrom(runtimeOnly)

    javadoc.classpath += sourceSets.test_vanilla_capability_entityitem.output
    javadoc.classpath += sourceSets.test_vanilla_capability_inventorystate.output
    javadoc.classpath += sourceSets.test_vanilla_capability_itemitemhandler.output
    javadoc.classpath += sourceSets.test_vanilla_capability_recipehandler.output
    javadoc.classpath += sourceSets.test_vanilla_capability_temperature.output
    javadoc.classpath += sourceSets.test_vanilla_capability_worker.output
}

processTest_vanilla_capability_entityitemResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE
processTest_vanilla_capability_inventorystateResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE
processTest_vanilla_capability_itemitemhandlerResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE
processTest_vanilla_capability_recipehandlerResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE
processTest_vanilla_capability_temperatureResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE
processTest_vanilla_capability_workerResources.duplicatesStrategy = DuplicatesStrategy.INCLUDE

repositories {
    mavenCentral()
	mavenLocal()
    maven {
        name "Cyclops Repo"
        url "https://maven.pkg.github.com/CyclopsMC/packages"
        credentials {
            username = project.findProperty("gpr.user") ?: System.getenv("MAVEN_USERNAME") ?: System.getenv("GITHUB_USER")
            password = project.findProperty("gpr.key") ?: System.getenv("MAVEN_KEY") ?: System.getenv("GITHUB_TOKEN")
        }
    }
}

dependencies {
    implementation "net.neoforged:neoforge:${project.neoforge_version}"

    // Add something like 'cyclopscore_version_local=0.1.0-DEV' to your secrets.properties if you want to use a custom local CyclopsCore version.
    if (secrets.cyclopscore_version_local) {
        implementation "org.cyclops.cyclopscore:cyclopscore-${project.minecraft_version}-neoforge:${secrets.cyclopscore_version_local}:deobf"
    } else {
        implementation "org.cyclops.cyclopscore:cyclopscore-${project.minecraft_version}-neoforge:${project.cyclopscore_version}:deobf"
    }
	
	// TODO: port mod dependencies once they update

    // Project lombok
	compileOnly 'org.projectlombok:lombok:1.18.30'
	annotationProcessor 'org.projectlombok:lombok:1.18.30'
	testCompileOnly 'org.projectlombok:lombok:1.18.30'
	testAnnotationProcessor 'org.projectlombok:lombok:1.18.30'
    testImplementation "junit:junit:4.12"
    testImplementation "org.mockito:mockito-core:1.+"
}

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

subsystems {
    parchment {
        minecraftVersion = "${project.parchment_minecraft_version}"
        mappingsVersion = "${project.parchment_version}"
    }
}

runs {
    configureEach {
		systemProperty 'forge.logging.markers', 'REGISTRIES'
        systemProperty 'forge.logging.console.level', 'debug'
        modSource project.sourceSets.main
		modSource project.sourceSets.test_vanilla_capability_entityitem
		modSource project.sourceSets.test_vanilla_capability_inventorystate
		modSource project.sourceSets.test_vanilla_capability_itemitemhandler
		modSource project.sourceSets.test_vanilla_capability_recipehandler
		modSource project.sourceSets.test_vanilla_capability_temperature
		modSource project.sourceSets.test_vanilla_capability_worker
    }
	
    client {
        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
    }

    server {
        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
        programArgument '--nogui'
    }

    gameTestServer {
        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
    }

    data {
        programArguments.addAll '--all', '--validate',
                '--mod', project.mod_id,
                '--mod', 'test_vanilla_capability_entityitem',
                '--mod', 'test_vanilla_capability_inventorystate',
                '--mod', 'test_vanilla_capability_itemitemhandler',
                '--mod', 'test_vanilla_capability_recipehandler',
                '--mod', 'test_vanilla_capability_temperature',
                '--mod', 'test_vanilla_capability_worker',
                '--output', file('src/generated/resources/').getAbsolutePath(),
                '--existing', file('src/main/resources/').getAbsolutePath()
    }
}

jar {
    manifest {
        attributes([
                "FMLAT": "accesstransformer.cfg",
                "Specification-Title": "${project.name}",
                "Specification-Vendor": "rubensworks",
                "Specification-Version": "${project.mod_version}",
                "Implementation-Title": "${project.name}",
                "Implementation-Version": "${project.mod_version}",
                "Implementation-Vendor" :"rubensworks",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

task signJar(type: PotentiallySignJar, dependsOn: jar) {
	dependsOn(tasks.jar)

    onlyIf {
        System.getenv().SIGN_KEYSTORE
    }

    keyStore = System.getenv().SIGN_KEYSTORE
    alias = System.getenv().SIGN_ALIAS
    storePass = System.getenv().SIGN_STOREPASS
    keyPass = System.getenv().SIGN_KEYPASS
    input = jar.archivePath
    output = jar.archivePath
}

task deobfJar(type: Jar) {
    from sourceSets.main.output
    archiveClassifier.set('deobf')
    manifest {
        attributes([
                "FMLAT": "accesstransformer.cfg",
                "Specification-Title": "${project.name}",
                "Specification-Vendor": "rubensworks",
                "Specification-Version": "${project.mod_version}",
                "Implementation-Title": "${project.name}",
                "Implementation-Version": "${project.mod_version}",
                "Implementation-Vendor" :"rubensworks",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

task apiJar(type: Jar) {
    from sourceSets.main.output
    from sourceSets.main.java
    archiveClassifier.set('api')
    include 'commoncapabilities/api/**'
}

task sourcesJar(type: Jar) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveClassifier.set('sources')
    from sourceSets.main.allJava
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    duplicatesStrategy(DuplicatesStrategy.FAIL)
    archiveClassifier.set('javadoc')
    from javadoc.destinationDir
}

artifacts {
    archives deobfJar
	archives apiJar
    archives sourcesJar
    archives javadocJar
}

// Replace properties in files
processResources {
    def expandProps = [
            'mod_version'                           : mod_version,
            'group'                                 : project.group, //Else we target the task's group.
            'minecraft_version'                     : minecraft_version,
            'mod_name'                              : mod_name,
            'mod_author'                            : mod_author,
            'mod_id'                                : mod_id,
            'license'                               : license,
            'issue_tracker_url'                     : issue_tracker_url,
            'display_url'                           : display_url,
            'description'                           : project.description,
            'neoforge_version'                      : neoforge_version,
            'neoforge_loader_version_range'         : neoforge_loader_version_range,
            'neoforge_update_json_url'              : neoforge_update_json_url,
            'java_version'                          : java_version,
            'cyclopscore_version'                   : cyclopscore_version,
            'cyclopscore_version_semver'            : cyclopscore_version.replaceAll("-.*\$", ""),
    ]

    filesMatching(['pack.mcmeta', 'META-INF/mods.toml', 'META-INF/neoforge.mods.toml', 'mixins.*.json']) {
        expand expandProps
    }
    inputs.properties(expandProps)
}

task publishCurseForge(type: TaskPublishCurseForge) {
    dependsOn(tasks.jar)
    apiToken = secrets.curseforgeKey;
    def mainFile = upload(project.curseforge_project_id, jar)
    mainFile.releaseType = secrets.build_number.equals("RELEASE") ? Constants.RELEASE_TYPE_RELEASE : Constants.RELEASE_TYPE_BETA
    mainFile.changelogType = "text"
    mainFile.changelog = secrets.changelog
    mainFile.addJavaVersion("Java ${project.java_version}")
    mainFile.addGameVersion(project.minecraft_version)
    mainFile.addModLoader("NeoForge")

    mainFile.addRequirement("cyclops-core")
}

modrinth {
    token = secrets.modrinthKey;
    projectId = "${modrinth_project_id}"
    versionNumber = project.minecraft_version + '-' + project.version
    versionName = "${project.version} for NeoForge ${project.minecraft_version}"
    versionType = secrets.build_number.equals("RELEASE") ? "release" : "beta"
    uploadFile = jar
    gameVersions = [ project.minecraft_version ]
    changelog = provider { secrets.changelog }

    dependencies {
        required.project "Z9DM0LJ4" // Cyclops Core
    }
}

publishing {
    repositories {
        if (project.hasProperty("filesmaven_url")) {
            logger.info('Publishing to files server')
            maven {
                url project.filesmaven_url
                credentials {
                    username = project.filesmaven_username
                    password = project.filesmaven_key
                }
            }
        } else if (System.getenv("MAVEN_URL")) {
            logger.info('Publishing to files server')
            maven {
                url System.getenv("MAVEN_URL")
                credentials {
                    username = System.getenv("MAVEN_USERNAME")
                    password = System.getenv("MAVEN_KEY")
                }
            }
        } else {
            logger.error('No maven repo was set!')
        }
    }

    publications { PublicationContainer publicationContainer ->
        publicationContainer.register("maven", MavenPublication) { MavenPublication publication ->
            publication.artifacts = [jar, javadocJar, deobfJar, sourcesJar]
            publication.artifactId = project.archivesBaseName.toLowerCase() // GH can't handle uppercase...
        }
    }
}

idea {
    module {
        downloadSources = true
        downloadJavadoc = true
        for (String excludeDirName in ["run", "out", "logs", "gradle"]) {
            File excludeDir = new File(projectDir, excludeDirName)
            excludeDirs.add(excludeDir)
        }
    }
}

jacocoTestReport {
    reports {
        xml.required = true
        html.required = true
    }
}

spotless {
    java {
        target project.fileTree(project.rootDir) {
            include '**/java/org/cyclops/**/*.java'
        }

        endWithNewline()
        trimTrailingWhitespace()
        removeUnusedImports()
    }
}
spotlessJava.mustRunAfter(compileTest_vanilla_capability_entityitemJava)
spotlessJava.mustRunAfter(compileTest_vanilla_capability_inventorystateJava)
spotlessJava.mustRunAfter(compileTest_vanilla_capability_itemitemhandlerJava)
spotlessJava.mustRunAfter(compileTest_vanilla_capability_recipehandlerJava)
spotlessJava.mustRunAfter(compileTest_vanilla_capability_temperatureJava)
spotlessJava.mustRunAfter(compileTest_vanilla_capability_workerJava)
spotlessJava.mustRunAfter(processTest_vanilla_capability_entityitemResources)
spotlessJava.mustRunAfter(processTest_vanilla_capability_inventorystateResources)
spotlessJava.mustRunAfter(processTest_vanilla_capability_itemitemhandlerResources)
spotlessJava.mustRunAfter(processTest_vanilla_capability_recipehandlerResources)
spotlessJava.mustRunAfter(processTest_vanilla_capability_temperatureResources)
spotlessJava.mustRunAfter(processTest_vanilla_capability_workerResources)
spotlessJava.mustRunAfter(javadoc)
spotlessJava.mustRunAfter(compileTestJava)
spotlessJava.mustRunAfter(test)

tasks.register('updateGitHooks', Copy) {
    from './scripts/pre-commit'
    into './.git/hooks'
}
compileJava.dependsOn updateGitHooks

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
}

// The following is required to fix running unit tests during build phase
tasks.configureEach { task ->
    if (task.name.startsWith("test")) {
        task.enabled = true
    }
    if (task.name.startsWith("testJunit")) {
        task.enabled = false
    }
}