FalsePatternLib/build.gradle

//version: 1641429628falsepattern16
/*
DO NOT CHANGE THIS FILE!

Also, you may replace this file at any time if there is an update available.
Please check https://github.com/FalsePattern/ExampleMod1.7.10/blob/main/build.gradle for updates.
 */


import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

import java.util.concurrent.TimeUnit

buildscript {
    repositories {
        maven {
            name = "forge"
            url = "https://maven.minecraftforge.net"
        }
        maven {
            name = "sonatype"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
        maven {
            name = "Scala CI dependencies"
            url = "https://repo1.maven.org/maven2/"
        }
        maven {
            name = "jitpack"
            url = "https://jitpack.falsepattern.com/"
        }
    }
    dependencies {
        classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.6'
    }
}

plugins {
    id 'idea'
    id 'scala'
    id("org.ajoberstar.grgit") version("3.1.1")
    id("com.github.johnrengelman.shadow") version("4.0.4")
    id("com.palantir.git-version") version("0.12.3")
    id("maven-publish")
}

apply plugin: 'forge'

def projectJavaVersion = JavaLanguageVersion.of(8)

java {
    toolchain {
        languageVersion.set(projectJavaVersion)
    }
}

idea {
    module {
        inheritOutputDirs = true
        downloadJavadoc = true
        downloadSources = true
    }
}

if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
    throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
}

checkPropertyExists("modName")
checkPropertyExists("modId")
checkPropertyExists("modGroup")
checkPropertyExists("autoUpdateBuildScript")
checkPropertyExists("minecraftVersion")
checkPropertyExists("forgeVersion")
checkPropertyExists("replaceGradleTokenInFile")
checkPropertyExists("gradleTokenModId")
checkPropertyExists("gradleTokenModName")
checkPropertyExists("gradleTokenVersion")
checkPropertyExists("gradleTokenGroupName")
checkPropertyExists("apiPackage")
checkPropertyExists("accessTransformersFile")
checkPropertyExists("usesMixins")
checkPropertyExists("mixinPlugin")
checkPropertyExists("mixinsPackage")
checkPropertyExists("coreModClass")
checkPropertyExists("containsMixinsAndOrCoreModOnly")
checkPropertyExists("usesShadowedDependencies")
checkPropertyExists("developmentEnvironmentUserName")

//Properties added in fork
checkPropertyExists("skipBuildScriptUpdateCheck")
checkPropertyExists("repositoryURL")
checkPropertyExists("repositoryName")
checkPropertyExists("mavenGroupId")
checkPropertyExists("mavenArtifactId")
checkPropertyExists("hasMixinDeps")


String javaSourceDir = "src/main/java/"
String scalaSourceDir = "src/main/scala/"

String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
}

if(apiPackage) {
    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
    }
}

if(accessTransformersFile) {
    String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
    if(getFile(targetFile).exists() == false) {
        throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
    }
}

if(usesMixins.toBoolean()) {
    if(mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) {
        throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!")
    }

    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
    }

    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
    }
}

if(coreModClass) {
    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
    }
}

configurations.all {
    resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)

    // Make sure GregTech build won't time out
    System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
    System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
}

// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
'git config core.fileMode false'.execute()
// Pulls version from git tag
try {
    version = gitVersion()
}
catch (Exception e) {
    throw new IllegalStateException("This mod must be version controlled by Git AND the repository must provide at least one tag!");
}

group = modGroup
if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
    archivesBaseName = customArchiveBaseName
}
else {
    archivesBaseName = modId
}
archivesBaseName += "-mc" + minecraftVersion

minecraft {
    version = minecraftVersion + "-" + forgeVersion + "-" + minecraftVersion
    runDir = "run"

    if (replaceGradleTokenInFile) {
        replaceIn replaceGradleTokenInFile
        if(gradleTokenModId) {
            replace gradleTokenModId, modId
        }
        if(gradleTokenModName) {
            replace gradleTokenModName, modName
        }
        if(gradleTokenVersion) {
            replace gradleTokenVersion, versionDetails().lastTag
        }
        if(gradleTokenGroupName) {
            replace gradleTokenGroupName, modGroup
        }
    }
}

if(file("addon.gradle").exists()) {
    apply from: "addon.gradle"
}

apply from: 'repositories.gradle'

configurations {
    implementation.extendsFrom(shadowImplementation)  // TODO: remove after all uses are refactored
    implementation.extendsFrom(shadowCompile)
    implementation.extendsFrom(shadeCompile)
}

repositories {
    maven {
        name = "Overmind forge repo mirror"
        url = "https://gregtech.overminddl1.com/"
    }
    if(usesMixins.toBoolean() || hasMixinDeps.toBoolean()) {
        maven {
            name = "sponge"
            url = "https://sponge.falsepattern.com/"
        }
        maven {
            url = "https://jitpack.falsepattern.com/"
        }
    }
}

dependencies {
    if(usesMixins.toBoolean()) {
        annotationProcessor("org.ow2.asm:asm-debug-all:5.0.3")
        annotationProcessor("com.google.guava:guava:24.1.1-jre")
        annotationProcessor("com.google.code.gson:gson:2.8.6")
        annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
        // using 0.8 to workaround a issue in 0.7 which fails mixin application
        compile("org.spongepowered:mixin:0.7.11-SNAPSHOT") {
            // Mixin includes a lot of dependencies that are too up-to-date
            exclude module: "launchwrapper"
            exclude module: "guava"
            exclude module: "gson"
            exclude module: "commons-io"
            exclude module: "log4j-core"
        }
        compile("com.github.GTNewHorizons:SpongeMixins:1.3.3:dev")
    }
    if(hasMixinDeps.toBoolean()) {
        runtime("org.spongepowered:mixin:0.7.11-SNAPSHOT") {
            // Mixin includes a lot of dependencies that are too up-to-date
            exclude module: "launchwrapper"
            exclude module: "guava"
            exclude module: "gson"
            exclude module: "commons-io"
            exclude module: "log4j-core"
        }
        runtime("com.github.GTNewHorizons:SpongeMixins:1.3.3:dev")
    }
}

apply from: 'dependencies.gradle'

def mixingConfigRefMap = "mixins." + modId + ".refmap.json"
def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"

task generateAssets {
    if(usesMixins.toBoolean()) {
        getFile("/src/main/resources/mixins." + modId + ".json").text = """{
  "required": true,
  "minVersion": "0.7.11",
  "package": "${modGroup}.${mixinsPackage}",
  "plugin": "${modGroup}.${mixinPlugin}",
  "refmap": "${mixingConfigRefMap}",
  "target": "@env(DEFAULT)",
  "compatibilityLevel": "JAVA_8"
}

"""
    }
}

task relocateShadowJar(type: ConfigureShadowRelocation) {
    target = tasks.shadowJar
    prefix = modGroup + ".shadow"
}

shadowJar {
    project.configurations.shadeCompile.each { dep ->
        from(project.zipTree(dep)) {
            exclude 'META-INF', 'META-INF/**'
        }
    }

    manifest {
        attributes(getManifestAttributes())
    }

    minimize()  // This will only allow shading for actually used classes
    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
    dependsOn(relocateShadowJar)
}

jar {
    project.configurations.shadeCompile.each { dep ->
        from(project.zipTree(dep)) {
            exclude 'META-INF', 'META-INF/**'
        }
    }

    manifest {
        attributes(getManifestAttributes())
    }

    if(usesShadowedDependencies.toBoolean()) {
        dependsOn(shadowJar)
        enabled = false
    }
}

reobf {
    if(usesMixins.toBoolean()) {
        addExtraSrgFile mixinSrg
    }
}

afterEvaluate {
    if(usesMixins.toBoolean()) {
        tasks.compileJava {
            options.compilerArgs += [
                    "-AreobfSrgFile=${tasks.reobf.srg}",
                    "-AoutSrgFile=${mixinSrg}",
                    "-AoutRefMapFile=${refMap}",
                    // Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
                    "-XDenableSunApiLintControl",
                    "-XDignore.symbol.file"
            ]
        }
    }
}

runClient {
    def arguments = []
    def jvmArguments = []

    if (usesMixins.toBoolean()) {
        arguments += [
                "--mods=../build/libs/$archivesBaseName-${version}.jar"
        ]
    }

    if(usesMixins.toBoolean() || hasMixinDeps.toBoolean()) {
        arguments += [
                "--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"
        ]
        jvmArguments += [
                "-Dmixin.debug=true", "-Dmixin.debug.countInjections=true", "-Dmixin.debug.verbose=true", "-Dmixin.debug.export=true"
        ]
    }

    if(developmentEnvironmentUserName) {
        arguments += [
                "--username",
                developmentEnvironmentUserName
        ]
    }

    args(arguments)
    jvmArgs(jvmArguments)
}

runServer {
    def arguments = []
    def jvmArguments = []

    if (usesMixins.toBoolean()) {
        arguments += [
                "--mods=../build/libs/$archivesBaseName-${version}.jar"
        ]
    }

    if (usesMixins.toBoolean() || hasMixinDeps.toBoolean()) {
        arguments += [
                "--tweakClass", "org.spongepowered.asm.launch.MixinTweaker"
        ]
        jvmArguments += [
                "-Dmixin.debug=true", "-Dmixin.debug.countInjections=true", "-Dmixin.debug.verbose=true", "-Dmixin.debug.export=true"
        ]
    }

    args(arguments)
    jvmArgs(jvmArguments)
}

tasks.withType(JavaExec).configureEach {
    javaLauncher.set(
            javaToolchains.launcherFor {
                languageVersion = projectJavaVersion
            }
    )
}

processResources
{
    // this will ensure that this task is redone when the versions change.
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version

    // replace stuff in mcmod.info, nothing else
    from(sourceSets.main.resources.srcDirs) {
        include 'mcmod.info'

        // replace version and mcversion
        expand "minecraftVersion": project.minecraft.version,
                "modVersion": versionDetails().lastTag,
                "modId": modId,
                "modName": modName
    }

    if(usesMixins.toBoolean()) {
        from refMap
    }

    // copy everything else, thats not the mcmod.info
    from(sourceSets.main.resources.srcDirs) {
        exclude 'mcmod.info'
    }
}

def getManifestAttributes() {
    def manifestAttributes = [:]
    if(containsMixinsAndOrCoreModOnly.toBoolean() == false && (usesMixins.toBoolean() || coreModClass)) {
        manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
    }

    if(accessTransformersFile) {
        manifestAttributes += ["FMLAT" : accessTransformersFile.toString()]
    }

    if(coreModClass) {
        manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
    }

    if(usesMixins.toBoolean()) {
        manifestAttributes += [
                "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
                "MixinConfigs" : "mixins." + modId + ".json",
                "ForceLoadAsMod" : containsMixinsAndOrCoreModOnly.toBoolean() == false
        ]
    }
    return manifestAttributes
}

task sourcesJar(type: Jar) {
    from (sourceSets.main.allJava)
    from (file("$projectDir/LICENSE"))
    getArchiveClassifier().set('sources')
}

task shadowDevJar(type: ShadowJar) {
    project.configurations.shadeCompile.each { dep ->
        from(project.zipTree(dep)) {
            exclude 'META-INF', 'META-INF/**'
        }
    }

    from sourceSets.main.output
    getArchiveClassifier().set("dev")

    manifest {
        attributes(getManifestAttributes())
    }

    minimize()  // This will only allow shading for actually used classes
    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
}

task relocateShadowDevJar(type: ConfigureShadowRelocation) {
    target = tasks.shadowDevJar
    prefix = modGroup + ".shadow"
}

task circularResolverJar(type: Jar) {
    dependsOn(relocateShadowDevJar)
    dependsOn(shadowDevJar)
    enabled = false
}

task devJar(type: Jar) {
    project.configurations.shadeCompile.each { dep ->
        from(project.zipTree(dep)) {
            exclude 'META-INF', 'META-INF/**'
        }
    }

    from sourceSets.main.output
    getArchiveClassifier().set("dev")

    manifest {
        attributes(getManifestAttributes())
    }

    if(usesShadowedDependencies.toBoolean()) {
        dependsOn(circularResolverJar)
        enabled = false
    }
}

task apiJar(type: Jar) {
    from (sourceSets.main.allJava) {
        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
    }

    from (sourceSets.main.output) {
        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
    }

    from (sourceSets.main.resources.srcDirs) {
        include("LICENSE")
    }

    getArchiveClassifier().set('api')
}

artifacts {
    archives sourcesJar
    archives devJar
    if(apiPackage) {
        archives apiJar
    }
}

// publishing

def getMavenSettingsCredentials = {
    String userHome = System.getProperty( "user.home" );
    File mavenSettings = new File(userHome, ".m2/settings.xml")
    def xmlSlurper = new XmlSlurper()
    def output = xmlSlurper.parse(mavenSettings)
    return output."servers"."server"
}

def getCredentials = {
    try {
        def entries = getMavenSettingsCredentials()
        for (entry in entries) {
            if (entry."id".text() == repositoryName) {
                return [username: entry.username.text(), password: entry.password.text()]
            }
        }
        throw new Exception();
    } catch (Exception ignored) {
        //Try from environment variables if file does not exist
        String username = System.getenv("MAVEN_DEPLOY_USER")
        String password = System.getenv("MAVEN_DEPLOY_PASSWORD")
        if (username == null || password == null) {
            return [username: null, password: null]
        } else {
            return [username: username, password: password]
        }
    }
}

//Publishing
publishing {
    publications {
        maven(MavenPublication) {
            artifact source: (jar.enabled ? jar : shadowJar)
            artifact source: sourcesJar, classifier: "src"
            artifact source: (devJar.enabled ? devJar : shadowDevJar), classifier: "dev"
            if (apiPackage) {
                artifact source: apiJar, classifier: "api"
            }

            groupId = mavenGroupId
            artifactId = mavenArtifactId + "-mc" + minecraftVersion
            version = gitVersion()
        }
    }

    repositories {
        if (repositoryURL.trim() != "") {
            maven {
                name = repositoryName
                url = repositoryURL
                def creds = getCredentials()
                credentials {
                    username = creds == null ? "none" : creds.username
                    password = creds == null ? "none" : creds.password
                }
            }
        }
    }
}

// Updating
task updateBuildScript {
    doLast {
        if (performBuildScriptUpdate(projectDir.toString())) return

        print("Build script already up-to-date!")
    }
}

if (!skipBuildScriptUpdateCheck.toBoolean() && isNewBuildScriptVersionAvailable(projectDir.toString())) {
    if (autoUpdateBuildScript.toBoolean()) {
        performBuildScriptUpdate(projectDir.toString())
    } else {
        println("Build script update available! Run 'gradle updateBuildScript'")
    }
}

static URL availableBuildScriptUrl() {
    new URL("https://raw.githubusercontent.com/FalsePattern/ExampleMod1.7.10/main/build.gradle")
}

boolean performBuildScriptUpdate(String projectDir) {
    if (isNewBuildScriptVersionAvailable(projectDir)) {
        def buildscriptFile = getFile("build.gradle")
        availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
        print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
        return true
    }
    return false
}

boolean isNewBuildScriptVersionAvailable(String projectDir) {
    Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]

    String currentBuildScript = getFile("build.gradle").getText()
    String currentBuildScriptHash = getVersionHash(currentBuildScript)
    String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
    String availableBuildScriptHash = getVersionHash(availableBuildScript)

    boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
    return !isUpToDate
}

static String getVersionHash(String buildScriptContent) {
    String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
    if(versionLine != null) {
        return versionLine.split(": ").last()
    }
    return ""
}

configure(updateBuildScript) {
    group = 'forgegradle'
    description = 'Updates the build script to the latest version'
}

// Helper methods

def checkPropertyExists(String propertyName) {
    if (project.hasProperty(propertyName) == false) {
        throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/FalsePattern/ExampleMod1.7.10/blob/main/gradle.properties")
    }
}

def getFile(String relativePath) {
    return new File(projectDir, relativePath)
}