mcbuild.gradle

// Hea3veN's build script for minecraft mods
// v1.0.7 (2016-05-09):
//     * Remove the code to update the README
// v1.0.6 (2016-05-05):
//     * Update to java 8
// v1.0.5 (2016-03-08):
//     * Add the FMLCorePluginContainsFMLMod attribute to the manifest if there is a coremod
//     * Add version replacement for kotlin projects
// v1.0.4 (2016-03-08):
//     * Fix issue when the changelog doesn't have the current version
// v1.0.3 (2016-03-01):
//     * Actually use the project_bootstrap_file value
// v1.0.2 (2016-02-07):
//     * Define the run directory
// v1.0.1 (2016-02-02):
//     * Forge doesn't like @ in the dependencies versions
// v1.0.0 (2016-01-31):
//     * Initial release


buildscript {
	repositories {
		jcenter()
	}
	dependencies {
		classpath 'org.ajoberstar:grgit:1.4.1'
		classpath 'org.apache.httpcomponents:httpclient:4.3.3'
	}
}

apply plugin: McBuildPlugin

import groovy.json.JsonBuilder
import groovy.json.JsonSlurper
import org.ajoberstar.grgit.Grgit
import org.apache.http.client.methods.HttpPost
import org.apache.http.entity.StringEntity
import org.apache.http.impl.client.HttpClientBuilder

version = "${version_mc}-${project_version}"
group = "${project_group}"
archivesBaseName = "${project_name}"

sourceCompatibility = 1.8
targetCompatibility = 1.8

minecraft {
	version = "${version_mc}-${version_forge}" + (project.hasProperty('version_forge_branch')? '-' + version_forge_branch : '')
	mappings = version_mappings
	runDir = 'run'

	if (project.hasProperty('project_coremod')) {
		coreMod = project_coremod
	}

	def project_class_path = project_class.replace('.', '/')
	replaceIn "src/main/java/${project_class_path}.java"
	replace 'PROJECTVERSION', project.version
	replace 'MCVERSION', project.minecraft.version
	replace 'FORGEVERSION', version_forge
}

if (project.hasProperty('project_coremod')) {
	jar.manifest.attributes.put('FMLCorePluginContainsFMLMod', 'true')
}

if (project.hasProperty('project_curseforge_id')) {
	curseforge {
		apiKey = project.hasProperty('curseForgeApiKey') ? project.curseForgeApiKey : ''

		project {
			id = project_curseforge_id
			releaseType = 'release'
			changelog = UpdateFile.
					getChangelog(new File(projectDir, project_update_file), version_mc, project.version).
					replace('\n', '\r\n')
			addGameVersion version_mc
		}
	}
}

repositories {
	mavenLocal()
	maven {
		url "https://raw.github.com/hea3ven/mvn-repo/master"
	}
//	maven {
//		name "JEI"
//		url "http://dvs1.progwml6.com/files/maven"
//	}
}

configurations {
	runmods
}

dependencies {
//	deobfCompile "mezz.jei:jei_1.8.9:2.24.0.109"
}

processResources {
	from(sourceSets.main.resources.srcDirs) {
		include 'mcmod.info'
		include project_bootstrap_file
		expand project.properties
		expand 'version': project.version, 'mcversion': project.minecraft.version
	}

	from(sourceSets.main.resources.srcDirs) {
		exclude 'mcmod.info'
		exclude project_bootstrap_file
	}
}

class McBuildPlugin implements Plugin<Project> {
	void apply(Project project) {
		project.configurations.create('release')
		project.configurations.release.transitive = false
	}
}

if (project.hasProperty('project_bootstrap_file')) {

	sourceSets.main.java.srcDirs += 'src/bootstrap/java'

	jar {
		manifest {
			attributes("H3NTBootstrap": project_bootstrap_file)
		}
		into('libs') {
			from configurations.release
		}
	}
}

task copyRunMods(type: Copy) {
	from configurations.runmods.files
	into minecraft.runDir + "/mods/"
}
setupDecompWorkspace.dependsOn copyRunMods

if (tasks.findByPath('compileKotlin') != null) {
	task updateMainKotlinFile << {
		def mainFile = new File('src/main/java/' + project_class.replace('.', '/') + '.kt')
		if (mainFile.exists()) {
			def content = mainFile.text.
					replaceAll(/val VERSION = "[^"]*"/, 'val VERSION = "' + project.version + '"').
					replaceAll(/Forge@\[[^,]*,\)/, "Forge@[$version_forge,)")
			mainFile.withWriter { w -> w << content }
		}
	}
	compileKotlin.dependsOn updateMainKotlinFile
}

task updateChangelog << {
	UpdateFile updateFile = UpdateFile.load(new File(projectDir, project_update_file))
	def repo = Grgit.open(file("."))

	Changelog changelog = new Changelog()
	repo.log { range(updateFile.commits[version_mc], 'HEAD') }.findAll { it.fullMessage.startsWith('* ') }.
			collect { it.fullMessage.trim().substring(2) }.each { changelog.addLine(it) }

	updateFile.addChangelog(version_mc, (String) project.version, changelog)
	updateFile.promotions["${version_mc}-latest"] = project.version
	updateFile.promotions["${version_mc}-recommended"] = project.version
	updateFile.commits[version_mc] = repo.head().id

	updateFile.save(new File(projectDir, project_update_file))

	updateFile.saveChangelog(new File(projectDir, project_changelog_file))
}

class UpdateFile {
	String homepage = null
	Map<String, String> promotions = new HashMap()
	Map<String, String> commits = new HashMap()
	Map<String, Map<String, Changelog>> versions = new HashMap()

	static def load(File file) {
		def data = new JsonSlurper().parseText(file.text)
		def updateFile = new UpdateFile()
		data.each { mcVersion, v ->
			if (mcVersion == 'homepage') {
				updateFile.homepage = v
			} else if (mcVersion == 'promos') {
				v.each { promoName, promoVersion ->
					updateFile.promotions.put(promoName, promoVersion)
				}
			} else {
				updateFile.versions[mcVersion] = new HashMap()
				v.each { version, changelogText ->
					if (version == 'commit')
						updateFile.commits[mcVersion] = changelogText
					else
						updateFile.versions[mcVersion].put(version, new Changelog(changelogText))
				}
			}

		}
		updateFile
	}

	static def getChangelog(File file, String mcVersion, String version) {
        def changelogFile = load(file)
        if (!changelogFile.versions.containsKey(mcVersion))
            return ''
        if (!changelogFile.versions[mcVersion].containsKey(version))
            return ''
		def changelog = changelogFile.versions[mcVersion][version]
		(changelog != null) ? changelog.save() : ''
	}

	def addChangelog(String mcVersion, String version, Changelog changelog) {
		if (!versions.containsKey(mcVersion))
			versions[mcVersion] = new HashMap()
		versions[mcVersion].put(version, changelog)
	}

	def save(File file) {
		Map<String, Object> data = new HashMap()
		data.put('homepage', homepage)
		data.put('promos', promotions)
		versions.each { mcVersion, v ->
			data[mcVersion] = new HashMap()
			data[mcVersion]['commit'] = commits[mcVersion]
			v.each { version, changelog ->
				data[mcVersion][version] = changelog.save()
			}
		}
		file.setText(new JsonBuilder(data).toPrettyString())
	}

	def saveChangelog(File file) {
		def changelogText = ''
		versions.sort { it.key }.collect { it.value }.reverseEach {
			def sortedChangelogs = [:]
			it.sort {
				it.key + ((!it.key.contains('-beta') && !it.key.contains('-alpha')) ? '-release' : '')
			}.reverseEach { sortedChangelogs[it.key] = it.value }
			sortedChangelogs.each {
				version, changelog -> changelogText += version + ':\n' + changelog.save() + '\n\n'
			}
		}
		file.setText(changelogText)
	}
}

class Changelog {
	ArrayList additions = new ArrayList()
	ArrayList removes = new ArrayList()
	ArrayList fixes = new ArrayList()
	ArrayList extra = new ArrayList()

	def Changelog(String text = null) {
		if (text != null)
			text.eachLine { addLine(it) }
	}

	def addLine(String line) {
		if (line.startsWith('    * '))
			line = line.substring(6)
		if (line.endsWith('.'))
			line = line.substring(0, line.length() - 1)
		if (line.startsWith('Add'))
			additions.add(line)
		else if (line.startsWith('Remove'))
			removes.add(line)
		else if (line.startsWith('Fix'))
			fixes.add(line)
		else
			extra.add(line)
	}

	String save() {
		(additions + removes + extra + fixes).collect { '    * ' + it + '.' }.join('\n')
	}
}

task commitRelease(dependsOn: 'curseforge') << {
	def repo = Grgit.open(file("."))
	repo.commit(message: 'Version ' + project.version, all: true)
}

task pushRelease(type: Exec, dependsOn: commitRelease) {
	commandLine 'git', 'push'
}

def readCurrentDownloads() {
	def downloads = '\n'
	new File(project.projectDir, "README.md").eachLine { line ->
		if (line.contains('www.curse.com')) {
			downloads = downloads + line
		}
	}
	return downloads
}

task githubRelease(dependsOn: pushRelease) << {
	def httpClient = HttpClientBuilder.create().build();

	def req = new HttpPost('https://api.github.com/repos/' + project_repo + '/releases')
	req.addHeader('User-Agent', 'Mozilla/5.0 Ubuntu/8.10 Firefox/3.0.4')
	req.addHeader('Authorization', 'Basic ' + (project.githubUser + ':' + project.githubPassword)
			.getBytes('iso-8859-1')
			.encodeBase64())
	req.addHeader("content-type", "application/json")
	req.setEntity(new StringEntity('{'
			+ '    "tag_name": "v' + project.version + '",'
			+ '    "target_commitish": "' + project_repo_branch + '",'
			+ '    "name": "Version ' + project.version + '",'
			+ '    "body": "```\\n' +
			UpdateFile.getChangelog(new File(projectDir, project_update_file), version_mc, project.version).
					replace('\n', '\\n').replace('\t', '    ') + '\\n```\\n'
			+ readCurrentDownloads().replace('\n', '\\n') + '",'
			+ '    "draft": false'
			+ '}'))

	def response = httpClient.execute(req);
//	if (response.statusLine.statusCode != 200) {
//		def reader = new BufferedReader(new InputStreamReader(response.entity.content))
//		reader.eachLine { line ->
//			println line
//		}
//	}
}

task release(dependsOn: 'githubRelease') << {
	println "Released v" + project.version
}