build.gradle

import qsl.internal.Versions

plugins {
	id("maven-publish")
	id("org.jetbrains.gradle.plugin.idea-ext") version("1.1.6")
	id("qsl.common")
}
def ENV = System.getenv()
group = "org.quiltmc"
version = Versions.QSL_VERSION

// Takes "1.0.0-beta.1" and changes it to "1.0.0-beta.2", unless we are releasing.
// TODO: there is no way to semantically identify if a release is a snapshot or not right now
if (version.contains("beta") && !ENV.MAVEN_URL) {
	int beta = Integer.parseInt(version.substring(version.indexOf("beta.") + 5))
	version = version.replace(version.substring(version.indexOf("beta.")), "beta." + (beta + 1))
}

// Same thing, but with alphas
if (version.contains("alpha") && !ENV.MAVEN_URL) {
	int alpha = Integer.parseInt(version.substring(version.indexOf("alpha.") + 6))
	version = version.replace(version.substring(version.indexOf("alpha.")), "alpha." + (alpha + 1))
}

version = version + "+" + Versions.MINECRAFT_VERSION.version() + (System.getenv("SNAPSHOTS_URL") ? "-SNAPSHOT" : "")
println("QSL: " + version)

sourceSets {
	testmod {
		compileClasspath += main.compileClasspath
		runtimeClasspath += main.runtimeClasspath
	}
}

// The root project simply just publishes all artifacts.
// For that reason, do not generate a remapped jar.
//prepareRemapJar {
//	enabled = false
//}

remapJar {
	enabled = false
}

jar {
	enabled = false
}

task fatJavadoc(type: Javadoc) {
	group "documentation"

	options {
		source = String.valueOf(Versions.JAVA_VERSION)
		encoding = "UTF-8"
		charSet = "UTF-8"
		memberLevel = JavadocMemberLevel.PACKAGE
		links(
				"https://guava.dev/releases/31.1-jre/api/docs/",
				"https://asm.ow2.io/javadoc/",
				"https://docs.oracle.com/en/java/javase/17/docs/api/",
				"https://jenkins.liteloader.com/job/Mixin/javadoc/",
				// TODO: Fix maven javadocs
				// "https://maven.quiltmc.org/repository/release/org/quiltmc/quilt-mappings/${Versions.MINECRAFT_VERSION.version()}+build.${Versions.MAPPINGS_BUILD}/quilt-mappings-${Versions.MINECRAFT_VERSION.version()}+build.${Versions.MAPPINGS_BUILD}-javadoc.jar/"
		)

		// Disable the overzealous doclint tool in Java 8
		addStringOption("Xdoclint:none", "-quiet")
		tags(
				"author:a",
				'reason:m:"Reason:"'
		)
	}

	failOnError false

	exclude {
		it.file.absolutePath.contains("mixin") || it.file.absolutePath.contains("impl")
	}

	afterEvaluate {
		subprojects.stream()
			.filter { it.path.count(':') == 2 }
			.filter { it.name != "block_entity"}
			.each { subproject ->
			subproject.tasks.withType(Javadoc).each { javadocTask ->
				source += javadocTask.source
				classpath += javadocTask.classpath
				// TODO: find a proper fix for this
				// What does this do? Well, turns out transitive access wideners aren't applied properly,
				// which fails the fat javadoc task! Since Quilt Block Entity adds a transitive access widener to a private interface.
				// So what do we do? We simply removed the Vanilla JAR and hope that the correct transformed JAR shows up first.
				// The proper fix is to get the root project to generate a new MC JAR that contains all the transitive transformations of the modules
				// applied and pass that to the fat javadoc task instead.
//						.filter { !it.name.startsWith("minecraft") }
			}
		}

//		subprojects.stream()
//			.filter { it.path.count(':') == 2 }
//			.filter { it.name == "block_entity"}
//			.each { subproject ->
//				subproject.tasks.withType(Javadoc).each { javadocTask ->
//					source += javadocTask.source
//					classpath += javadocTask.classpath
//				}
//			}
	}
	destinationDir = file("${buildDir}/docs/fat-javadoc")
}


task fatJavadocJar(type: Jar) {
	group "build"

	archiveClassifier = "fat-javadoc"
	dependsOn fatJavadoc
	from fatJavadoc.destinationDir
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifact fatJavadocJar

			pom.withXml {
				def depsNode = asNode().appendNode("dependencies")

				rootProject.subprojects.stream().filter {
					it.path.count(':') == 1
				}.forEach {
					def depNode = depsNode.appendNode("dependency")
					depNode.appendNode("groupId", it.group)
					depNode.appendNode("artifactId", it.name)
					depNode.appendNode("version", it.version)
					depNode.appendNode("scope", "compile")
				}
			}
		}
	}
}

loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava)

// Because we rely on the results of our libraries, we use afterEvaluate to setup the sourcesets and testmod tasks.
afterEvaluate {
	// Add sourceSet dependencies on all libraries
	// Make this project include the compileClasspath and runtimeClasspath of the libraries.
	subprojects.stream().filter { it.path.count(":") == 1 }.each {
		project.sourceSets.main.compileClasspath += it.sourceSets.main.compileClasspath
		project.sourceSets.main.runtimeClasspath += it.sourceSets.main.runtimeClasspath
		project.sourceSets.testmod.compileClasspath += it.sourceSets.testmod.compileClasspath
		project.sourceSets.testmod.runtimeClasspath += it.sourceSets.testmod.runtimeClasspath
	}
}

loom {
	runs {
		testmodClient {
			client()
			configName = "Testmod Client"
			source(project.sourceSets.testmod)
		}

		testmodServer {
			server()
			configName = "Testmod Server"
			source(project.sourceSets.testmod)

			programArg("--nogui")
		}

		// Auto test server, a server is ran for a few seconds and testmods run to verify things such as mixin
		// application function properly.
		autoTestServer {
			inherit testmodServer
			configName = "Auto test server"
			property("quilt.auto_test")
		}

		// Game test server, a server that executes tests using Minecraft's test framework.
		gameTestServer {
			inherit testmodServer

			configName = "Game test server"
			property("quilt.game_test", "true")
			property("quilt.game_test.report_file", "${project.buildDir}/game_test/report.xml")
			runDir("build/game_test")
		}
	}
}

task runAutoAllTestServer {
	group "verification"
	description "Runs all the server-sided tests automatically.\nTypically ran by the CI server."
}

task runGameAllTestServer {
	group "verification"
	description "Runs all the server-sided game tests automatically.\nTypically ran by the CI server."
}

afterEvaluate {
	def generateQmjForIdea = tasks.create("generateQmjForIdea")
	project.subprojects.each {
		it.subprojects.each {
			generateQmjForIdea.dependsOn it.tasks.getByName("generateQmj")
		}
	}

	idea {
		project {
			settings {
				taskTriggers {
					afterSync generateQmjForIdea
				}
			}
		}
	}

	testmodRemapJar { tsk ->
		nestedJars.setFrom(Collections.emptySet())

		rootProject.subprojects.stream().filter {
			it.path.count(':') == 1
		}.forEach {
			tsk.nestedJars.from it.tasks.getByName("testmodRemapJar")
		}
	}

	tasks.runAutoAllTestServer.dependsOn tasks.runAutoTestServer
	tasks.runGameAllTestServer.dependsOn tasks.runGameTestServer
	tasks.test.dependsOn tasks.runGameAllTestServer
}

task checkVersion {
	doFirst {
		try {
			def xml = new URL("https://maven.quiltmc.org/repository/release/org/quiltmc/qsl/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!")
			}
		} catch (FileNotFoundException ignored) {
			// No existing version of library found
		}
	}
}

project.getTasksByName("checkLibVersion", true).each {
	checkVersion.dependsOn it
}

publish.dependsOn checkVersion