build.gradle

buildscript {
	dependencies {
		classpath 'org.kohsuke:github-api:1.114'
		classpath 'com.guardsquare:proguard-gradle:' + (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11) ? '7.2.0-beta2' : '7.1.0')
	}
}

plugins {
	id 'java'
	id 'java-library'
	id 'eclipse'
	id 'maven-publish'
	id 'org.cadixdev.licenser' version '0.6.1'
	id 'org.quiltmc.loom' version '0.12.+' apply false
	id 'com.github.johnrengelman.shadow' version '7.0.0'
}

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

archivesBaseName = "quilt-loader"
// Don't forget to change this in the QuiltLoaderImpl class as well
version = "0.16.0"
def ENV = System.getenv()

allprojects {
	apply plugin: 'java-library'
	apply plugin: 'eclipse'

	if (ENV.SNAPSHOTS_URL) {
		version = version + "-SNAPSHOT"
	}
	if (!ENV.GITHUB_ACTIONS) {
		version = version + "+local"
	}

	repositories {
		maven {
			name = 'Fabric'
			url = 'https://maven.fabricmc.net/'
		}
		maven {
			name = 'Quilt'
			url = 'https://maven.quiltmc.org/repository/release'
		}
		mavenCentral()
	}
	java {
		toolchain {
			languageVersion = JavaLanguageVersion.of(17)
		}
	}
}


configurations {
	include

	implementation {
		extendsFrom include
	}
}

dependencies {
	// fabric-loader dependencies
	api "org.ow2.asm:asm:${project.asm_version}"
	api "org.ow2.asm:asm-analysis:${project.asm_version}"
	api "org.ow2.asm:asm-commons:${project.asm_version}"
	api "org.ow2.asm:asm-tree:${project.asm_version}"
	api "org.ow2.asm:asm-util:${project.asm_version}"

	api("net.fabricmc:sponge-mixin:${project.mixin_version}") {
		exclude module: 'launchwrapper'
		exclude module: 'guava'
	}
	api 'net.fabricmc:tiny-mappings-parser:0.3.0+build.17'
	api 'net.fabricmc:tiny-remapper:0.8.1'
	api 'net.fabricmc:access-widener:2.1.0'

	api 'org.quiltmc:quilt-json5:1.0.1'
	include 'org.quiltmc:quilt-loader-sat4j:2.3.5.1'


	testCompileOnly 'org.jetbrains:annotations:23.0.0'

	// Unit testing
	testImplementation(platform("org.junit:junit-bom:5.7.2"))
	testImplementation("org.junit.jupiter:junit-jupiter")
}

test {
	useJUnitPlatform()
}

processResources {
	inputs.property "version", project.version

	filesMatching("quilt.mod.json") {
		expand "version": project.version
	}
}

java {
	sourceCompatibility = 8
	targetCompatibility = 8
	withJavadocJar()
	withSourcesJar()
}
compileJava {
	options.release.set(8)
}
jar {
	enabled = false
	// Set the classifier to fix gradle task validation confusion.
	archiveClassifier = "disabled"
}

test {
	useJUnitPlatform()
}

shadowJar {
	// Has stupid defaults, make our own
	enabled = false
}

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

// Renaming in the shadow jar task doesnt seem to work, so do it here
task getSat4jAbout(type: Copy) {
	dependsOn project.configurations.include
	duplicatesStrategy = DuplicatesStrategy.EXCLUDE

	from {
		configurations.include.collect {
			zipTree(it).matching {
				include 'about.html'
			}
		}
	}

	rename 'about.html', 'net/fabricmc/loader/impl/lib/sat4j/about-sat4j.html'

	into layout.buildDirectory.dir("sat4j")
}

task fatJar(type: ShadowJar, dependsOn: getSat4jAbout) {
	from sourceSets.main.output
	from project(":minecraft").sourceSets.main.output
	from getSat4jAbout.destinationDir
	from("LICENSE") {
		rename { "${it}_${project.archivesBaseName}"}
	}

	manifest {
		attributes (
			"Main-Class": "net.fabricmc.loader.launch.server.FabricServerLauncher"
		)
	}

	archiveClassifier = "fat"
	configurations = [project.configurations.include]

	relocate 'org.sat4j', 'net.fabricmc.loader.impl.lib.sat4j'

	exclude 'about.html'
	exclude 'sat4j.version'
	exclude 'META-INF/maven/org.ow2.sat4j/*/**'

	outputs.upToDateWhen { false }
}

File proguardFile = file("build/libs/fabric-loader-${version}.jar")

import proguard.gradle.ProGuardTask
task proguardJar(type: ProGuardTask, dependsOn: fatJar) {
	def classpath = project(":minecraft").configurations.compileClasspath

	inputs.files(fatJar, classpath)
	outputs.files(proguardFile)
	outputs.upToDateWhen { false }

	doFirst {
		classpath.resolve().forEach {
			libraryjars it
		}
	}

	libraryjars JavaVersion.current().java9Compatible ? "${System.getProperty('java.home')}/jmods" : "${System.getProperty('java.home')}/lib/rt.jar"

	injars fatJar.archiveFile
	outjars proguardFile
	configuration file("proguard.conf")
}
build.dependsOn proguardJar

jar {
	enabled = false
	// Set the classifier to fix gradle task validation confusion.
	archiveClassifier = "disabled"
}
tasks.withType(AbstractArchiveTask) {
	preserveFileTimestamps = false
	reproducibleFileOrder = true
}

sourcesJar {
	from sourceSets.main.allSource
	from project(":minecraft").sourceSets.main.allSource
}

// useful for creating test mod jar
task testJar(type: Jar) {
	archiveClassifier = "test"
	from sourceSets.test.output
}



task copyJson() {
	def inJson = file('src/main/resources/quilt_installer.json')
	//def inLwJson = file('src/main/resources/fabric-installer.launchwrapper.json')

	def outJson = file("build/libs/${archivesBaseName}-${version}.json")
	//def outLwJson = file("build/libs/${archivesBaseName}-${version}.launchwrapper.json")

	inputs.files (inJson, /*inLwJson*/)
	outputs.files(outJson, /*outLwJson*/)

	doLast {
		outJson.text = inJson.text
		//outLwJson.text = inLwJson.text
	}
}
tasks.build.dependsOn "copyJson"

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

	// Target JDK 8
	if (JavaVersion.current().isJava9Compatible()) {
		it.options.release.set(8)
	}
}

javadoc {
	options {
		if (file("README.html").exists()) {
			overview = "README.html"
		}

		source = "8"
		encoding = 'UTF-8'
		charSet = 'UTF-8'
		memberLevel = JavadocMemberLevel.PACKAGE
		links(
				'https://asm.ow2.io/javadoc/',
				'https://docs.oracle.com/javase/8/docs/api/',
				'https://logging.apache.org/log4j/2.x/log4j-api/apidocs/'
		)

		// Disable the crazy super-strict doclint tool in Java 8
		addStringOption('Xdoclint:none', '-quiet')
	}

	source sourceSets.main.allJava.srcDirs
	classpath = sourceSets.main.compileClasspath + sourceSets.main.output // compile impl stuff for dep as well
	include("**/api/**")
	// workaround as one of the api stuff use that package
	failOnError false
}

allprojects {

	license {
		header project.rootProject.file("codeformat/FABRIC-HEADER")
		include '**/*.java'

		// Exclude gson since it is google's code, we just modify and bundle it
		exclude '**/lib/gson/*.java'
	}
}

// Causes more trouble than its worth
tasks.withType(GenerateModuleMetadata) {
	enabled = false
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			// add all the jars that should be included when publishing to maven
			artifact(proguardFile) {
				builtBy proguardJar
			}
			artifact(sourcesJar)
			artifact javadocJar
			artifact(file('src/main/resources/quilt_installer.json')) {
				builtBy copyJson
			}
//			artifact(file('src/main/resources/fabric-installer.launchwrapper.json')) {
//				builtBy copyJson
//				classifier = "launchwrapper"
//			}
		}
	}

	repositories {
		if (ENV.MAVEN_URL) {
			maven {
				url ENV.MAVEN_URL
				credentials {
					username ENV.MAVEN_USERNAME
					password ENV.MAVEN_PASSWORD
				}
			}
		} else if (ENV.SNAPSHOTS_URL) {
			maven {
				url ENV.SNAPSHOTS_URL

				credentials {
					username ENV.SNAPSHOTS_USERNAME
					password ENV.SNAPSHOTS_PASSWORD
				}
			}
		} else {
			mavenLocal()
		}
	}
}

// Refresh meta after publish
tasks.register("refreshMeta", RefreshMetaTask)

class RefreshMetaTask extends DefaultTask {
	@TaskAction
	void doTask() {
		def ENV = System.getenv()

		if (ENV.META_UPDATE_URL) {
			logger.lifecycle("Refreshing meta")
			URL url = new URL(ENV.META_UPDATE_URL)

			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
			connection.requestMethod = "GET"

			try (InputStream _ = connection.inputStream) {
			}

			if (connection.responseCode != 200) {
				throw GradleException("Failed to refresh meta server")
			}

			logger.lifecycle("Meta refresh done")
		} else {
			logger.lifecycle("META_UPDATE_URL not specified, not refreshing meta")
		}
	}
}