build.gradle

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

buildscript {
    repositories {
        mavenCentral()
        maven {
            name = "forge"
            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.2-SNAPSHOT"
    }
}

apply plugin: "net.minecraftforge.gradle.forge" // adds the forge dependency
apply plugin: 'maven' // for uploading to a maven repo

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 allways 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.


    // replacing stuff in the source
    replace "@VERSION@", project.version
    replace "@MC_VERSION@", version
}

// configure  the source folders
sourceSets {
    main {
        java {
            srcDir "common"
            srcDir "common_old_license"
          //  srcDir "src_old_license"
            // exclude 'some exclusion'
            // include 'some inclusion'
        }
        resources {
            srcDir "buildcraft_resources"
            srcDir "BuildCraft-Localization"
            exclude "**/.md" // exclude readme from localization repo
            // exclude 'some exclusion'
            // include 'some inclusion'
        }
    }
    api {
		java {
			srcDir "BuildCraftAPI/api"
		}
    }
}

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

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

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

def createMCModInfo(def id, def taskName)
{
    File temp = new File("build/processing/" + taskName + "/mcmod.info")
    temp.parentFile.mkdirs()
    if (temp.exists())
        temp.delete()
    temp.createNewFile()
    String prettyPrinted = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson([ext.mcModInfo[id]]))
    prettyPrinted = prettyPrinted.replace("\${version}", project.version)
    prettyPrinted = prettyPrinted.replace("\${mcversion}", project.minecraft.version)
    temp.write(prettyPrinted)
    temp.deleteOnExit()
    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))
    }
}

// add a source jar
//task sourceJar(type: Jar) {
//    from sourceSets.main.allSource
//    from sourceSets.api.allSource
//    classifier = 'sources'
//}

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

// add a javadoc jar
task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier = 'javadoc'
    from 'build/docs/javadoc'
}

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

task apiJar(type: Jar, dependsOn: reobfJar) {
    destinationDir = file("modules")
    classifier = 'api'

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

task libJar(type: Jar, dependsOn: reobfJar) {
    destinationDir = file("modules")
    classifier = 'lib'

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

task coreJar(type: Jar, dependsOn: reobfJar) {
    destinationDir = file("modules")
    classifier = 'core'

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

task buildersJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'builders'

    doFirst {
        from(createMCModInfo(2, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraftbuilders/**", "buildcraft/builders/**", "LICENSE"])
        }
    }
}

task energyJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'energy'

    doFirst {
        from(createMCModInfo(3, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraftenergy/**", "buildcraft/energy/**", "LICENSE"])
        }
    }
}

task factoryJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'factory'

    doFirst {
        from(createMCModInfo(4, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraftfactory/**", "buildcraft/factory/**", "LICENSE"])
        }
    }
}

task siliconJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'silicon'

    doFirst {
        from(createMCModInfo(5, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraftsilicon/**", "buildcraft/silicon/**", "LICENSE"])
        }
    }
}

task transportJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'transport'

    doFirst {
        from(createMCModInfo(6, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcrafttransport/**", "buildcraft/transport/**", "LICENSE"])
        }
    }
}

task roboticsJar(type: Jar, dependsOn: reobfJar) {

    destinationDir = file("modules")
    classifier = 'robotics'

    doFirst {
        from(createMCModInfo(7, name).parentFile)
        from(project.ext.jarFile) {
            includes.addAll(["assets/buildcraftrobotics/**", "buildcraft/robotics/**", "LICENSE"])
        }
    }
}

task allJar(type: Jar, dependsOn:reobfJar) {

    destinationDir = file("modules")

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


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

// make sure all of these happen when we run build
build.dependsOn sourceJar, 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"
}

clean{
    delete "modules"
}

// 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 allJar
}

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()
        }
    }
}

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 {
        if (project.hasProperty("filesmaven")) { // if this is the Forge server, and this stuff is defined...
            logger.info('Publishing to files server')

            mavenDeployer {
                // specify the jars that maven needs to deploy here
                configuration = configurations.deployerJars

                // authentication, again, specially set in the forge server environment
                repository(url: project.filesmaven.url) {
                    authentication(userName: project.filesmaven.username, privateKey: project.filesmaven.key)
                }

                // here you specify all your metadata
                // this is the definition of the maven pom.xml. This is simply a DSL to define the XML. Not actual fields or things to set.
                pom {
                    groupId = project.group
                    version = project.version
                    artifactId = project.archivesBaseName
                    project {
                        name project.archivesBaseName
                        packaging 'jar'
                        description 'A Minecraft mod adding all sorts of machinery'
                        url 'http://www.mod-buildcraft.com/'

                        scm {
                            url 'https://github.com/BuildCraft/BuildCraft'
                            connection 'scm:git:git://github.com/BuildCraft/BuildCraft.git'
                            developerConnection 'scm:git:git@github.com:BuildCraft/BuildCraft.git'
                        }

                        issueManagement {
                            system 'github'
                            url 'https://github.com/BuildCraft/BuildCraft/issues'
                        }

                        licenses {
                            license {
                                name 'Minecraft Mod Public License'
                                url 'http://www.mod-buildcraft.com/MMPL-1.0.txt'
                                distribution 'repo'
                            }
                        }

                        developers {
                            developer {
                                id 'SpaceToad'
                                name 'SpaceToad'
                                roles { role 'developer' }
                            }
                            developer {
                                id 'CovertJaguar'
                                name 'CovertJaguar'
                                roles { role 'developer' }
                            }
                            developer {
                                id 'SirSngir'
                                name 'SirSengir'
                                roles { role 'developer' }
                            }   
                            developer {
                                id 'Krapht'
                                name 'Krapht'
                                roles { role 'developer' }
                            }   

                        }
                    }
                }
            }
        }
        else
        {
            // otherwise publishing to the local repo in ~/.m2 is fine...
            add project.repositories.mavenLocal()
        }
    }
}