build.gradle

import groovy.xml.MarkupBuilder
import org.apache.tools.ant.filters.ReplaceTokens

import java.text.SimpleDateFormat

buildscript {
    repositories {
        mavenCentral()
        maven {
            name = "forge"
            url = "http://files.minecraftforge.net/maven"
        }
        maven {
            name = "sonatype"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
    }
}

apply plugin: 'scala'
apply plugin: 'forge'

group = "mrtjp"
archivesBaseName = "ProjectRed"

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
}

repositories {
    maven {
        name "chickenbones"
        url "http://chickenbones.net/maven/"
    }

    maven {
        name "mvnmrtjp"
        url "http://projectredwiki.com/maven"
    }

    maven {
        name "dvs1"
        url "http://dvs1.progwml6.com/files/maven/"
    }
//    ivy {
//        name 'ThermalExpansion'
//        artifactPattern "http://addons.cursecdn.com/files/${config.texpan.cf}/[module]-[revision].[ext]"
//    }
//    ivy {
//        name 'CoFHCore'
//        artifactPattern "http://addons.cursecdn.com/files/${config.cofh.cf}/[module]-[revision].[ext]"
//    }
}

configurations {
    deployerJars
}

dependencies {
    deployerJars "org.apache.maven.wagon:wagon-ftp:2.2"

    compile "mrtjp:MrTJPCore:${config.mc.version}-${config.mrtjp.version}:dev"
    compile "codechicken:CodeChickenLib:${config.mc.version}-${config.ccl.version}:dev"
    compile "codechicken:ForgeMultipart:${config.mc.version}-${config.fmp.version}:dev"
    compile "codechicken:NotEnoughItems:${config.mc.version}-${config.nei.version}:dev"
    compile "tconstruct:TConstruct:${config.mc.version}-${config.tc.version}:deobf"
//    compile group: 'thermalexpansion', name: 'ThermalExpansion', version: config.texpan.version, ext: 'jar'
//    compile group: 'cofh', name: 'CoFHCore', version: config.cofh.version, ext: 'jar'
}

def build_number = (Integer.parseInt(System.getenv("BUILD_NUMBER") ?: "1")+51).toString()
version = "${project.config.mod.version}."+build_number

minecraft {
    version = config.mc.version+"-"+config.forge.version
    if (file('../run').exists())
    {
        runDir = "../run"
    }
    else
    {
        runDir = "run"
    }
}

sourceSets {
    main {
        def root = project.projectDir
        scala {
            srcDir new File(root, "src")
        }
        resources {
            srcDir new File(root, "resources")
        }
    }
}

task updateVersion(type: Copy) {
    // Replace tokens
    from(sourceSets.main.scala.srcDirs)
    into 'build/sources/scala'
    filter(ReplaceTokens, tokens: [
            'VERSION'      : config.mod.version,
            'BUILD_NUMBER' : build_number,
            'MC_VERSION'   : config.mc.version,
            'FORGE_VERSION': config.forge.version,
            'FMP_VERSION'  : config.fmp.version,
            'CCL_VERSION'  : config.ccl.version,
            'MRTJP_VERSION': config.mrtjp.version
    ])
}

processResources {
    //redo task if any of these properties change
    inputs.property "version", project.version
    inputs.property "mc.version", config.mc.version
    inputs.property "fmp.version", config.fmp.version
    inputs.property "ccl.version", config.ccl.version
    inputs.property "mrtjp.version", config.mrtjp.version

    // Replace properties in all files
    from(sourceSets.main.resources.srcDirs) {
        include '**.info'
        filter(ReplaceTokens, tokens: [
                'VERSION'      : config.mod.version,
                'BUILD_NUMBER' : build_number,
                'MC_VERSION'   : config.mc.version,
                'FORGE_VERSION': config.forge.version,
                'FMP_VERSION'  : config.fmp.version,
                'CCL_VERSION'  : config.ccl.version,
                'MRTJP_VERSION': config.mrtjp.version
        ])
    }
    // Copy everything else
    from(sourceSets.main.resources.srcDirs) {
        include 'assets/**/*.*'
    }
}

compileScala.dependsOn updateVersion
ext.jarVer = "${project.minecraft.version}-${project.version}"
ext.jarFile = zipTree(jar.archivePath)
ext.baseExcludes = ["**/thermalexpansion/**"]

task integrationJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedIntegration*.class"
        include "**/ProjectRedTransmission*.class"
        include "**/mrtjp/projectred/integration/**"
        include "**/mrtjp/projectred/transmission/**"

        include "**/assets/projectred/textures/blocks/gates/**"
        include "**/assets/projectred/textures/blocks/wires/**"
        include "**/assets/projectred/textures/obj/gateparts/**"

        include "integration_mod.info"
        rename("integration_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Integration'
}

task lightingJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedIllumination*.class"
        include "**/mrtjp/projectred/illumination/**"

        include "**/assets/projectred/textures/blocks/lights/**"
        include "**/assets/projectred/textures/obj/lights/**"

        include "lighting_mod.info"
        rename("lighting_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Lighting'
}

task mechanicalJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedExpansion*.class"
        include "**/mrtjp/projectred/expansion/**"
        include "**/ProjectRedTransportation*.class"
        include "**/mrtjp/projectred/transportation/**"

        include "**/assets/projectred/textures/blocks/machines/**"
        include "**/assets/projectred/textures/blocks/pipes/**"
        include "**/assets/projectred/textures/obj/machines/**"

        include "mechanical_mod.info"
        rename("mechanical_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'Mechanical_beta'
}

task worldJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedExploration*.class"
        include "**/mrtjp/projectred/exploration/**"

        include "**/assets/projectred/textures/blocks/ore/**"

        include "world_mod.info"
        rename("world_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    version = project.ext.jarVer
    classifier = 'World'
}

task compatJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        include "**/ProjectRedCompatibility*.class"
        include "**/mrtjp/projectred/compatibility/**"

        //APIs
        include "**/dan200/**"

        include "**/assets/asm/**"
        include "**/assets/projectred/textures/blocks/compat/**"

        include "compat_mod.info"
        rename("compat_mod.info", 'mcmod.info')

        project.ext.baseExcludes.addAll(includes)
    }
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
    version = project.ext.jarVer
    classifier = 'Compat'
}

task baseJar(type: Jar, dependsOn: reobf) {
    from(project.ext.jarFile) {
        exclude project.ext.baseExcludes

        rename("base_mod.info", 'mcmod.info')
    }
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
    version = project.ext.jarVer
    classifier = 'Base'

}

// baseJar pulls all files not in any other jar. Therefore must run last
baseJar.mustRunAfter { tasks.findAll { task -> (task.name.endsWith('Jar') && !task.name.equals('baseJar')) } }

jar {
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
}

task sourceJar(type: Jar) {
    from sourceSets.main.allSource
    classifier = 'sources'
    version = "${project.minecraft.version}-${project.version}"
}

task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'dev'
    version = "${project.minecraft.version}-${project.version}"
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
}

def deployMetaFile()
{
    new File(new File(project.projectDir, "build/libs/"),
            "deploymeta-${project.minecraft.version}-${project.version}.xml")
}

def createDeployMeta()
{
    def writer = new StringWriter()
    def xml = new MarkupBuilder(writer)

    def today = new SimpleDateFormat('dd-MM-yyyy').format(new Date())

    xml.deployMeta() {
        modversion(version)

        date(today)

        deps {
            Minecraft(project.minecraft.version)
            Forge(config.forge.version)
            MrTJPCore(config.mrtjp.version)
            FMP(config.fmp.version)
            CCL(config.ccl.version)
        }

        isPublic(true)

        isRecommended(false)
    }

    def file = deployMetaFile()

    def stream = new FileOutputStream(file)
    stream.write(writer.toString().getBytes())
    stream.flush()
    stream.close()
}

artifacts {
    archives integrationJar
    archives lightingJar
    archives mechanicalJar
    archives worldJar
    archives compatJar
    archives baseJar

    archives sourceJar
    archives deobfJar

    archives deployMetaFile()
}

uploadArchives {
    dependsOn 'reobf'
    doFirst {createDeployMeta()}
    repositories {
        if (project.hasProperty("mavenurl"))
        {
            mavenDeployer {
                configuration = configurations.deployerJars

                repository(url: project.mavenurl) {
                    authentication(userName: project.mavenusername, password: project.mavenpassword)
                }

                pom {
                    groupId = project.group
                    version = "${project.minecraft.version}-${project.version}"
                    artifactId = project.archivesBaseName
                    project {
                        name project.archivesBaseName
                        packaging 'jar'
                        description project.archivesBaseName
                        url 'https://github.com/MrTJP/'+project.archivesBaseName

                        scm {
                            url 'https://github.com/MrTJP/'+project.archivesBaseName
                            connection 'scm:git:git://github.com/MrTJP/'+project.archivesBaseName+'.git'
                            developerConnection 'scm:git:git@github.com:MrTJP/'+project.archivesBaseName+'.git'
                        }

                        issueManagement {
                            system 'github'
                            url 'https://github.com/MrTJP/'+project.archivesBaseName+'/issues'
                        }

                        licenses {
                            license {
                                name 'Restricted Public Software License (RPSL) v1.3.1'
                                url 'https://raw.githubusercontent.com/MrTJP/ProjectRed/master/LICENSE.md'
                                distribution 'repo'
                            }
                        }

                        developers {
                            developer {
                                id 'mrtjp'
                                name 'mrtjp'
                                roles { role 'developer' }
                            }
                        }
                    }
                }
            }
        }
    }
}