build.gradle

import com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.apache.commons.io.FileUtils
import org.apache.commons.io.filefilter.FileFilterUtils
import org.apache.commons.io.filefilter.TrueFileFilter

import java.nio.file.Files

buildscript {
    repositories {
        maven { url = 'https://files.minecraftforge.net/maven' }
        jcenter()
        mavenCentral()
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:4.+'
    }
}

plugins {
    id("maven-publish")
    id "com.github.johnrengelman.shadow" version "6.1.0"
    id 'com.matthewprenger.cursegradle' version "1.4.0"
}
apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'idea'

def mcVersion = '1.12.2'
version = '1.1.5'
group = 'team.cappcraft.icheme'
archivesBaseName = 'immersive-chemical-engineering'

sourceCompatibility = targetCompatibility = 1.8

minecraft {
    mappings channel: 'snapshot', version: '20171003-1.12'

    runs {
        client {
            workingDirectory project.file('run')

            // 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', 'debug'
        }

        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', 'debug'
        }
    }
}

repositories {
    maven { url = 'https://files.minecraftforge.net/maven' }
    maven {
        name = 'ModMaven'
        url 'https://modmaven.dev'
    }
    maven {
        name = 'CoFH Maven'
        url = 'http://maven.covers1624.net/'
    }
    maven {
        name = 'ChickenBones Maven'
        url = "http://chickenbones.net/maven/"
    }
    maven {
        name = 'JEI Maven'
        url = 'http://dvs1.progwml6.com/files/maven'
    }
    maven {
        name = 'Immersive Maven'
        url = 'http://maven.blamejared.com'
    }
    maven {
        url "https://www.cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
}

dependencies {
    minecraft 'net.minecraftforge:forge:1.12.2-14.23.5.2854'

    implementation 'mezz.jei:jei_1.12.2:4.+'
    implementation 'cofh:RedstoneFlux:1.12-2.+:deobf'
    implementation 'mcjty.theoneprobe:TheOneProbe-1.12:1.12-1.+'
    implementation 'CraftTweaker2:CraftTweaker2-MC1120-Main:1.12-4.+'
    implementation fg.deobf('blusunrize:ImmersiveEngineering:0.12-92-559')

    //noinspection GradlePackageUpdate
    implementation 'org.jgrapht:jgrapht-core:1.4.0'
    shadow 'org.jgrapht:jgrapht-core:1.4.0'

    testImplementation(platform('org.junit:junit-bom:5.7.1'))
    testImplementation('org.junit.jupiter:junit-jupiter:5.8.1')

    runtimeOnly('curse.maven:nbtEdit-247580:2448708')
}

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "skipped", "failed"
    }
}

jar {
    manifest {
        attributes([
                "Specification-Title"     : "immersive-chemical-engineering",
                "Specification-Vendor"    : "Cappcraft Team",
                "Specification-Version"   : "1",
                "Implementation-Title"    : project.name,
                "Implementation-Version"  : "${version}",
                "Implementation-Vendor"   : "Cappcraft Team",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}

class MakeATsTask extends DefaultTask {
    @Input
    FileCollection runtimeLibraries
    @OutputDirectories
    File dirATs

    String FILENAME_AT = "accesstransformer.cfg"

    MakeATsTask() {
        runtimeLibraries = project.configurations["runtimeClasspath"].filter {
            !it.name.startsWith("forge")
        }
        dirATs = new File("$project.buildDir/generatedATs")
    }

    @TaskAction
    def makeAT() {
        project.delete(dirATs)//Clean first
        runtimeLibraries.forEach {
            project.zipTree(it).filter { content ->
                content.name.endsWith("_at.cfg")
            }.forEach { at ->
                println("Found AccessTransFormer: ${at.name} in ${it.name}")
                project.copy {
                    from(at)
                    into(project.file("$dirATs/${at.name.substring(0, at.name.lastIndexOf("."))}"))
                    rename {
                        FILENAME_AT
                    }
                }
            }
        }
    }
}

task transformAccessTransformer(type: MakeATsTask) {
    group = "access_transformer"

    if (dirATs.exists())
        minecraft.accessTransformers.addAll(FileUtils.listFiles(
                dirATs,
                FileFilterUtils.nameFileFilter(FILENAME_AT),
                TrueFileFilter.INSTANCE))
}

task generateSources(type: Copy) {
    inputs.properties("version": version)
    group = "build"
    from compileJava.source
    into "$buildDir/generatedSrc"
    expand "version": version
}

compileJava {
    source = tasks.generateSources.outputs
    dependsOn(tasks.generateSources)
}

processResources {
    inputs.properties(
            "version": version,
            "mcversion": mcVersion
    )
    from(sourceSets.main.resources.srcDirs)
    copy {
        from(sourceSets.main.resources.srcDirs)
        into("$buildDir/classes/java/main")
        filesMatching("mcmod.info") {
            expand("version": version, "mcversion": mcVersion)
        }
    }
    filesMatching("mcmod.info") {
        expand("version": version, "mcversion": mcVersion)
    }
}

task sourceJar(type: Jar) {
    group = "build"
    archiveClassifier.set 'sources'
    from sourceSets.main.allSource
}

shadowJar {
    classifier = "deobf"
    configurations = [project.configurations.shadow]
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

Properties properties = new Properties()
def file = new File("${projectDir}/local.properties")
if (file.exists()) {
    properties.load(Files.newInputStream(file.toPath()))

    curseforge {
        apiKey = properties.getProperty("curse-api")
        project {
            id = '463438'
            changelog = 'Support Comparator'
            releaseType = 'beta'

            mainArtifact shadowJar//Will be replaced in afterEvaluate
            addArtifact shadowJar
            addArtifact sourceJar

            addGameVersion("Java 8")
            addGameVersion("1.12.2")

            relations {
                requiredDependency("immersive-engineering")
            }
        }
    }

    afterEvaluate {
        task shadowReobfedJar(type: ShadowJar) { shadow ->
            shadow.group = "build"
            shadow.description = 'Create a combined JAR of reobfed and runtime dependencies'

            shadow.archiveClassifier.set("shadowed")//Set classifier

            shadow.manifest.inheritFrom project.tasks.jar.manifest
            def libsProvider = project.provider { -> [project.tasks.jar.manifest.attributes.get('Class-Path')] }
            def files = project.objects.fileCollection().from { ->
                project.configurations.findByName(ShadowBasePlugin.CONFIGURATION_NAME)
            }
            shadow.doFirst {
                if (!files.empty) {
                    def libs = libsProvider.get()
                    libs.addAll files.collect { "${it.name}" }
                    manifest.attributes 'Class-Path': libs.findAll { it }.join(' ')
                }
                //Take re-Obf Jar as input
                shadow.from(tasks.reobfJar.getInput())
            }
            shadow.configurations = [project.configurations.shadow]
            shadow.exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA', 'module-info.class')
            shadow.dependsOn(tasks.reobfJar)
            tasks.reobfJar.finalizedBy(shadow)
        }

        tasks.curseforge463438.mainArtifact.artifact = shadowReobfedJar

        publishing {
            publications {
                uploadhMod(MavenPublication) {
                    artifactId = project.archivesBaseName

                    artifact sourceJar
                    artifact shadowJar
                    artifact shadowReobfedJar
                }
            }
            repositories {
                maven {
                    name = "GitHubPackages"
                    url = uri("https://maven.pkg.github.com/CappCraft-Team/Immersive-Chemical-Engineering")
                    credentials {
                        username = properties.getProperty("gpr.user") ?: System.getenv("USERNAME")
                        password = properties.getProperty("gpr.key") ?: System.getenv("TOKEN")
                    }
                }
            }
        }
    }
}