build.gradle

import net.fabricmc.loom.build.nesting.JarNester
import org.slf4j.LoggerFactory

buildscript {
	dependencies {
		classpath "org.kohsuke:github-api:${project.github_api}"
		classpath "com.guardsquare:proguard-gradle:${project.proguard_gradle}"
	}
}

plugins {
	id 'java'
	id 'java-library'
	id 'eclipse'
	id 'maven-publish'
	id 'org.quiltmc.gradle.licenser' version '2.0.1'
	id 'org.quiltmc.loom' version '1.3.3' apply false
	id 'com.github.johnrengelman.shadow' version '8.1.1'
}

java {
	toolchain {
		languageVersion.set(JavaLanguageVersion.of(8))
	}
	withJavadocJar()
	withSourcesJar()
}

archivesBaseName = "quilt-loader"
version = project.quilt_loader
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'
		}
		maven {
			name = 'Quilt'
			url = 'https://maven.quiltmc.org/repository/snapshot'
		}
		maven {
		  name = 'Unascribed'
		  url = 'https://repo.sleeping.town/'
		}
		mavenCentral() {
			content {
				excludeGroupByRegex "org.ow2.asm"
			}
		}
	}
}

sourceSets {
	main {
		java.srcDirs = ['src/main/java', 'src/fabric/api/java', 'src/fabric/impl/java', 'src/fabric/legacy/java']
	}
}

configurations {
	include
	development

	compileClasspath.extendsFrom localImplementation
	runtimeClasspath.extendsFrom localImplementation
	testImplementation.extendsFrom localImplementation
	localImplementation.extendsFrom include
}

dependencies {
	include project(path: ':dependencies', configuration: 'include')
	development project(path: ':dependencies', configuration: 'development')

	// also must update in minecraft AND minecraft test
	compileOnly "org.quiltmc.chasm:chasm:${project.quilt_chasm}"
	compileOnly "org.quiltmc.chasm:chassembly:${project.quilt_chasm}"

	testCompileOnly "org.jetbrains:annotations:${project.annotations}"

	// Unit testing
	testImplementation(platform("org.junit:junit-bom:${project.junit_bom}"))
	testImplementation("org.junit.jupiter:junit-jupiter")

	/*api*/ localImplementation project(':dependencies')
}

def javaComponent = components.java as AdhocComponentWithVariants
javaComponent.withVariantsFromConfiguration(configurations.shadowRuntimeElements) {
	skip()
}

test {
	useJUnitPlatform()
}

processResources {
	inputs.property "version", project.version
	inputs.property "tiny_mappings_parser", project.tiny_mappings_parser
	inputs.property "sponge_mixin", project.sponge_mixin
	inputs.property "tiny_remapper", project.tiny_remapper
	inputs.property "access_widener", project.access_widener
	inputs.property "quilt_json5", project.quilt_json5
	inputs.property "asm", project.asm
	inputs.property "asm_analysis", project.asm
	inputs.property "asm_commons", project.asm
	inputs.property "asm_tree", project.asm
	inputs.property "asm_util", project.asm
	inputs.property "quilt_config", project.quilt_config
	inputs.property "mixin_extras", project.mixin_extras

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

	filesMatching(["quilt_installer.json", "fabric-installer.launchwrapper.json"]) {
		expand(
			"tiny_mappings_parser": project.tiny_mappings_parser,
			"sponge_mixin": project.sponge_mixin,
			"tiny_remapper": project.tiny_remapper,
			"access_widener": project.access_widener,
			"quilt_json5": project.quilt_json5,
			"asm": project.asm,
			"asm_analysis": project.asm,
			"asm_commons": project.asm,
			"asm_tree": project.asm,
			"asm_util": project.asm,
			"quilt_config": project.quilt_config,
			"mixin_extras": project.mixin_extras,
		)
	}
}

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', 'org/quiltmc/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",
			"Fabric-Loom-Remap": "false",
			"Automatic-Module-Name": "org.quiltmc.loader"
		)
	}

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

	relocate 'org.quiltmc.loader.util.sat4j', 'org.quiltmc.loader.impl.lib.sat4j'
	relocate 'org.quiltmc.parsers', 'org.quiltmc.loader.impl.lib.parsers'
	relocate 'com.electronwill', 'org.quiltmc.loader.impl.lib.electronwill'
	relocate 'com.unascribed.flexver', 'org.quiltmc.loader.impl.lib.flexver'
	//relocate 'org.quiltmc.json5', 'org.quiltmc.loader.impl.lib.json5'
	exclude 'about.html'
	exclude 'sat4j.version'
	exclude 'META-INF/maven/org.ow2.sat4j/*/**'

	doLast {
		JarNester.nestJars(project.configurations.development.files, archiveFile.get().asFile, LoggerFactory.getLogger("JiJ"))
	}

	outputs.upToDateWhen { false }
}

File proguardFile = file("build/libs/quilt-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('build/resources/main/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.copyJson.dependsOn "processResources"
tasks.build.dependsOn "copyJson"

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

javadoc {
	javadocTool.set javaToolchains.javadocToolFor {
		languageVersion = JavaLanguageVersion.of(17)
	}

	options {
		if (file("README.html").exists()) {
			overview = "README.html"
		}
		destinationDir = file("${buildDir}/docs/${project.version}")
		source = "8"
		encoding = 'UTF-8'
		charSet = 'UTF-8'
		memberLevel = JavadocMemberLevel.PACKAGE
		splitIndex true
		links(
				'https://asm.ow2.io/javadoc/',
				'https://docs.oracle.com/javase/8/docs/api/',
				'https://logging.apache.org/log4j/2.x/log4j-api/apidocs/'
		)

		addBooleanOption 'Xdoclint:html', true
		addBooleanOption 'Xdoclint:syntax', true
		addBooleanOption 'Xdoclint:reference', true
		addBooleanOption 'Xdoclint:accessibility', true
		addStringOption("-notimestamp")
		addStringOption("Xdoclint:none")
		addStringOption("-quiet")
		addFileOption "-add-stylesheet", file("src/main/javadoc/style.css")
	}

	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 {
		rule project.rootProject.file("codeformat/FABRIC_MODIFIED_HEADER")
		rule project.rootProject.file("codeformat/HEADER")
		include '**/*.java'

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

[configurations.runtimeElements, configurations.apiElements].each { configuration ->
	configuration.outgoing.artifacts.clear()
	artifacts {
		add(configuration.name, proguardFile) {
			builtBy proguardJar
		}
	}
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			// add all the jars that should be included when publishing to maven
			from components.java
			artifact(file('build/resources/main/quilt_installer.json')) {
				builtBy processResources
				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()
		}
	}
}