build.xml

<project name="TabulaRasa" default="install" basedir=".">
	<property environment="env"/>
	
	<!-- Basic directories -->
	<property name="src.dir" value="src/main/java"/>
	<property name="resources.dir" value="src/main/resources"/>
	<property name="build.dir" value="build"/>
	<property name="download.dir" value="${build.dir}/downloads"/>
	
	<!-- Project information -->
	<property name="build.name" value="${ant.project.name}"/>
	<property name="class.pckg" value="tabularasa"/>
	<!-- Version file -->
	<property name="verclass.dir" value="${src.dir}/${class.pckg}" />
	<property name="verclass.name" value="TabulaRasa.java"/>

	<!-- Forge version -->
	<property name="mc.version"  value="1.7.10"/>
	<property name="forge.major" value="10"/>
	<property name="forge.minor" value="13"/>
	<property name="forge.patch" value="0"/>
	<property name="forge.build" value="1205"/>
	
	<!-- Packaging -->
	<property name="dist.dir" value="${build.dir}/dist"/>
	<property name="classes.dir" value="${build.dir}/packaging"/>
	<property name="apiclasses.dir" value="${build.dir}/api-packaging"/>
	
	<!-- Forge paths -->
	<property name="forge.version" value="${mc.version}-${forge.major}.${forge.minor}.${forge.patch}.${forge.build}"/>
	<property name="forge.dir" value="${build.dir}/forge"/>
	<property name="forgebuild.dir" value="${forge.dir}/build"/>
	<property name="compile.dir" value="${forgebuild.dir}/tmp/compile"/>
	<property name="lib.dir" value="${forgebuild.dir}/libs"/>
	<property name="sources.dir" value="${forgebuild.dir}/sources/minecraft"/>
	<property name="transformers.dir" value="${forge.dir}/src/main/resources/"/>
	<property name="forge.stsh" value="${build.dir}/.gradle/caches/minecraft/net/minecraftforge/forge/${forge.version}"/>
	<property name="forge.jar" value="${forge.stsh}/forgeSrc-${forge.version}.jar"/>
	<property name="reobf.cmd" value="${download.dir}/bon.jar"/>
	<property name="forge.url" value="http://files.minecraftforge.net/maven/net/minecraftforge/forge/${forge.version}/forge-${forge.version}-src.zip"/>
	
	<!-- Classpaths -->
	<path id="mcp.classpath">
		<pathelement location="${forge.jar}"/>
		<fileset dir="${lib.dir}">
			<include name="*.jar"/>
			<include name="**/*.jar"/>
			<exclude name="${reobf.jar}"/>
		</fileset>
		<fileset dir="${build.dir}/.gradle/caches">
			<include name="modules*/files*/**/*.jar"/>
			<exclude name="modules*/files*/commons-io/commons-io/1.4/**/*.jar"/>
			<exclude name="modules*/files*/com.google.guava/guava/14*/**/*.jar"/>
			<exclude name="modules*/files*/com.google.guava/guava/15*/**/*.jar"/>
		</fileset>
	</path>
	<path id="gson">
		<fileset dir="${build.dir}/.gradle/caches">
			<include name="modules*/files*/com.google.code.gson/**/*.jar"/>
		</fileset>
	</path>
	
	<!-- Task skipping -->
	<target name="properties">
		<!-- Enforce some paths -->
		<mkdir dir="${build.dir}"/>
		<mkdir dir="${download.dir}"/>
		<!-- Set properties -->
		<available property="has.api" file="${src.dir}/${class.pckg}/api"/>
		<available property="bon.exists" file="${reobf.cmd}"/>
		<available property="forge.exists" file="${download.dir}/forge-${forge.version}-src.zip"/>
		<condition property="forge.already.installed">
			<available file="${forge.dir}/build/dirtyArtifacts/forgeSrc-${forge.version}.jar" type="file"/>
		</condition>
		<condition property="have.libs">
			<and>
				<istrue value="${forge.exists}"/>
			</and>
		</condition>
	</target>
	
	<!-- Dependency downloading -->

	<target name="download-core" depends="properties" unless="forge.exists">
	</target>

	<target name="get-dependencies" depends="get-version" unless="have.libs">
	</target>

	<target name="extract-dependencies" depends="setup-forge,get-dependencies" unless="have.libs">
		<delete dir="${lib.dir}/"/>
		<mkdir dir="${lib.dir}/"/>
	</target>
	
	<macrodef name="move-transformers"><sequential>
		
	</sequential></macrodef>
	
	<!-- Building process -->
	<target name="install" depends="upload">
		<!-- Cleanup -->
		<delete dir="${apiclasses.dir}"/>
		<delete dir="${classes.dir}"/>
		<delete>
			<fileset dir="${dist.dir}">
				<exclude name="${build.name}${build.full}${build.number}.jar"/>
				<exclude name="${build.name}${build.full}${build.number}-dev.jar"/>
				<exclude name="${build.name}${build.full}${build.number}-API.zip"/>
			</fileset>
		</delete>
	</target>

	<macrodef name="install-lite">
		<attribute name="build"/>
		<attribute name="classes" default="${compile.dir}"/>
		<sequential>
			<copy todir="${classes.dir}" preservelastmodified="true">
				<fileset dir="@{classes}">
					<include name="**/*.class"/>
				</fileset>
				<fileset dir="${resources.dir}"/>
			</copy>
			<update-languages/>
			<jar destfile="${dist.dir}/${build.name}${build.full}@{build}.jar"
				compress="true" level="9" basedir="${classes.dir}"/>
		</sequential>
	</macrodef>

	<target name="build" depends="extract-dependencies,get-build-number,copy-sources">
		<!-- Recompile -->
		<echo message="Compiling..."/>
		<mkdir dir="${compile.dir}"/>
		
		<depend srcdir="${sources.dir}" destdir="${compile.dir}"
			cache="${forgebuild.dir}/tmp/depcache" closure="true">
			<include name="**/*.java"/>
		</depend>
		<javac srcdir="${sources.dir}" destdir="${compile.dir}" target="1.6" source="1.6"
			classpathref="mcp.classpath" debug="true" debuglevel="lines,source" includeAntRuntime="false">
			<include name="**/*.java"/>
		</javac>
		
		<!-- Dev jar -->
		<echo message="Building jar..."/>
		<local name="build"/><property name="build" value="${build.number}-dev"/>
		<install-lite build="${build}"/>

		<!-- Reobf -->
		<echo message="Reobfuscating..."/>
		<java classpath="${reobf.cmd}" classname="immibis.bon.cui.MCPRemap">
			<arg  line="-q -m"/>
			<arg value="-to SRG"/>
			<arg value="-from MCP"/>
			<arg value="-mcp ${forge.stsh}/unpacked"/>
			<arg value="-in ${dist.dir}/${build.name}${build.full}${build}.jar"/>
			<arg value="-out ${dist.dir}/${build.name}${build.full}${build.number}.jar"/>
			<arg value="-ref ${forge.jar}"/>
			<arg value="-jref ${lib.dir}"/>
		</java>
	</target>

	<target name="copy-sources" depends="package-api">
		<!-- Copy source -->
		<mkdir dir="${sources.dir}"/>
		<sync todir="${sources.dir}">
			<fileset dir="${src.dir}"/>
		</sync>
	</target>

	<target name="package-api" depends="get-version" if="has.api">
		<!-- Copy & package API -->
		<copy todir="${apiclasses.dir}/${class.pckg}/api">
			<fileset dir="${src.dir}/${class.pckg}/api"/>
		</copy>
		<zip destfile="${dist.dir}/${build.name}${build.full}${build.number}-API.zip" basedir="${apiclasses.dir}"/>
	</target>

	<target name="setup-forge" depends="download-forge" unless="forge.already.installed">
		<delete dir="${forge.dir}" failonerror="false"/>
		<mkdir dir="${forge.dir}"/>
		<unzip dest="${forge.dir}">
			<fileset dir="${download.dir}">
				<include name="forge-${forge.version}-src.zip"/>
			</fileset>
		</unzip>
		
		<!-- Cleanup -->
		<delete>
			<fileset dir="${forge.dir}">
				<include name="*.txt"/>
				<include name="src/**/*.info"/>
			</fileset>
		</delete>
		<delete dir="${forge.dir}/eclipse" failonerror="false"/>
		<delete dir="${forge.dir}/src/main/java" failonerror="false"/>
		<delete dir="${build.dir}/.gradle/caches/minecraft/net/minecraftforge/forge/${forge.version}/srgs" failonerror="false"/>
		
		<!-- Change executables' permissions -->
		<chmod file="${forge.dir}/gradlew" perm="+x"/>

		<move-transformers/>

		<!-- Install forge -->
		<exec executable="./gradlew" failonerror="true" dir="${forge.dir}/" vmlauncher="false">
			<arg line="-g ../.gradle"/>
			<arg line="extractMinecraftSrc"/>
			<arg line="eclipseClasspath"/>
		</exec>

		<mkdir dir="${compile.dir}"/>
		<mkdir dir="${lib.dir}"/>
		<javac srcdir="${forgebuild.dir}/tmp/recompSrc" destdir="${compile.dir}" target="1.6" source="1.6"
			classpathref="mcp.classpath" debug="true" debuglevel="lines,source" includeAntRuntime="false"/>
		<jar destfile="${forge.jar}" compress="true" level="9" basedir="${compile.dir}"/>
		<copy file="${forge.jar}" todir="${forgebuild.dir}/dirtyArtifacts/"/>
		<delete dir="${compile.dir}"/>
	</target>

	<target name="download-forge" depends="setup-bon,download-core" unless="forge.exists">
		<echo message="Downloading forge... "/>
		<get src="${forge.url}" dest="${download.dir}/forge-${forge.version}-src.zip"/>
	</target>
	
	<target name="setup-bon" depends="properties" unless="bon.exists">
		<echo message="Downloading BON..."/>
		<get src="https://github.com/skyboy/bearded-octo-nemesis/releases/download/1.1/BON.jar" dest="${reobf.cmd}"/>
	</target>
	
	<target name="upload" depends="build" if="CF_API_TOKEN">
		<echo message="Uploading to CurseForge..."/><local name="fileout"/>
		<script language="javascript" classpathref="gson"><![CDATA[
			
			var token = project.getProperty("CF_API_TOKEN");
			var modid = project.getProperty("CF_MOD_ID");
			var gameVersion = null;
			var parser = new com.google.gson.JsonParser();
			var path = project.getProperty("dist.dir");
			var file = new java.lang.StringBuilder(path).append("/").append(project.getProperty("build.name"));
			file.append(project.getProperty("build.full")).append(project.getProperty("build.number"));
			var fileMain = new java.lang.StringBuilder(file).append(".jar");
			var fileDev = new java.lang.StringBuilder(file).append("-dev.jar");
			var fileApi = new java.lang.StringBuilder(file).append("-API.zip");
			
			// version ids
			var version = project.getProperty("mcv");
			var t = new java.lang.StringBuilder("https://minecraft.curseforge.com/api/game/versions?token=");
			t.append(token);
			var con = new java.net.URL(t.toString()).openConnection();
			con = new java.io.InputStreamReader(con.getInputStream());
		
			var data = parser.parse(con).getAsJsonArray();
			
			for (var i = 0, e = data.size(); i < e; ++i) {
				var element = data.get(i).getAsJsonObject();
				if (version.equals(element.get("name").getAsString())) {
					gameVersion = element.get("id").getAsString();
					break;
				}
			}
			if (gameVersion == null) throw "Unable to find game version " + version + "!";
			
			var httpConn;
			function sendFile(requestURL, uploadFile, metadata) {
				var LINE_FEED = "\r\n";
				var boundary = "===" + java.lang.System.currentTimeMillis() + "===";
				         
		        var url = new java.net.URL(requestURL);
		        httpConn = url.openConnection();
		        httpConn.setUseCaches(false);
		        httpConn.setDoOutput(true);
		        httpConn.setDoInput(true);
				var t = new java.lang.StringBuilder("multipart/form-data; boundary=").append(boundary);
		        httpConn.setRequestProperty("Content-Type",  t.toString());
				httpConn.setRequestProperty("X-Api-Token", token);
		        var outputStream = httpConn.getOutputStream();
		        var writer = new java.io.PrintWriter(new java.io.OutputStreamWriter(outputStream, "UTF-8"), true);
				
				writer.append("--").append(boundary).append(LINE_FEED);
		        writer.append("Content-Disposition: form-data; name=\"metadata\"").append(LINE_FEED);
		        writer.append("Content-Type: text/plain; charset=UTF-8").append(LINE_FEED);
		        writer.append(LINE_FEED);
		        writer.append(metadata).append(LINE_FEED);
		        writer.flush();
				
		        var fileName = uploadFile.getName();
		        writer.append("--").append(boundary).append(LINE_FEED);
		        writer.append("Content-Disposition: form-data; name=\"file\"; filename=\"").append(fileName).append("\"");
				writer.append(LINE_FEED);
		        writer.append("Content-Type: application/octet-stream").append(LINE_FEED);
		        writer.append("Content-Transfer-Encoding: binary").append(LINE_FEED);
		        writer.append(LINE_FEED);
		        writer.flush();
		 
		        var inputStream = new java.io.FileInputStream(uploadFile);
		        var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 4096);
		        var bytesRead = -1;
		        while ((bytesRead = inputStream.read(buffer)) != -1) {
		            outputStream.write(buffer, 0, bytesRead);
		        }
		        outputStream.flush();
		        inputStream.close();
		        
		        writer.flush();
		        writer.append(LINE_FEED).flush();
		        writer.append("--").append(boundary).append("--").append(LINE_FEED);
		        writer.close();
			
				return httpConn.getInputStream();
			}
			
			// main file
			var t = new java.lang.StringBuilder("https://minecraft.curseforge.com/api/projects/");
			path = t.append(modid).append("/upload-file").toString();
			
			t = new java.lang.StringBuilder("{changelog:").append('"",');
			t.append("releaseType:\"alpha\",").append("gameVersions:[");
			t.append(gameVersion).append("]}");
			try {
				con = new java.io.InputStreamReader(sendFile(path, file = new java.io.File(fileMain), t.toString()));
			
				var data = parser.parse(con).getAsJsonObject();
				
				fileMain = data.get("id").getAsString();
				t = new java.lang.StringBuilder("Uploaded to CurseForge! File ID: ");
				t.append(fileMain);
				project.setProperty("fileout", t.toString());
	
				t = new java.lang.StringBuilder("{changelog:").append('"",');
				t.append("releaseType:\"alpha\",").append("parentFileID:");
				t.append(fileMain).append("}");
				
				sendFile(path, file = new java.io.File(fileDev), t.toString());
				file = new java.io.File(fileApi);
				if (file.exists()) sendFile(path, file, t.toString());
			} catch(_) {
				t = new java.lang.StringBuilder("Error uploading ").append(file.getName());
				t.append(" to CurseForge! ").append(httpConn.getResponseCode()).append(": ");
				t.append(httpConn.getResponseMessage());
				if (fileMain == null) {
					project.setProperty("fileout", t.toString());
				} else {
					java.lang.System.err.println(t.toString());
				}
			}
			
		]]></script>
		<echo message="${fileout}"/>
	</target>
	
	<macrodef name="update-languages">
		<sequential>
			<script language="javascript"><![CDATA[
				var path = "/assets/cofh/language/";
				var languages = new java.io.File(project.getProperty("resources.dir") + path);
				if (languages.exists() && languages.isDirectory()) {
					var out = "";
					for each(var i in languages.list()) {
						if (i != null && i.length() > 5 && i.indexOf(".lang") == i.length() - 5) {
							out += i.substring(0, i.length() - 5) + ", ";
						}
					}
					if (out.length > 0) {
						var os = new java.io.PrintWriter(project.getProperty("classes.dir") + path + ".languages");
						os.write("["+out.substring(0, out.length - 2)+"]");
						os.flush();
						os.close();
					}
				}
			]]></script>
		</sequential>
	</macrodef>
	
	<target name="verify-version">
		<script language="javascript"><![CDATA[
			var name = project.getProperty("build.full");
			if (name == null || name == "") {
				name = project.getProperty("verclass.name");
				if (name == null || name == "") {
					project.setProperty("build.full", "-");
				}
			}
		]]></script>
	</target>

	<target name="get-version" depends="verify-version,setup-forge" unless="build.full">
		<local name="grep.out"/><local name="mfrv"/>
		<!-- Read version out of file -->
		<script language="javascript"><![CDATA[
			
			var mainClass = new java.io.File(project.getProperty("verclass.dir"), project.getProperty("verclass.name"));
			mainClass = new java.util.Scanner(mainClass, "UTF-8").useDelimiter("\\Z");
			var text = mainClass.next();
			mainClass.close();
			
			var matches = /[0-9.]+R[0-9.]+((RC|B)[0-9]+)?/.exec(text);
			
			project.setProperty("grep.out", matches[0]);
		]]></script>
		
		<!-- Split mod&mc version, update mcmod -->
		<script language="javascript" classpathref="gson"><![CDATA[
			
			versionlist = project.getProperty("grep.out");

			mcversion = versionlist.substring(0, versionlist.indexOf('R'));
			mfrversion = versionlist.substring(versionlist.indexOf('R') + 1);
			
			project.setProperty("mfrv", mfrversion);
			project.setProperty("mcv", mcversion);
			
			var c = project.getProperty("build.channel");
			if (c == null || c == "")
				project.setProperty("build.channel", mfrversion.indexOf("B") > 0 ? "alpha" : (
													 mfrversion.indexOf("RC") > 0 ? "beta" : "release"));
			
			// open file and parse JSON structure
			var file = new java.io.File(project.getProperty("resources.dir") + "/mcmod.info");
			if (file.exists())
			{
				var mcmod = new java.util.Scanner(file, "UTF-8").useDelimiter("\\Z");
				var data = new com.google.gson.JsonParser().parse(mcmod.next()).getAsJsonArray();
				mcmod.close();
				
				// update all version elements
				for (var i = 0, e = data.size(); i < e; ++i) {
					var element = data.get(i).getAsJsonObject();
					element.addProperty("version", mfrversion);
					element.addProperty("mcversion", mcversion);
				}
				
				// write file back, pretty-printed
				var output = new com.google.gson.stream.JsonWriter(new java.io.FileWriter(file));
				output.setIndent("    ");
				new com.google.gson.Gson().toJson(data, output);
				output.close();
			}
		]]></script>
		<echo message="Version: ${mfrv}  Channel: ${build.channel}"/>
		<property name="build.full" value="-[${mcv}]${mfrv}-"/>
	</target>

	<target name="get-build-number" depends="build-number-there" unless="build.number">
		<echo message="!! No build number set !!"/>
		<property name="build.number" value="CUSTOM_BUILD"/>
	</target>

	<target name="build-number-there" depends="get-version" if="env.BUILD_NUMBER" unless="build.number">
		<echo message="Using build number ${env.BUILD_NUMBER}..."/>
		<property name="build.number" value="${env.BUILD_NUMBER}"/>
	</target>

	<target name="clean">
		<delete dir="${build.dir}"/>
	</target>

	<target name="rebuild">
		<delete file="${forge.jar}" failonerror="false"/>
		<delete dir="${forge.dir}"/>
		<delete dir="${download.dir}"/>
		<antcall target="install"/>
	</target>

	<target name="refresh-deps">
		<delete dir="${lib.dir}"/>
		<delete dir="${download.dir}"/>
		<antcall target="install"/>
	</target>

	<target name="jar" depends="install"/>
</project>