build.gradle

import org.apache.tools.ant.filters.ReplaceTokens

// This sets us up for building a forge project - you need all of these
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'
    }
}

println "Adding utility attributes to $project.name..."

// return true if there is a property `prop` from Gradle, Java system properties, or environment, in that order.
ext._hasProperty = { prop ->
    def res = _property(prop)
    return res != null && res != ""
}

// get property from Gradle, Java system properties, or environment, in that order.
ext._property = { prop ->
    if (project.hasProperty(prop))
        return project.property(prop)
    def res = System.getProperty(prop, null)
    if (res)
        return res
    res = System.getenv(prop)
    if (res)
        return res
    return null
}

ext.branch = _property("TRAVIS_BRANCH")
if (branch && !(branch.startsWith("version") || branch == "master")) {
    ext.fail = true
}

ext.setIfUnset = { prop, value ->
    if (!hasProperty(prop)) {
        ext[prop] = value
    }
}

setIfUnset("ossrhUsername", _property("ossrhUsername"))
setIfUnset("ossrhPassword", _property("ossrhPassword"))

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

// Apply the forge plugin - this adds all the magic for automatically obfuscating, deobfuscating etc
apply plugin: 'forge'

// This is our group
group = "com.techshroom" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
// This is our actual project within the group.
archivesBaseName = "TSModCore"

// Define properties file
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
}

dependencies {
    compile "codechicken:CodeChickenLib:${config.mc.version.normal}-${config.ccl.version}:dev"
    compile "com.techshroom:StepBuilder:${config.sb.version}"

    testCompile "junit:junit:4.11"
}

version =  "${config.mc.version.mod}.${config.mod.version}"

// Setup the forge minecraft plugin data. Specify the preferred forge/minecraft version here
minecraft {
    version = config.mc.version.normal + "-" + config.forge.version
    println version
    if (file('../run').exists()) {
        runDir = "../run"
    } else {
        runDir = "run"
    }
    replace '${version}', project.version
}

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

task updateVersion(type: Copy) {
    // Replace tokens
    from(sourceSets.main.java.srcDirs)
    into 'build/sources/java'
    filter(ReplaceTokens, tokens: [
        'VERSION': config.mod.version.toString(),
        'MODID': config.mod.id.toString(),
        'SUPPORTED_VERSIONS': config.mod.mcversions.toString()
    ])
}

compileJava.dependsOn updateVersion

tasks.withType(JavaCompile) {
    options.incremental = true
}

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

    // Replace properties in all files
    from(sourceSets.main.resources.srcDirs) {
        include '**.info'
        filter(ReplaceTokens, tokens: [
            'VERSION': config.mod.version,
            'MC_VERSION': config.mc.version.normal,
            'FORGE_VERSION': config.forge.version,
            'CCL_VERSION': config.ccl.version,
            'MODID': config.mod.id,
            'SUPPORTED_VERSIONS': config.mod.mcversions
        ])
    }
    // Copy everything else
    from(sourceSets.main.resources.srcDirs) {
        include 'assets/**/*.*'
    }
}
// Add in a source jar for people, should they desire to download such a thing
task sourceJar(type: Jar) {
    from sourceSets.main.allSource
    classifier = 'sources'
    version = project.version
}
task javadocJar(type: Jar) {
    from javadoc
    classifier = 'javadoc'
    version = project.version
}

// Add in an mcp named jar, for those who wish to run in a development environment (assuming mcp naming matches)
task deobfJar(type: Jar) {
    from sourceSets.main.output
    classifier = 'dev'
    version = "${project.version}"
    manifest {
        attributes 'FMLCorePlugin': 'codechicken.core.launch.DepLoader'
        attributes 'FMLCorePluginContainsFMLMod': 'true'
    }
}

// Tell the artifact system about our extra jars
artifacts {
    archives sourceJar, javadocJar, deobfJar
}
ext.TRAVIS = _hasProperty("TRAVIS") && _property("TRAVIS").toBoolean()
ext.SECURITY = !TRAVIS
apply plugin: 'maven'
if (SECURITY) {
    apply plugin: 'signing'
    signing {
        sign configurations.archives
    }
}
tasks.getByName("uploadArchives").onlyIf { !hasProperty("fail") || !fail }
uploadArchives {
  repositories {
    mavenDeployer {
      if (SECURITY) {
        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
      }

      repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
        authentication(userName: ossrhUsername, password: ossrhPassword)
      }

      snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
        authentication(userName: ossrhUsername, password: ossrhPassword)
      }

      pom.project {
        name "${config.mod.id}"
        packaging 'jar'
        description 'TSModCore mod for Minecraft'
        url 'https://github.com/TechShroom/TSModCore'

        scm {
          connection 'git://github.com/TechShroom/TSModCore'
          developerConnection 'git://github.com/TechShroom/TSModCore'
          url 'https://github.com/TechShroom/TSModCore'
        }

        licenses {
          license {
            name 'The MIT License'
            url 'https://github.com/TechShroom/TSModCore/blob/master/LICENSE'
          }
        }

        developers {
          developer {
            id 'kenzierocks'
            name 'Kenzie Togami'
            email 'ket1999@gmail.com'
          }
        }
      }
    }
  }
}