build.gradle

/*
 * This file is part of Applied Energistics 2.
 * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
 *
 * Applied Energistics 2 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Applied Energistics 2 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
 */

plugins {
    id "net.neoforged.gradle.userdev"
    id "maven-publish"
    id "com.diffplug.spotless"
    id "com.github.johnrengelman.shadow"
    id "de.undercouch.download"
}

evaluationDependsOn(":libs:markdown")

sourceSets {
    main {
        java {
            srcDir 'src/main/flatbuffers/generated'
            exclude "**/integration/modules/jei/**"
        }
        resources {
            srcDir 'src/generated/resources'
        }
    }
    test {
    }
    buildtools
}

configurations {
    shaded {
        transitive = false
    }
    buildtoolsImplementation.extendsFrom(compileClasspath)

    internal {
        visible = false
        canBeConsumed = false
        canBeResolved = false
    }
    configurations.compileClasspath.extendsFrom(internal)
    configurations.runtimeClasspath.extendsFrom(internal)
    configurations.testCompileClasspath.extendsFrom(internal)
    configurations.testRuntimeClasspath.extendsFrom(internal)
}

dependencies {
    // To be copied into the jar file
    shaded project(path: ':libs:markdown', configuration: "archives")
    shaded "io.methvin:directory-watcher:${directory_watcher_version}"
    shaded "org.yaml:snakeyaml:${snakeyaml_version}"
    shaded "com.google.flatbuffers:flatbuffers-java:${flatbuffers_version}"

    implementation(project(':libs:markdown')) {
        transitive = false
    }
    // Do not inherit any transitive dependencies here since we rely on those dependencies being
    // present in Minecrafts own dependencies already.
    implementation("io.methvin:directory-watcher:${directory_watcher_version}") {
        transitive = false
    }
    implementation("org.yaml:snakeyaml:${snakeyaml_version}") {
        transitive = false
    }
    implementation("com.google.flatbuffers:flatbuffers-java:${flatbuffers_version}") {
        transitive = false
    }
    // Used for the guide export
    implementation("org.bytedeco:ffmpeg-platform:6.0-1.5.9")

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

    // compile against provided APIs
    compileOnly "mezz.jei:jei-${jei_minecraft_version}-common-api:${jei_version}"
    compileOnly "mezz.jei:jei-${jei_minecraft_version}-forge-api:${jei_version}"

    // Always depend on the REI API to compile
    if (project.runtime_itemlist_mod == "jei") {
        runtimeOnly "mezz.jei:jei-${jei_minecraft_version}-forge:${jei_version}"

        compileOnly("me.shedaniel:RoughlyEnoughItems-neoforge:${project.rei_version}")
    } else if (project.runtime_itemlist_mod == "rei") {
        implementation("dev.architectury:architectury-neoforge:10.0.16")
        implementation("me.shedaniel:RoughlyEnoughItems-neoforge:${project.rei_version}")
    } else {
        compileOnly("me.shedaniel:RoughlyEnoughItems-neoforge:${project.rei_version}")
    }

    compileOnly "mcp.mobius.waila:wthit-api:neo-${project.wthit_version}"
    if (project.runtime_tooltip_mod == "wthit") {
        runtimeOnly("mcp.mobius.waila:wthit:neo-${project.wthit_version}")
    }

    if (project.runtime_tooltip_mod == "jade") {
        implementation("curse.maven:jade-324717:${project.jade_file_id}")
    } else {
        compileOnly("curse.maven:jade-324717:${project.jade_file_id}")
    }

    def topDependency = "curse.maven:the-one-probe-245211:4159743"
    if (project.runtime_tooltip_mod == "top") {
        implementation(topDependency)
    } else {
        compileOnly topDependency
    }

    // unit test dependencies
    testImplementation(platform("org.junit:junit-bom:${project.junit_version}"))
    testRuntimeOnly(project(":libs:junit"))
    testImplementation("org.junit.jupiter:junit-jupiter-api")
    testImplementation("org.junit.jupiter:junit-jupiter-params")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
    testImplementation("org.junit.platform:junit-platform-launcher")
    testImplementation("org.assertj:assertj-core:3.19.0")
    testImplementation("com.google.guava:guava-testlib:21.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.3.1")
    testImplementation("cpw.mods:securejarhandler:2.1.20")

    compileOnly 'org.apache.commons:commons-configuration2:2.9.0'
}
archivesBaseName = artifact_basename

allprojects {
    group = artifact_group

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }

    // ensure everything uses UTF-8 and not some random codepage chosen by gradle
    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8'
        options.deprecation = false
        options.compilerArgs << "-Xmaxerrs" << "9999"
    }
}

repositories {
    mavenLocal()
    mavenCentral()
    maven {
        url "https://maven.shedaniel.me/"
        content {
            includeGroup "me.shedaniel"
            includeGroup "me.shedaniel.cloth"
            includeGroup "dev.architectury"
        }
    }
    maven {
        url "https://maven2.bai.lol"
        content {
            includeGroup "mcp.mobius.waila"
            includeGroup "lol.bai"
        }
    }
    maven {
        name 'modmaven'
        url "https://modmaven.dev/"
        content {
            includeGroup "mezz.jei"
        }
    }
    maven {
        name 'cursemaven'
        url "https://www.cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
    maven { // for TOP
        url "https://maven.k-4u.nl/"
        content {
            includeGroup "mcjty"
        }
    }
}

///////////////////
// Version Number
version = version_major + "." + version_minor + "." + version_patch

ext.pr = System.getenv('PR_NUMBER') ?: ""
if (ext.pr) {
    version = version + "+pr." + ext.pr
}

ext.branch = System.getenv('BRANCH') ?: ""
if (ext.branch) {
    version = version + "+branch." + ext.branch
}

ext.tag = System.getenv('TAG') ?: ""
if (ext.tag) {
    if (!ext.tag.startsWith("neoforge/v")) {
        throw new GradleException("Tags for the neoforge version should start with neoforge/: ${ext.tag}")
    }

    version = ext.tag.substring("neoforge/v".length())
    // Validate that the rest is a semver version
    if (version ==~ /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/) {
        if (System.getenv("GITHUB_ENV")) {
            def envFile = new File(System.getenv("GITHUB_ENV"))
            envFile.append("VERSION=${version}")
        }
    } else {
        throw new GradleException("Invalid semver: $version")
    }
}

ext.isAlpha = project.version.contains("alpha")
ext.isBeta = project.version.contains("beta")

test {
    useJUnitPlatform()

    // Might not need this anymore...
    systemProperty "guideDev.ae2guide.sources", file("guidebook").absolutePath

    def aeDir = project.rootDir.absolutePath
    environment(
            "MOD_CLASSES",
            // In Gradle 9, replace with a provider
            List.of(
                    "${project.buildDir}/classes/java/main",
                    "${project.buildDir}/classes/java/test",
                    "${project.buildDir}/resources/main",
                    "${project.buildDir}/resources/test",
            ).stream().map {
                "ae2%%" + it
            }.collect(Collectors.joining(File.pathSeparator))
    )

    def fmlVersion = "1.0.16"

    environment("fmljunit.assetsDir", new File(gradle.gradleUserHomeDir, "caches/minecraft/assets/${minecraft_version}/").absolutePath)
    environment("fmljunit.neoForgeVersion", neoforge_version)
    environment("fmljunit.fmlVersion", fmlVersion)
    environment("fmljunit.mcVersion", minecraft_version)
    environment("fmljunit.neoFormVersion", "20231019.002635")

    jvmArgumentProviders.add(new CommandLineArgumentProvider() {
        @Override
        Iterable<String> asArguments() {
            return [
                    "--module-path",
                    test.classpath
                            .filter {
                                it.name.contains("bootstraplauncher")
                                        || it.name.contains("securejarhandler")
                                        || it.name.contains("asm")
                                        || it.name.contains("JarJarFileSystems")
                                        || it.name.startsWith("mockito")
                                        || it.name.startsWith("junit-jupiter")
                                        || it.name.startsWith("junit-platform")
                                        || it.name.startsWith("opentest4j")
                                        || it.name.startsWith("assertj-")
                                        || it.name.startsWith("guava-testlib-")
                            }
                            .join(File.pathSeparator)
            ]
        }
    })

    doFirst {
        var classPathLines = tasks.writeMinecraftClasspath.output.asFile.get().readLines()
        classPathLines.addAll(test.classpath
                .filter { it.name.startsWith("fmljunit") })
        new File("$aeDir/build/test_classpath.txt").text = classPathLines.join("\n")
    }

    jvmArgs = [
            "-DignoreList=junit,securejarhandler,asm,asm-commons,asm-tree,asm-util,asm-analysis,bootstraplauncher,JarJarFileSystems,events-${fmlVersion}.jar,core-${fmlVersion}.jar,language-java,language-lowcode,language-minecraft,client-extra,neoforge-,mixinextras-",
            "--add-modules",
            "ALL-MODULE-PATH",
            "--add-opens", "java.base/java.util.jar=cpw.mods.securejarhandler",
            "--add-opens", "java.base/java.lang.invoke=cpw.mods.securejarhandler",
            "--add-exports", "java.base/sun.security.util=cpw.mods.securejarhandler",
            "--add-exports", "jdk.naming.dns/com.sun.jndi.dns=java.naming",
            "-DlegacyClassPath.file=$aeDir/build/test_classpath.txt",
            "-Dfml.gameLayerLibraries=events-${fmlVersion}.jar",
            "-DmergeModules=jna-5.10.0.jar,jna-platform-5.10.0.jar",
            "-Djava.net.preferIPv6Addresses=system",
            "-Dfml.pluginLayerLibraries=core-${fmlVersion}.jar,language-java-${fmlVersion}.jar,language-lowcode-${fmlVersion}.jar,language-minecraft-${fmlVersion}.jar",
    ]
}

//tasks.named('test').configure {
//    it.inputs.file(tasks.named('writeMinecraftClasspath').map { it.outputs.files.singleFile })
//}

dependencies {
    buildtoolsImplementation 'de.siegmar:fastcsv:2.1.0'
    buildtoolsImplementation 'com.google.code.gson:gson:2.8.9'
}

/**
 * Configures properties common to all run configurations
 */
def commonSystemProperties = [
        'forge.logging.console.level': 'debug',
        'fml.earlyprogresswindow'    : 'false',
        'appeng.tests'               : 'true',
]

// NG hacks to add our deps to the legacy classpath
// If anything changes here you have to delete the build folder for the neoforge:...:writeMinecraftClasspath task
import net.neoforged.gradle.userdev.runtime.tasks.ClasspathSerializer

import java.util.stream.Collectors

def libSrcSets = [
        project(":libs:markdown").sourceSets.main
]

def legacyCPLibs = [
        "io.methvin:directory-watcher:${directory_watcher_version}",
        "org.yaml:snakeyaml:${snakeyaml_version}",
        "com.google.flatbuffers:flatbuffers-java:${flatbuffers_version}",
]

tasks.withType(ClasspathSerializer).configureEach {
    legacyCPLibs.each { lib ->
        def libArtifact = lib.split(":")[1]
        def libVersion = lib.split(":")[2]
        def libJar = libArtifact + "-" + libVersion + ".jar"

        def libFile = project.configurations.runtimeClasspath.find({
            return it.name == libJar
        })

        it.inputFiles.from libFile
    }
    project.configurations.runtimeClasspath.each({f ->
        if (f.name.startsWith("javacpp") || f.name.startsWith("ffmpeg")) {
            it.inputFiles.from f
        }
    })
    libSrcSets.each { srcSet ->
        it.inputFiles.from srcSet.output
    }
}

def commonRunProperties = {
    workingDirectory = project.file('run')
    systemProperties = commonSystemProperties
    // property "mixin.debug.export", "true"
    modSources = [sourceSets.main]
}

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

runs {
    client {
        with commonRunProperties
        systemProperties = [
                *                          : commonSystemProperties,
                "appeng.tests"             : "true",
                "guideDev.ae2guide.sources": file("guidebook").absolutePath,
        ]
    }
    gametestWorld {
        configure("client")
        with commonRunProperties
        programArguments("--username", "AE2Dev", "--quickPlaySingleplayer", "GametestWorld")
        systemProperties = [
                "appeng.tests"             : "true",
                "guideDev.ae2guide.sources": file("guidebook").absolutePath,
        ]
    }
    guide {
        with commonRunProperties
        configure("client")
        systemProperties = [
                "guideDev.ae2guide.sources"    : file("guidebook").absolutePath,
                "guideDev.ae2guide.startupPage": "ae2:index.md"
        ]
    }
    server {
        with commonRunProperties
    }
    data {
        with commonRunProperties
        programArguments = [
                '--mod', 'ae2',
                '--all',
                '--output', file('src/generated/resources/').absolutePath,
                '--existing', file('src/main/resources').absolutePath
        ]
    }
    guideexport {
        with commonRunProperties
        configure("client")
        systemProperties = [
                "appeng.runGuideExportAndExit": "true",
                "appeng.guideExportFolder"    : file("$buildDir/guide").absolutePath,
                "guideDev.ae2guide.sources"   : file("guidebook").absolutePath
        ]
    }
    // Use to run the tests
    gametest {
        configure("gameTestServer")
        with commonRunProperties
        workingDirectory = project.file("build/gametest")
    }
}

//////////////
// Artifacts
processResources {
    exclude '.cache'

    filesMatching("META-INF/mods.toml") {
        expand 'minecraft_version': project.minecraft_version_range, 'neoforge_version': project.neoforge_version_range,
                'jei_version': project.jei_version_range, 'top_version': project.top_version_range,
                'jade_version': project.jade_version_range
        filter { line ->
            line.replace('version="0.0.0"', "version=\"$version\"")
        }
    }
}

jar {
    finalizedBy shadowJar
    archiveClassifier = "plain"
}

shadowJar {
    from sourceSets.main.output.classesDirs
    from sourceSets.main.output.resourcesDir

    from('guidebook') {
        into 'assets/ae2/ae2guide'
    }

    manifest {
        attributes([
                "Specification-Title"   : "Applied Energistics 2",
                "Specification-Vendor"  : "TeamAppliedEnergistics",
                "Specification-Version" : "${project.version}",
                "Implementation-Title"  : "${project.name}",
                "Implementation-Version": "${project.version}",
                "Implementation-Vendor" : "TeamAppliedEnergistics",
        ])
    }

    relocate "io.methvin", "appeng.shaded.methvin"
    relocate "org.yaml.snakeyaml", "appeng.shaded.snakeyaml"

    configurations = [project.configurations.shaded]
    archiveClassifier = null
}

assemble.dependsOn shadowJar

def publicApiIncludePatterns = {
    exclude "**/*Internal.*"
    exclude "**/*Internal\$*.*"
    include "appeng/api/**"
}

javadoc {
    source = sourceSets.main.allJava
    classpath = sourceSets.main.compileClasspath + sourceSets.main.output

    options.addStringOption('Xdoclint:none', '-quiet')
    options.encoding = 'UTF-8'
    options.charSet = 'UTF-8'
}
javadoc publicApiIncludePatterns

task javadocJar(type: Jar, dependsOn: javadoc, group: "build") {
    archiveClassifier = "javadoc"
    from javadoc.destinationDir
}

task sourcesJar(type: Jar) {
    archiveClassifier = "sources"
    from sourceSets.main.allJava
}

task apiJar(type: Jar, group: "build") {
    archiveClassifier = "api"
    // api jar ist just a development aid and serves as both a binary and source jar simultaneously
    from sourceSets.main.output
    from sourceSets.main.allJava
    manifest {
        attributes("Fabric-Loom-Remap": true)
    }
}
apiJar publicApiIncludePatterns

artifacts {
    archives javadocJar
    archives sourcesJar
    archives apiJar
}

//////////////////
// Maven publish
publishing {
    publications {
        maven(MavenPublication) {
            groupId = project.group
            artifactId = project.archivesBaseName
            version = project.version

            artifact shadowJar
            artifact sourcesJar
            artifact javadocJar
            artifact apiJar
        }
    }
    repositories {
        maven {
            credentials {
                username System.getenv("GITHUB_ACTOR")
                password System.getenv("GITHUB_TOKEN")
            }
            name = "GitHubPackages"
            url = "https://maven.pkg.github.com/AppliedEnergistics/Applied-Energistics-2"
        }
        maven {
            credentials {
                username System.getenv("MODMAVEN_USER")
                password System.getenv("MODMAVEN_PASSWORD")
            }
            name = "modmaven"
            url = "https://modmaven.dev/artifactory/local-releases/"
        }
    }
}

/////////////
// Spotless
spotless {

    java {
        target 'src/*/java/appeng/**/*.java'

        endWithNewline()
        indentWithSpaces()
        removeUnusedImports()
        toggleOffOn()
        eclipse().configFile 'codeformat/codeformat.xml'
        importOrderFile 'codeformat/ae2.importorder'

        // courtesy of diffplug/spotless#240
        // https://github.com/diffplug/spotless/issues/240#issuecomment-385206606
        custom 'noWildcardImports', {
            if (it.contains('*;\n')) {
                throw new Error('No wildcard imports allowed')
            }
        }
        bumpThisNumberIfACustomStepChanges(1)
    }

    format 'json', {
        target 'src/*/resources/**/*.json'
        targetExclude 'src/generated/resources/**'
        prettier().config(['parser': 'json'])
    }
}

////////////////
// Crowdin
task uploadToCrowdin(type: JavaExec) {
    classpath = sourceSets.buildtools.runtimeClasspath
    mainClass = 'Crowdin'
    args 'upload_source'
    workingDir "."
}
task uploadTranslations(type: JavaExec) {
    classpath = sourceSets.buildtools.runtimeClasspath
    mainClass = 'Crowdin'
    args 'upload_translations'
    workingDir "."
}
task downloadFromCrowdin(type: JavaExec) {
    classpath = sourceSets.buildtools.runtimeClasspath
    mainClass = 'Crowdin'
    args 'update_translations'
    workingDir "."
}

// See https://github.com/AppliedEnergistics/Applied-Energistics-2/issues/5259
// Gradle module metadata contains mapped dependencies, making our artifacts unconsumable
tasks.withType(GenerateModuleMetadata) {
    enabled = false
}

check.dependsOn tasks.register('validateResources', JavaExec) {
    group = "verification"
    classpath = sourceSets.buildtools.runtimeClasspath
    mainClass = 'ValidateResourceIds'
    workingDir "."
    args "guidebook"
}

/**
 * This task download the FlatBuffers compiler suitable for the current platform.
 */
tasks.register('downloadFlatbufferCompiler', Download) {
    var os = System.getProperty("os.name").toLowerCase(Locale.ROOT)
    var arch = System.getProperty("os.arch")
    if (os.startsWith("windows")) {
        src "https://github.com/google/flatbuffers/releases/download/v${flatbuffers_version}/Windows.flatc.binary.zip"
    } else if (os.startsWith("mac")) {
        if (arch == "aarch64") {
            src "https://github.com/google/flatbuffers/releases/download/v${flatbuffers_version}/Mac.flatc.binary.zip"
        } else if (arch == "amd64") {
            src "https://github.com/google/flatbuffers/releases/download/v${flatbuffers_version}/MacIntel.flatc.binary.zip"
        } else {
            throw new GradleException("Unknown Mac architecture: $arch")
        }
    } else if (os.startsWith("linux")) {
        src "https://github.com/google/flatbuffers/releases/download/v${flatbuffers_version}/Linux.flatc.binary.clang++-12.zip"
    } else {
        throw new GradleException("Unknown OS: $os")
    }
    onlyIfModified true
    dest "${project.buildDir}/flatc.zip"
}

tasks.register('downloadAndUnzipFlatbufferCompiler', Copy) {
    dependsOn downloadFlatbufferCompiler
    from zipTree(downloadFlatbufferCompiler.dest)
    into "${project.buildDir}/flatbuffers-bin"
}
/**
 * Update the generated Java Code for our scene export schema.
 * The code is checked in so this only needs to be run when the schema changes.
 */
tasks.register('updateFlatbufferSources', Exec) {
    group 'build'
    dependsOn downloadAndUnzipFlatbufferCompiler
    workingDir project.projectDir
    commandLine "${project.buildDir}/flatbuffers-bin/flatc",
            "--gen-mutable",
            "--java-package-prefix", "appeng.flatbuffers",
            "--gen-generated",
            "--java",
            "-o",
            "${project.projectDir}/src/main/flatbuffers/generated",
            "${project.projectDir}/src/main/flatbuffers/scene.fbs"

    doFirst {
        file("${project.projectDir}/src/main/flatbuffers/generated").deleteDir()
    }
    doLast {
    }
    doLast {
        // sadly flatc uses an outdated annotation
        def folder = file("${project.projectDir}/src/main/flatbuffers/generated")
        folder.eachFileRecurse(groovy.io.FileType.FILES) { file ->
            String content = file.text
            if (content.contains('@javax.annotation.Generated')) {
                content = content.replace('@javax.annotation.Generated', '@javax.annotation.processing.Generated')
                file.write(content)
            }
        }
    }
}

/**
 * Generate the TypeScript sources for our schema. The sources are manually copied
 * over to the website repository.
 */
tasks.register('updateFlatbufferTypescriptSources', Exec) {
    group 'build'
    dependsOn downloadAndUnzipFlatbufferCompiler
    workingDir project.projectDir
    commandLine "${project.buildDir}/flatbuffers-bin/flatc",
            "--ts-flat-files",
            "--ts",
            "-o",
            "${project.buildDir}/scene-ts",
            "${project.projectDir}/src/main/flatbuffers/scene.fbs"

    doFirst {
        file("${project.buildDir}/scene-ts").deleteDir()
    }
}