build.gradle

//file:noinspection SpellCheckingInspection
buildscript {
	repositories {
		maven {
			name "Fabric Repository"
			url "https://maven.fabricmc.net"
		}
		mavenCentral()
		mavenLocal()
		maven {
			name "Jitpack"
			url "https://jitpack.io"
		}
	}
	dependencies {
		classpath "cuchaz:enigma-cli:${project.enigma_version}"
		classpath "com.github.Chocohead:Stitch:${project.stitch_hash}"
		classpath "commons-io:commons-io:2.8.0"
		classpath "de.undercouch:gradle-download-task:4.1.1"
		classpath("com.github.js6pak:tiny-remapper:c389241") {
			transitive = false
		}
		classpath "net.fabricmc.unpick:unpick:${project.unpick_version}"
		classpath "net.fabricmc.unpick:unpick-format-utils:${project.unpick_version}"
		classpath "net.fabricmc:name-proposal:${project.name_proposal_version}"
		classpath "org.codehaus.groovy:groovy-all:3.0.11"
	}
}

plugins {
	id "java" // for constants, packages, javadoc
	id "de.undercouch.download" version "4.1.1"
	id "maven-publish"
	id "org.cadixdev.licenser" version "0.6.1"
	id "net.fabricmc.filament" version "0.3.0"
}

def minecraft_version = "b1.7.3"

def taskName = project.gradle.startParameter.taskNames[0]
def ENV = System.getenv()
// Fetch build number from Github Actions
def build_number = ENV.GITHUB_RUN_NUMBER && taskName != "publishToMavenLocal" ? ENV.GITHUB_RUN_NUMBER : "local"

def yarnVersion = "${minecraft_version}+build.$build_number"
version = yarnVersion

System.out.println("Preparing yarn ${yarnVersion}")

repositories {
	mavenCentral()
	maven {
		name "Babric Repository"
		url "https://maven.glass-launcher.net/babric/"
	}
	maven {
		name "Fabric Repository"
		url "https://maven.fabricmc.net"
	}
	maven {
		name "Mojang"
		url "https://libraries.minecraft.net/"
	}
	mavenLocal()
}

configurations {
	enigmaRuntime
	javadocClasspath
	decompileClasspath
	mappingPoetJar {
		transitive = false
	}
	mappingPoet {
		extendsFrom mappingPoetJar
		transitive = true
	}
	unpick
}

def unpickMetaFile = file("unpick-definitions/unpick.json")

dependencies {
	enigmaRuntime "cuchaz:enigma-swing:${project.enigma_version}"
	enigmaRuntime "net.fabricmc:name-proposal:${project.name_proposal_version}"
	javadocClasspath "net.fabricmc:fabric-loader:${project.fabric_loader_version}"
	javadocClasspath "org.jetbrains:annotations:${project.jetbrains_annotations_version}"
	javadocClasspath "com.google.code.findbugs:jsr305:3.0.2" // for some other jsr annotations
	decompileClasspath "net.fabricmc:cfr:${project.cfr_version}"
	mappingPoetJar "net.fabricmc:mappingpoet:${project.mappingpoet_version}"
	unpick "net.fabricmc.unpick:unpick-cli:${project.unpick_version}"
	// Update asm to allow running on JDK 18
	unpick "org.ow2.asm:asm:${project.asm_version}"
	unpick "org.ow2.asm:asm-tree:${project.asm_version}"
	unpick "org.ow2.asm:asm-commons:${project.asm_version}"
	unpick "org.ow2.asm:asm-util:${project.asm_version}"
}

def setupGroup = "jar setup"
def yarnGroup = "yarn"
def buildMappingGroup = "mapping build"
def mapJarGroup = "jar mapping"
def mappingsDir = file("mappings")
def cacheFilesMinecraft = file(".gradle/minecraft")
def tempDir = file(".gradle/temp")
def intermediaryJar = file("${minecraft_version}-intermediary.jar")
def unpickedJar = file("${minecraft_version}-intermediary-unpicked.jar")
def namedJar = file("${minecraft_version}-named.jar")
def versionFile = new File(cacheFilesMinecraft, "${minecraft_version}.json")
def clientJar = new File(cacheFilesMinecraft, "${minecraft_version}-client.jar")
def serverJar = new File(cacheFilesMinecraft, "${minecraft_version}-server.jar")
def clientIntermediaryJar = new File(cacheFilesMinecraft, "${minecraft_version}-client-intermediary.jar")
def serverIntermediaryJar = new File(cacheFilesMinecraft, "${minecraft_version}-server-intermediary.jar")
def libraries = new File(cacheFilesMinecraft, "libraries")
def libs = new File("build/libs/")


import com.google.common.hash.Hashing
import com.google.common.io.Files
import com.google.common.net.UrlEscapers
import cuchaz.enigma.command.CheckMappingsCommand
import cuchaz.enigma.command.MapSpecializedMethodsCommand
import groovy.io.FileType
import groovy.json.JsonSlurper
import net.fabricmc.stitch.commands.CommandFixNesting
import net.fabricmc.stitch.commands.CommandMergeTiny
import net.fabricmc.stitch.commands.CommandReorderTiny
import net.fabricmc.stitch.commands.CommandRewriteIntermediary
import net.fabricmc.stitch.merge.JarMerger
import net.fabricmc.tinyremapper.OutputConsumerPath
import net.fabricmc.tinyremapper.TinyRemapper
import net.fabricmc.tinyremapper.TinyUtils
import org.apache.commons.io.FileUtils

import java.nio.charset.StandardCharsets
import java.util.zip.GZIPOutputStream

@SuppressWarnings('GrDeprecatedAPIUsage')
static boolean validateChecksum(File file, String checksum) {
	if (file != null) {
		def hash = Files.asByteSource(file).hash(Hashing.sha1())
		def builder = new StringBuilder()
		hash.asBytes().each {
			builder.append(Integer.toString((it & 0xFF) + 0x100, 16).substring(1))
		}
		return builder.toString() == checksum
	}
	return false
}

task downloadVersionsManifest {
	group = setupGroup
	//inputs.property "mc_ver", minecraft_version
	inputs.property "currenttime", new Date()
	def manifestFile = new File(cacheFilesMinecraft, "version_manifest_v2.json")
	outputs.file(manifestFile)
	doLast {
		logger.lifecycle(":downloading minecraft versions manifest")
		FileUtils.copyURLToFile(new URL("https://babric.github.io/manifest-polyfill/version_manifest_v2.json"), manifestFile)
	}
}

static def getManifestVersion(File manifestFile, String minecraft_version) {
	def manifest = manifestFile.exists() ? new JsonSlurper().parseText(FileUtils.readFileToString(manifestFile, StandardCharsets.UTF_8)) : null
	return manifest != null ? manifest.versions.stream().filter({
		(it.id == minecraft_version)
	}).findFirst() : java.util.Optional.empty()
}

task downloadWantedVersionManifest(dependsOn: downloadVersionsManifest) {
	group = setupGroup
	def manifestFile = downloadVersionsManifest.outputs.files.singleFile
	def manifestVersion = getManifestVersion(manifestFile, minecraft_version)

	//have to grab the release time as there"s a current timestamp on each element?!
	inputs.property "releaseTime", manifestVersion.isPresent() ? manifestVersion.get().releaseTime : -1

	outputs.file versionFile

	doLast {
		manifestVersion = getManifestVersion(manifestFile, minecraft_version)
		//nb need to re-read here in case it didn"t exist before
		if (manifestVersion.isPresent() || versionFile.exists()) {

			if (manifestVersion.isPresent()) {
				FileUtils.copyURLToFile(new URL(manifestVersion.get().url), versionFile)
			}
		} else {
			throw new RuntimeException("No version data for Minecraft version ${minecraft_version}")
		}
	}

}

task downloadMcJars(dependsOn: downloadWantedVersionManifest) {
	group = setupGroup
	inputs.files versionFile

	outputs.files(clientJar, serverJar)

	outputs.upToDateWhen {
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile, StandardCharsets.UTF_8))
		return clientJar.exists() && serverJar.exists() && validateChecksum(clientJar, version.downloads.client.sha1) && validateChecksum(serverJar, version.downloads.server.sha1)
	}

	doLast {
		if (!versionFile.exists()) {
			throw new RuntimeException("Can' t download the jars without the ${versionFile.name} file !")
		}

		//reload in case it changed
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile, StandardCharsets.UTF_8))

		logger.lifecycle(":downloading minecraft jars")

		download {
			src new URL(version.downloads.client.url)
			dest clientJar
			overwrite false
		}

		download {
			src new URL(version.downloads.server.url)
			dest serverJar
			overwrite false
		}
	}
}

task downloadMcLibs(dependsOn: downloadWantedVersionManifest) {
	group = setupGroup
	inputs.files versionFile

	outputs.dir(libraries)

	outputs.upToDateWhen { false }

	doLast {
		if (!versionFile.exists()) {
			throw new RuntimeException("Can't download the jars without the ${versionFile.name} file !")
		}

		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile, StandardCharsets.UTF_8))

		logger.lifecycle(":downloading minecraft libraries")

		if (!libraries.exists()) {
			libraries.mkdirs()
		}

		version.libraries.each {
			if (it.natives || it.name.contains("nightly"))
				return

			def downloadUrl = it.downloads.artifact.url

			download {
				src downloadUrl
				dest new File(libraries, downloadUrl.substring(downloadUrl.lastIndexOf("/") + 1))
				overwrite false
			}

			project.dependencies.add("decompileClasspath", it.name)
		}
	}
}

task downloadIntermediary(type: Download) {
	group = buildMappingGroup
	def url = "https://github.com/babric/intermediary/raw/master/mappings/${minecraft_version}.tiny"
	src UrlEscapers.urlFragmentEscaper().escape(url)
	dest new File(cacheFilesMinecraft, "${minecraft_version}-intermediary.tiny")
}

task remapMcJars(dependsOn: [downloadMcJars, downloadMcLibs, downloadIntermediary]) {
	group = mapJarGroup

	inputs.file clientJar
	inputs.file serverJar
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file clientIntermediaryJar
	outputs.file serverIntermediaryJar

	doLast {
		logger.lifecycle(":mapping minecraft to intermediary")
		mapJar(clientIntermediaryJar, clientJar, downloadIntermediary.dest, libraries, "client", "intermediary")
		mapJar(serverIntermediaryJar, serverJar, downloadIntermediary.dest, libraries, "server", "intermediary")
	}
}

task mergeJars(dependsOn: remapMcJars) {
	group = setupGroup
	inputs.files(serverJar, clientJar)
	outputs.file(intermediaryJar)

	doLast {
		logger.lifecycle(":merging jars")

		if (intermediaryJar.exists()) {
			return
		}

		def jarMerger = new JarMerger(clientIntermediaryJar, serverIntermediaryJar, intermediaryJar)
		jarMerger.merge()
		jarMerger.close()

		CommandFixNesting.run(intermediaryJar)
	}

}

task invertIntermediary(dependsOn: downloadIntermediary, type: FileOutput) {
	group = buildMappingGroup
	def v1Input = downloadIntermediary.dest

	output = new File(cacheFilesMinecraft, "${minecraft_version}-intermediary-inverted.tiny")
	outputs.file(output)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":building inverted intermediary")

		String[] v1Args = [
				v1Input.getAbsolutePath(),
				output.getAbsolutePath(),
				"intermediary", "official"
		]

		new CommandReorderTiny().run(v1Args)
	}
}

task patchIntermediary(dependsOn: [mergeJars, downloadIntermediary]) {
	group = buildMappingGroup
	def intermediaryTinyInput = downloadIntermediary.outputs.files.singleFile

	def outputFile = new File(cacheFilesMinecraft, "${minecraft_version}-intermediary-full.tiny")
	outputs.file(outputFile)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":patching intermediary")
		String[] args = [
				intermediaryJar.getAbsolutePath(),
				intermediaryTinyInput.getAbsolutePath(),
				outputFile.getAbsolutePath(),
				"--writeAll"
		]

		new CommandRewriteIntermediary().run(args)
	}
}

task yarn(dependsOn: "unpickIntermediaryJar", type: JavaExec) {
	group = yarnGroup

	classpath = configurations.enigmaRuntime
	mainClass.set 'cuchaz.enigma.gui.Main'

	args '-jar'
	args unpickedJar.getAbsolutePath()
	args '-mappings'
	args mappingsDir.getAbsolutePath()
	args '-profile'
	args 'enigma_profile.json'

	jvmArgs "-Xmx2048m"
}

task yarnWithoutUnpick(dependsOn: mergeJars, type: JavaExec) {
	group = yarnGroup

	classpath = configurations.enigmaRuntime
	mainClass.set "cuchaz.enigma.gui.Main"

	args "-jar"
	args intermediaryJar.getAbsolutePath()
	args "-mappings"
	args mappingsDir.getAbsolutePath()
	args "-profile"
	args "enigma_profile.json"

	jvmArgs "-Xmx2048m"
}

task checkMappings(dependsOn: mergeJars) {
	group = buildMappingGroup
	inputs.dir mappingsDir
	doLast {
		logger.lifecycle(":checking mappings")

		String[] args = [
				intermediaryJar.getAbsolutePath(),
				mappingsDir.getAbsolutePath()
		]

		try {
			new CheckMappingsCommand().run(args)
		} catch (IllegalStateException ignored) {
			// just print, don"t fail the task
		}
	}
}

task buildYarnTiny(dependsOn: mergeJars, type: FileOutput) {
	group = buildMappingGroup
	inputs.dir mappingsDir
	if (!libs.exists()) {
		libs.mkdirs()
	}

	output = new File(tempDir, "yarn-mappings.tiny")

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":generating tiny mappings")

		new MapSpecializedMethodsCommand().run(
				intermediaryJar.getAbsolutePath(),
				"enigma",
				mappingsDir.getAbsolutePath(),
				"tiny:intermediary:named",
				output.getAbsolutePath()
		)
	}
}

task mergeTiny(dependsOn: ["buildYarnTiny", "downloadIntermediary"], type: FileOutput) {
	group = buildMappingGroup
	def yarnTinyInput = buildYarnTiny.output
	def intermediaryTinyInput = downloadIntermediary.dest

	output = new File(tempDir, "mappings.tiny")
	outputs.file(output)

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":merging yarn and intermediary")
		String[] args = [
				intermediaryTinyInput.getAbsolutePath(),
				yarnTinyInput.getAbsolutePath(),
				output.getAbsolutePath(),
				"intermediary",
				"client",
				"server"
		]

		output.delete()
		new CommandMergeTiny().run(args)
	}
}

combineUnpickDefinitions {
	group = 'unpick'
	input = file('unpick-definitions')
	output = new File(tempDir, 'definitions.unpick')
}

remapUnpickDefinitionsIntermediary {
	dependsOn buildYarnTiny
	group = 'unpick'
	output = new File(tempDir, 'intermediary-definitions.unpick')
	mappings = buildYarnTiny.output
}

task unpickIntermediaryJar(type: JavaExec, dependsOn: [mergeJars, "constantsJar", remapUnpickDefinitionsIntermediary]) {
	outputs.upToDateWhen { false }
	group "unpick"

	mainClass.set "daomephsta.unpick.cli.Main"
	systemProperty "java.util.logging.config.file", file('unpick-logging.properties')
	classpath configurations.unpick

	doFirst {
		args intermediaryJar.absolutePath, unpickedJar.absolutePath, remapUnpickDefinitionsIntermediary.output.get().asFile.absolutePath, constantsJar.archiveFile.get().asFile.absolutePath

		configurations.decompileClasspath.files.each {
			args it.absolutePath
		}
	}
}

task tinyJar(type: Jar, dependsOn: [mergeTiny, combineUnpickDefinitions]) {
	group = buildMappingGroup
	outputs.upToDateWhen { false }
	archiveFileName = "barn-${yarnVersion}.jar"
	destinationDirectory.set(file("build/libs"))
	classifier = ""
	from(mergeTiny.output) {
		rename { "mappings/mappings.tiny" }
	}
	from(combineUnpickDefinitions.output) {
		rename combineUnpickDefinitions.output.get().asFile.name, "extras/definitions.unpick"
	}
	from(file(unpickMetaFile)) {
		expand version: project.unpick_version
		rename unpickMetaFile.name, "extras/unpick.json"
	}
	manifest {
		attributes("Minecraft-Version-Id": minecraft_version)
	}
}

task compressTiny(dependsOn: [tinyJar, mergeTiny], type: FileOutput) {
	group = buildMappingGroup
	def outputFile = new File(libs, "barn-tiny-${yarnVersion}.gz")
	outputs.file(outputFile)
	output = outputFile

	def inputFile = mergeTiny.output

	outputs.upToDateWhen { false }

	doLast {
		logger.lifecycle(":compressing tiny mappings")

		def buffer = new byte[1024]
		def fileOutputStream = new FileOutputStream(outputFile)
		def outputStream = new GZIPOutputStream(fileOutputStream)
		def fileInputStream = new FileInputStream(inputFile)

		def length
		while ((length = fileInputStream.read(buffer)) > 0) {
			outputStream.write(buffer, 0, length)
		}

		fileInputStream.close()
		outputStream.finish()
		outputStream.close()
	}
}

clean.doFirst {
	delete tempDir, cacheFilesMinecraft
}

tasks.build.dependsOn "compressTiny", "tinyJar"

task mapNamedJar(dependsOn: ["mergeTiny", "unpickIntermediaryJar"]) {
	group = mapJarGroup
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file(namedJar)

	//Force the task to always run
	outputs.upToDateWhen { false }

	def jsrToJetbrains = [
			"javax/annotation/Nullable"            : "org/jetbrains/annotations/Nullable",
			"javax/annotation/Nonnull"             : "org/jetbrains/annotations/NotNull",
			"javax/annotation/concurrent/Immutable": "org/jetbrains/annotations/Unmodifiable"
	]

	doLast {
		logger.lifecycle(":mapping minecraft to named")

		mapJar(namedJar, unpickedJar, mergeTiny.output, libraries, "intermediary", "named") {
			it.withMappings { out ->
				jsrToJetbrains.each { e ->
					out.acceptClass e.key, e.value
				}
			}
		}
	}
}

// Setup the build for the unpicked constants

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

tasks.withType(JavaCompile).configureEach {
	it.options.encoding = "UTF-8"
	it.options.release = 8
}

sourceSets {
	constants
	packageDocs // package info files
}

license {
	header file("HEADER")
	include "**/*.java"
}

task constantsJar(type: Jar) {
	from sourceSets.constants.output
	archiveClassifier.set "constants"
}

build.dependsOn constantsJar

def fakeSourceDir = file(".gradle/temp/fakeSource")
task genFakeSource(type: JavaExec, dependsOn: ["mergeTiny", "mapNamedJar"]) {
	group = "javadoc generation"
	outputs.upToDateWhen { false }

	mainClass.set "net.fabricmc.mappingpoet.Main"
	classpath configurations.mappingPoet
	args mergeTiny.output.getAbsolutePath(), namedJar.getAbsolutePath(), fakeSourceDir.getAbsolutePath(), libraries.getAbsolutePath()

	doLast {
		logger.lifecycle ":Fake source generated"
	}
}

task decompileCFR(type: JavaExec, dependsOn: [mapNamedJar]) {
	mainClass.set "org.benf.cfr.reader.Main"

	args namedJar.getAbsolutePath(), "--outputdir", file("namedSrc").absolutePath

	doFirst {
		file("namedSrc").deleteDir()
		classpath = configurations.decompileClasspath
	}
}

javadoc {
	dependsOn genFakeSource
	dependsOn downloadMcLibs
	group = "javadoc generation"
	outputs.upToDateWhen { false }

	def mappingPoetJar = project.provider { zipTree configurations.mappingPoetJar.singleFile }

	failOnError = false
	maxMemory = "2G"

	// verbose = true // enable to debug
	options {
		// verbose() // enable to debug
		source = "17"
		encoding = "UTF-8"
		charSet = "UTF-8"
		memberLevel = JavadocMemberLevel.PRIVATE
		splitIndex true
		tags(
				"apiNote:a:API Note:",
				"implSpec:a:Implementation Requirements:",
				"implNote:a:Implementation Note:"
		)
		taglets "net.fabricmc.mappingpoet.jd.MappingTaglet"
		// taglet path, header, extra stylesheet settings deferred
		it.use()

		addBooleanOption "-allow-script-in-comments", true
		addBooleanOption "-ignore-source-errors", true
		links(
				"https://guava.dev/releases/21.0/api/docs/",
				"https://www.javadoc.io/doc/com.google.code.gson/gson/2.8.0/",
				"https://logging.apache.org/log4j/2.x/log4j-api/apidocs/",
				"https://javadoc.io/doc/org.jetbrains/annotations/${project.jetbrains_annotations_version}/",
				"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/",
				"https://javadoc.lwjgl.org/",
				"https://fastutil.di.unimi.it/docs/",
				"https://netty.io/4.1/api/",
				"https://commons.apache.org/proper/commons-logging/javadocs/api-1.1.3/",
				"https://commons.apache.org/proper/commons-lang/javadocs/api-3.5",
				"https://commons.apache.org/proper/commons-io/javadocs/api-2.5",
				"https://commons.apache.org/proper/commons-codec/archives/1.10/apidocs",
				"https://commons.apache.org/proper/commons-compress/javadocs/api-1.8.1/",
				"https://maven.fabricmc.net/docs/fabric-loader-${project.fabric_loader_version}/",
				"https://docs.oracle.com/en/java/javase/17/docs/api/"
		)
		// https://docs.oracle.com/en/java/javase/17/docs/specs/man/javadoc.html#additional-options-provided-by-the-standard-doclet
		addBooleanOption "Xdoclint:html", true
		addBooleanOption "Xdoclint:syntax", true
		addBooleanOption "Xdoclint:reference", true
		addBooleanOption "Xdoclint:accessibility", true
	}
	source fileTree(fakeSourceDir) + sourceSets.constants.allJava + sourceSets.packageDocs.allJava
	classpath = configurations.javadocClasspath.plus downloadMcLibs.outputs.files.asFileTree

	doLast {
		project.copy {
			from mappingPoetJar
			include "copy_on_click.js"
			into javadoc.outputDirectory
		}
	}

	doFirst {
		// lazy setting
		options {
			tagletPath configurations.mappingPoet.files.toList()
			header mappingPoetJar.get().filter { it.name == "javadoc_header.txt" }.singleFile.text.trim()
			// cannot include line breaks
			addFileOption "-add-stylesheet", mappingPoetJar.get().filter { it.name == "forms.css" }.singleFile
		}
	}
}

task javadocJar(type: Jar, dependsOn: ["javadoc"]) {
	group = "javadoc generation"

	from javadoc.destinationDir

	archiveVersion.set yarnVersion
	archiveClassifier.set "javadoc"
}

generatePackageInfoMappings {
	dependsOn mergeJars
	inputJar.set intermediaryJar
	packageName.set "net/minecraft/unused/packageinfo/"
	outputDir.set file("mappings/net/minecraft/unused/packageinfo")
}

javadocLint {
	group = "javadoc generation"
	mappingDirectory.set file("mappings")
}

check.dependsOn javadocLint

publishing {
	publications {
		maven(MavenPublication) {
			groupId "net.legacyfabric"
			artifactId "beta-yarn"
			version yarnVersion

			artifact(compressTiny.output) {
				classifier "tiny"
				builtBy compressTiny
			}

			artifact(tinyJar)

			artifact(constantsJar) {
				classifier "constants"
			}
			//artifact javadocJar
		}
	}
	repositories {
		if (ENV.MAVEN_PUBLISH_CREDENTIALS) {
			maven {
				url "https://repo.legacyfabric.net/repository/legacyfabric"
				credentials {
					username ENV.MAVEN_PUBLISH_CREDENTIALS.split(":")[0]
					password ENV.MAVEN_PUBLISH_CREDENTIALS.split(":")[1]
				}
				authentication {
					basic(BasicAuthentication)
				}
			}
		}
	}
}

// A task to ensure that the version being released has not already been released.
//task checkVersion {
//	doFirst {
//		def xml = new URL("https://maven.glass-launcher.net/babric/babric/barn/maven-metadata.xml").text
//		def metadata = new groovy.xml.XmlSlurper().parseText(xml)
//		def versions = metadata.versioning.versions.version*.text()
//		if (versions.contains(version)) {
//			throw new RuntimeException("${version} has already been released!")
//		}
//	}
//}

//publish.mustRunAfter checkVersion

static void mapJar(File output, File input, File mappings, File libraries, String from, String to,
				   Action<TinyRemapper.Builder> action = {}) {
	if (output.exists()) {
		output.delete()
	}

	def remapperBuilder = TinyRemapper.newRemapper()
			.withMappings(TinyUtils.createTinyMappingProvider(mappings.toPath(), from, to))
			.renameInvalidLocals(true)
			.rebuildSourceFilenames(true)
			.invalidLvNamePattern(~/\$\$\d+/)
			.inferNameFromSameLvIndex(true)

	action.execute(remapperBuilder)
	def remapper = remapperBuilder
			.build()

	try {
		def outputConsumerBuilder = new OutputConsumerPath.Builder(output.toPath())
		// expose output consumer builder to function if there is need in the future
		def outputConsumer = outputConsumerBuilder.build()
		outputConsumer.addNonClassFiles(input.toPath())
		remapper.readInputs(input.toPath())

		libraries.eachFileRecurse(FileType.FILES) { file ->
			remapper.readClassPath(file.toPath())
		}
		remapper.apply(outputConsumer)
		outputConsumer.close()
		remapper.finish()
	} catch (Exception e) {
		remapper.finish()
		throw new RuntimeException("Failed to remap jar", e)
	}
}

class FileOutput extends DefaultTask {
	@OutputFile
	File output
}