build.gradle

/*
 * Copyright (c) 2017 SpaceToad and the BuildCraft team
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
 * distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/
 */


/* Build info:

 - Using a release version (e.g. 8.0.4 rather than 8.0.4-SNAPSHOT or 8.0.4-0A1B2C3D4E5) requires setting the "release" system property to true
    - Add "-Drelease=true" to disallow adding the git commit hash to the end, or SNAPSHOT if we cannot find our git directory.

*/

// DON'T TOUCH THE BUILDSCRIPT[] BLOCK
// its special, and it is only there to make ForgeGradle work correctly.

buildscript {
    repositories {
        mavenCentral()
        jcenter()
        maven {
            url = "http://files.minecraftforge.net/maven"
        }
        maven {
            name = "sonatype"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT"
        classpath "org.ajoberstar:grgit:2.2.1"
    }
}

apply plugin: "net.minecraftforge.gradle.forge" // adds the forge dependency
apply plugin: 'maven' // for uploading to a maven repo
apply plugin: 'maven-publish' // for uploading to a maven repo
if (!hasProperty("grgit")) {
    // As otherwise it logs a warning as grgit gets applied twice
    apply plugin: "org.ajoberstar.grgit"
}

if (gradle.startParameter.taskNames.contains("checkstyle")) {
    apply plugin: "checkstyle"
}

ext.configFile = file "build.properties"
configFile.withReader {
    // Load config. It shall from now be referenced as simply config or project.config
    def prop = new Properties()
    prop.load(it)
    project.ext.config = new ConfigSlurper().parse prop
}

if (System.getenv("BUILD_NUMBER") != null) {
    config.mod_version += "-${System.getenv("BUILD_NUMBER")}"
}
if (System.getenv("BUILD_VARIANT") != null) {
    config.mod_version += "-${System.getenv("BUILD_VARIANT")}"
}

version = config.mod_version
group= "com.mod-buildcraft"
archivesBaseName = "buildcraft" // the name that all artifacts will use as a base. artifacts names follow this pattern: [baseName]-[appendix]-[version]-[classifier].[extension]

ext.mcModInfo = new groovy.json.JsonSlurper().parse(file("buildcraft_resources/mcmod.info"))
ext.priv = parseConfig(file('private.properties'))

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

dependencies {
    // Testing
    testCompile "junit:junit:4.12"
}

minecraft {
    version = config.mc_version + "-" + config.forge_version
    runDir = "run"

    // the mappings can be changed at any time, and must be in the following format.
    // snapshot_YYYYMMDD   snapshot are built nightly.
    // stable_#            stables are built at the discretion of the MCP team.
    // Use non-default mappings at your own risk. they may not always work.
    // simply re-run your setup task after changing the mappings to update your workspace.
    mappings = config.mappings_version
    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.

    def addVersionDetails = !Boolean.getBoolean("release")

    // Git versioning stuffs
    if (grgit != null) {
        String gitDir;
        if (rootProject == project) {
            gitDir = "$projectDir";
        } else {
            File dotGit = project.file(".git");
            if (dotGit.isDirectory()) {
                gitDir = dotGit;
            } else {
                gitDir = rootProject.file(".git/modules/BuildCraft").toString()
            }
        }
        def repo = grgit.open(dir: gitDir)
        replace "\${git_commit_hash}", repo.head().id
        // This is very ugly: we need 7(!) \ to produce a single \ in the final one. 
        replace "\${git_commit_msg}", repo.head().fullMessage.replace("\"", "\\\\\\\"").split("\n")[0]
        replace "\${git_commit_author}", repo.head().author.name
        replace "\${git_branch}", repo.branch.current().getName()
        if (addVersionDetails) {
            // Always use the compat commit for the version.
            project.version += "-" + grgit.open(dir: project.rootDir).head().id.toString().substring(0, 12)
        }
    } else {
        if (addVersionDetails) {
            project.version += "-SNAPSHOT"
        }
    }

    // replacing stuff in the source
    replace "\$version", project.version
    replace "\${mcversion}", version
    // Replace @Mod.acceptedMinecraftVersions specially as it has to be a valid version in a dev environment :/
    replace "(gradle_replace_mcversion,)", "[" + version + "]"
    replace "(gradle_replace_forgeversion,)", "[" + config.forge_version + ",)"
}

task printVersion {
    description = "Prints out the actual version used. Useful for testing the buildscript. (Add -Drelease=true to force this to the version specified in build.properties)"
    doLast {
        println "Version = " + project.version
    }
}

// configure  the source folders
sourceSets {
    main {
        java {
            srcDir "common"
            srcDir "common_old_license"
            srcDir "sub_projects/expression/src/main/java"
            srcDir "sub_projects/expression/src/autogen/java"
            // srcDir "src_old_license"
        }
        resources {
            srcDir "buildcraft_resources"
            srcDir "BuildCraft-Localization"
            exclude "**/.md" // exclude readme from localization repo
            srcDir "BuildCraftGuide/guide_resources"
            exclude "pack.png" // exclude from the guide repo
            exclude "pack.mcmeta" // exclude from the guide repo
        }
    }
    api {
        java {
            srcDir "BuildCraftAPI/api"
        }
    }
    test {
        java {
            srcDir "src/test/java"
            srcDir "sub_projects/expression/src/test/java"
        }
    }
}

if (gradle.startParameter.taskNames.contains("checkstyle")) {
    checkstyle {
        configFile = file("guidelines/buildcraft.checkstyle")
        toolVersion = "7.2"
    }

    task checkstyle {}
    tasks["checkstyle"].dependsOn checkstyleApi
    tasks["checkstyle"].dependsOn checkstyleMain

    tasks["checkstyleApi"].enabled = true
    tasks["checkstyleMain"].enabled = true
    tasks["checkstyleTest"].enabled = false
}

task setupSubProjects(dependsOn: "sub_projects:expression:generateSources") {
    // Just an inter-dependency task
}

eclipseClasspath.dependsOn setupSubProjects
ideaModule.dependsOn setupSubProjects
compileJava.dependsOn setupSubProjects

runClient.jvmArgs += "-Dbuildcraft.dev=true"
for (String s :"-XX:+UseG1GC -Xmx2G -Xms2G -Dsun.rmi.dgc.server.gcInterval=2147483646 -XX:+UnlockExperimentalVMOptions -XX:G1NewSizePercent=20 -XX:G1ReservePercent=20 -XX:MaxGCPauseMillis=50 -XX:G1HeapRegionSize=32M".split(" ")) {
    runClient.jvmArgs += s
}

// Obfuscated Jar location
ext.jarFile = zipTree(jar.archivePath)

// Add API dir to the IDEA module
idea.module.sourceDirs += sourceSets.api.java.srcDirs

processResources
{
    // replace stuff in mcmod.info, nothing else
    from(sourceSets.main.resources.srcDirs) {
        include 'mcmod.info'
                
        // replace version and mcversion
        // ${version}   and    ${mcversion}    are the exact strings being replaced
        expand "version":project.version, "mcversion":project.minecraft.version
    }

    // copy everything else, that's not the mcmod.info
    from(sourceSets.main.resources.srcDirs) {
        exclude 'mcmod.info'
        exclude 'pack.mcmeta'
        exclude 'pack.png'
    }
}

compileJava {
    options.compilerArgs << "-Xmaxerrs" << "2000"
    options.compilerArgs << "-Xmaxwarns" << "2"
    options.compilerArgs << "-Xlint:all"
    options.compilerArgs << "-Xdiags:verbose"
    options.compilerArgs << "-encoding" << "UTF-8"
}

javadoc {
    options.setUse(true)
    options.addStringsOption("Xmaxerrs").setValue(["2000"])
    options.addStringsOption("Xmaxwarns").setValue(["2000"])
    options.addStringsOption("Xdoclint:all")
    options.setEncoding("UTF-8")
}

// --------------------
// extra jar section
// -------------------

def createMCModInfo(String taskName)
{
    return new File("$projectDir/build/processing/" + taskName + "/mcmod.info")
}

def writeMCModInfo(String taskName, int... ids)
{
    File temp = createMCModInfo(taskName)
    temp.parentFile.mkdirs()
    if (temp.exists())
        temp.delete()
    temp.createNewFile()
    def elements = []
    for (int id : ids) {
        elements += ext.mcModInfo[id];
    }
    String prettyPrinted = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(elements))
    prettyPrinted = prettyPrinted.replace("\$version", project.version)
    prettyPrinted = prettyPrinted.replace("\${mcversion}", project.minecraft.version)
    temp.write(prettyPrinted)
    return temp
}

def parseConfig(File config) {
    if (!config.exists())
        return null
    config.withReader {
        def prop = new Properties()
        prop.load(it)
        return (new ConfigSlurper().parse(prop))
    }
}

def unzippedSourceJar = new File("$projectDir/build/processing/tasks/unzipped_src_jar/unzip")
def libsDir = new File(System.getenv("LIBS_DIR") ?: "$projectDir/build/libs/", version)
def modulesDir = new File(libsDir, "modules")
def modulesDirSrc = new File(modulesDir, "src")

// forge (or gradle?) creates a special sourceJar which has been processed
// This task unzips that created jar, so that partial source jars can be created.
task unzipSourceJar(type: Copy, dependsOn: sourceJar) {
    from (zipTree(sourceJar.archivePath)) {
        include "**"
    }
    into unzippedSourceJar
}

// add api classes to javadoc
javadoc {
    source += sourceSets.api.allSource
}

// add a javadoc jar
task javadocJar(type: Jar, dependsOn: javadoc) {
    destinationDir = libsDir
    appendix = "main"
    classifier = 'javadoc'
    from '$projectDir/build/docs/javadoc'
}

// because the normal output has been made to be obfuscated
task deobfJar(type: Jar) {
    destinationDir = libsDir
    appendix = "main"
    from sourceSets.main.output
    from sourceSets.api.output
    classifier = 'dev'
}

task writeModInfos() {
    outputs.upToDateWhen { false }
    doLast {
        writeMCModInfo("lib", 0)
        writeMCModInfo("core", 0, 1)
        writeMCModInfo("builders", 2)
        writeMCModInfo("energy", 3)
        writeMCModInfo("factory", 4)
        writeMCModInfo("silicon", 5)
        writeMCModInfo("transport", 6)
        writeMCModInfo("robotics", 7)
    }
}

task apiJar(type: Jar, dependsOn: [reobfJar, writeModInfos]) {
    destinationDir = modulesDir
    appendix = "api"

    from(project.ext.jarFile) {
        includes.addAll(["buildcraft/api/**"])
    }
}

task apiSrcJar(type: Jar, dependsOn: [build, unzipSourceJar]) {
    destinationDir = modulesDirSrc
    appendix = "api"
    classifier = 'sources'
    from sourceSets.api.allSource
}

task libJar(type: Jar, dependsOn: [reobfJar, writeModInfos]) {
    destinationDir = modulesDir
    appendix = "lib"

    from(createMCModInfo("lib").parentFile)
    from(project.ext.jarFile) {
        includes.addAll(["assets/buildcraft/**", "assets/buildcraftlib/**", "data/buildcraftlib/**", "buildcraft/lib/**", "buildcraft/api/**", "changelog/**", "LICENSE**", "versions.txt"])
    }
}

task libSrcJar(type: Jar, dependsOn: [build, unzipSourceJar]) {
    destinationDir = modulesDirSrc
    appendix = "lib"
    classifier = "sources"

    from sourceSets.api.allSource
    from (unzippedSourceJar) {
        includes.addAll(["assets/buildcraft/**", "assets/buildcraftlib/**", "buildcraft/lib/**", "LICENSE**"])
    }
}

task coreJar(type: Jar, dependsOn: [reobfJar, writeModInfos]) {
    destinationDir = modulesDir
    appendix = "core"

    from(createMCModInfo("core").parentFile)
    from(project.ext.jarFile) {
        includes.addAll(["assets/buildcraft/**", "assets/buildcraftlib/**", "data/buildcraftlib/**", "assets/buildcraftcore/**", "data/buildcraftcore/**", "buildcraft/lib/**", "buildcraft/core/**", "buildcraft/api/**", "changelog/**", "LICENSE**", "versions.txt"])
    }
}

for (String module : ["builders", "energy", "factory", "silicon", "transport", "robotics"]) {
    task (module + "Jar", type: Jar, dependsOn: [reobfJar, writeModInfos]) {
        destinationDir = modulesDir
        appendix = module

        from(createMCModInfo(module).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraft$module/**", "data/buildcraft$module/**", "buildcraft/$module/**", "LICENSE"])
        }
    }
}

task mainJar(type: Jar, dependsOn:reobfJar) {
    destinationDir = libsDir
    appendix = "main"

    from(project.ext.jarFile) {
        includes.addAll("**")
    }
}

task mainSrcJar(type: Jar, dependsOn:[reobfJar, unzipSourceJar]) {
    destinationDir = libsDir
    appendix = "main"
    classifier = "sources"

    from sourceSets.api.allSource
    from (unzippedSourceJar) {
        includes.add("**")
    }
}

// Configure BC compat
if (rootProject != project) {
    rootProject.allJar.
        from (project.ext.jarFile) {
            includes.addAll("**")
            exclude("mcmod.info")
        }
    rootProject.allJar.dependsOn(mainJar)

    rootProject.allSrcJar.
        from (unzippedSourceJar) {
            includes.add("**")
            exclude("mcmod.info")
        }
    rootProject.allJar.dependsOn(unzipSourceJar)
}

// add api classes to main package
jar {
    from sourceSets.api.output
}

// make sure all of these happen when we run build
build.dependsOn mainSrcJar, apiJar, deobfJar, javadocJar

// --------------------
// maven section
// -------------------

// create the deployerJars dependency configuration
configurations {
    deployerJars
    sshAntTask
}

dependencies {
    // dependency in deployerJars, for maven deployment. see definition in mavenDeployer{} below
    deployerJars "org.apache.maven.wagon:wagon-ssh:2.2"
    sshAntTask "org.apache.ant:ant-jsch:1.9.6", "com.jcraft:jsch:0.1.53"
}
// specify artifacts to be uploaded
artifacts {
    // the default jar is already here by default
    archives sourceJar
    archives javadocJar

    // Modules
    archives apiJar
    archives libJar
    archives coreJar
    archives buildersJar
    archives energyJar
    archives factoryJar
    archives siliconJar
    archives transportJar
    archives roboticsJar
    archives mainJar
}

def sftp(String subPath, Closure antFileset = {}) {
    ant {
        taskdef(name: 'scp', classname: 'org.apache.tools.ant.taskdefs.optional.ssh.Scp',
                classpath: configurations.sshAntTask.asPath)
        Map sftpArgs = [
                               verbose : 'yes',
                               todir : priv.username + "@" + priv.host + ":" + priv.remotedir + version + "/" + subPath,
                               port: priv.port,
                               password: priv.password,
                               sftp: true,
                               trust: 'yes'
        ]
        delegate.scp(sftpArgs) {
            antFileset.delegate = delegate
            antFileset()
        }
    }
}

publishing {
    repositories {
        maven {
            url System.getenv("MAVEN_DIR") ?: "$projectDir/build/maven"
        }
    }
    publications {
        pub_apiJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-api"
            version project.version

            artifact apiJar
        }
        pub_apiSrcJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-api"
            version project.version

            artifact apiSrcJar
        }
        pub_libJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-lib"
            version project.version

            artifact libJar
        }
        pub_libSrcJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-lib"
            version project.version

            artifact libSrcJar
        }
        pub_mainJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-main"
            version project.version

            artifact mainJar
        }
        pub_mainSrcJar(MavenPublication) {
            groupId "com.mod-buildcraft"
            artifactId "buildcraft-main"
            version project.version

            artifact mainSrcJar
        }
    }
}

task upload(dependsOn: build) {
    description = 'Update files on remote server.'
    doFirst {
        sftp("") {
            fileset(dir: libsDir)
        }
        sftp("modules") {
            fileset(dir: 'modules')
        }
    }
}


if (ext.priv == null)
    upload.enabled = false

uploadArchives {
    // make sure this happens after reobfuscation
    //dependsOn "reobf"

    repositories {
        add project.repositories.mavenLocal()
    }
}