build.gradle

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

allprojects {
    repositories { 
        jcenter()
        
    }
}

apply plugin: 'net.minecraftforge.gradle.forge'
apply plugin: 'maven'
apply from: 'build.properties'

minecraft {
    runDir = "run"
}

project.version = getVersion()
project.ext.shortVersion = getShortVersion()

minecraft {
    replace "@VERSION@", project.shortVersion
    replace "@MODID@", project.modid
    replace "@MODNAME@", project.longname
    replaceIn "MHFCReference.java"
}

processResources {
    // this will ensure that this task is redone when the versions change.
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version

    from(sourceSets.main.resources.srcDirs) {
        include 'mcmod.info'
        expand project.properties
    }
    
    from(sourceSets.main.resources.srcDirs) {
        exclude 'mcmod.info'
    }
}

dependencies {
    testCompile 'junit:junit:4.12'
}

task deobfJar(type: Jar) {
	group = 'build'
	description = 'Assemble a jar archive containing the deobfuscated classes'
	
    from sourceSets.main.output
    classifier = 'deobf'
}

task release(dependsOn: 'build') {
	group = 'build'
	description = 'Assemble this project for a release'
	
	doLast {
		println "Ready to release ${project.version}"
	}
}

task preRelease(dependsOn: 'build') {
	group = 'build'
	description = 'Assemble this project for a pre-release'
	
	doLast {
		println "Ready to pre-release ${project.version}"
	}
}

enum ReleaseType {
	NONE, RELEASE_CANDIDATE, RELEASE
}

project.ext.releaseType = ReleaseType.NONE;

gradle.taskGraph.whenReady {taskGraph ->
	if(taskGraph.hasTask(preRelease)) {
    	project.releaseType = ReleaseType.RELEASE_CANDIDATE
	}
	if(taskGraph.hasTask(release)) {
    	project.releaseType = ReleaseType.RELEASE
	}
}

task updateBuildMetadata {
	group = 'build'
	description = 'Updates the build metadata and update.json'
	
	doLast {
		// Skip anything that is not on branch master or not a release
		def isRelease = project.releaseType == ReleaseType.RELEASE_CANDIDATE ||
				project.releaseType == ReleaseType.RELEASE;

		if(!isRelease || getArtifactID() != '') {
			logger.lifecycle("Building with artifact-id ${getArtifactID()}, skipping update to update.json")
		 	return;
		}
		
		def metadataFolder = new File(project.buildDir, 'mhfc-update-metadata')
		def deleteResult = metadataFolder.deleteDir()
		if(!deleteResult) {
			throw new TaskExecutionException("Couldn't delete local clone of metadata folder");
		}
		
		def stdout = new ByteArrayOutputStream()
		// Clone the updates branch
		exec {
            executable "git"
            args "clone", "-b", "updates", "--single-branch", "git@github.com:Guild-Hall/MHFC.git", metadataFolder
            standardOutput = stdout
		}
		logger.lifecycle("${stdout}");
		
		def buildData = new File(metadataFolder, 'update.json')
		if(!buildData.exists()) {
			buildData << '{}'
		}
		def parsedJson = new groovy.json.JsonSlurper().parse(buildData)
		
		if(!parsedJson.hasProperty("homepage")) {
			parsedJson.homePage = "https://minecraft.curseforge.com/projects/monster-hunter-frontier-craft"
		}
		
		def mcversion = project.minecraft.version.toString()
		if(!parsedJson[mcversion]) {
			logger.lifecycle("${parsedJson} doesn't have ${mcversion}");
			parsedJson[mcversion] = [:]
		}
		
		def modversion = project.shortVersion.toString()
		def version = parsedJson[mcversion]
		if(version[modversion]) {
			logger.lifecycle("Version ${modversion} seems to already be published, skipping update")
			return;
		}
		version[modversion] = "See our homepage for changelogs"
		
		if(!parsedJson.promos) {
			parsedJson.promos = [:]
		}
		def promos = parsedJson.promos
		promos["${mcversion}-latest"] = modversion
		if(project.releaseType == ReleaseType.RELEASE) {
			promos["${mcversion}-recommended"] = modversion
		}
		
		buildData.newWriter().withWriter {
			it << new groovy.json.JsonBuilder(parsedJson).toPrettyString()
		}
		
		// Push the updates branch
		stdout.reset();
		exec {
			workingDir metadataFolder
            executable "git"
            args "add", "update.json"
            standardOutput = stdout
		}
		logger.lifecycle("${stdout}");
		stdout.reset();
		exec {
			workingDir metadataFolder
            executable "git"
            args "commit", "-m", "Automated update for build " + modversion
            standardOutput = stdout
		}
		logger.lifecycle("${stdout}");
		stdout.reset();
		exec {
			workingDir metadataFolder
            executable "git"
            args "push", "origin", "updates"
            standardOutput = stdout
		}
		logger.lifecycle("${stdout}");
	}
}

tasks["sourceJar"].classifier = 'sources'

tasks.build.dependsOn('deobfJar', 'sourceJar')
tasks.install.dependsOn 'build'

tasks.release.dependsOn('updateBuildMetadata')
tasks.preRelease.dependsOn('updateBuildMetadata')

// Always run these tasks
tasks.runClient.outputs.upToDateWhen { false }
tasks.runServer.outputs.upToDateWhen { false }

artifacts {
    archives jar
    archives sourceJar
    archives deobfJar
}

test {
    testLogging {
        exceptionFormat "full"
    }
    afterTest { desc, result -> 
        println "${desc.className} > ${desc.name} ${result.resultType}"
    }
}

def getShortVersion() {
    def stdout = new ByteArrayOutputStream()
    exec {
        executable "git"
        args "rev-list", "--count", "HEAD"
        standardOutput = stdout
    }
    def revision = stdout.toString().trim()
    return "${major}.${minor}.${patch}.${revision}"
}

def getVersion() {
	return getShortVersion() + getArtifactID() + "+${minecraft.version}"
}

def getArtifactID() {
    def stdout = new ByteArrayOutputStream()
    exec {
        executable "git"
        args "rev-parse", "--abbrev-ref", "HEAD"
        standardOutput = stdout
    }
    def branch = stdout.toString().trim()
    if(branch == "HEAD") {
        stdout.reset()
        exec {
            executable "git"
            args "rev-parse", "--short", "HEAD"
            standardOutput = stdout
        }
        branch = stdout.toString().trim()
    }
    def branchID = branch == 'master' ? '' : '-' + branch.replaceAll('[^0-9A-Za-z-\\.]', '-')
	return [branchID].join('-')
}