build.gradle

import org.gradle.api.internal.file.FileOperations
import org.quiltmc.launchermeta.version.v1.Library
import org.quiltmc.launchermeta.version.v1.Version
import quilt.internal.constants.Classifiers
import quilt.internal.constants.Constants
import quilt.internal.task.setup.DownloadWantedVersionManifestTask
import quilt.internal.util.serializable.VersionParser

import java.util.stream.Collectors
import java.util.stream.Stream

import static org.gradle.api.plugins.JavaPlugin.JAVADOC_TASK_NAME
import static quilt.internal.task.setup.DownloadWantedVersionManifestTask.DOWNLOAD_WANTED_VERSION_MANIFEST_TASK_NAME

plugins {
	id 'maven-publish'
	id 'quilt-mappings'
	alias libs.plugins.licenser
}

// put these in fields so we don't have to worry about inadvertently accessing the project during task execution
final FileOperations FILE_OPERATIONS = project.fileOperations
final ProviderFactory PROVIDERS = project.providers
final ObjectFactory OBJECTS = project.objects

final USE_SNAPSHOT_HASHES = false

final ENV = System.getenv()

final MINECRAFT_VERSION = libs.versions.minecraft.get()

version = "${MINECRAFT_VERSION}+build.${ENV.getOrDefault('BUILD_NUMBER', 'local')}"

if (ENV.BRANCH_NAME) {
	def branch = ENV.BRANCH_NAME.substring(ENV.BRANCH_NAME.lastIndexOf('/') + 1)
	if (MINECRAFT_VERSION != branch) {
		throw new IllegalStateException("Branch name (${branch}) does not match the mc version (${MINECRAFT_VERSION})")
	}
}

sourceSets {
	// for constantsJar and sourcesJar input
	constants
	// package info files, for javadoc input
	packageDocs
	// for javadoc input
	doclet
}

repositories {
	ivy {
		// hack to download file from url
		url = 'https://raw.githubusercontent.com'

		patternLayout {
			artifact '/[organisation]/[module]/[revision]/allowed_english_words.txt'
		}

		metadataSources { artifact() }
	}

	maven {
		name 'Mojang'
		url 'https://libraries.minecraft.net/'
	}
	mavenCentral()
	maven {
		name 'Quilt Repository'
		url 'https://maven.quiltmc.org/repository/release'
	}
	maven {
		name 'Fabric Repository'
		url 'https://maven.fabricmc.net'
	}
	maven {
		name 'Quilt Snapshot Repository'
		url 'https://maven.quiltmc.org/repository/snapshot'
	}
	mavenLocal()
}

configurations {
	dictionary
}

dependencies {
	dictionary libs.dictionary

	javadocClasspath(libs.quilt.loader)
	javadocClasspath(libs.jetbrains.annotations)
	// for some other jsr annotations
	javadocClasspath(libs.jsr305)
	hashed "org.quiltmc:hashed:${MINECRAFT_VERSION}${USE_SNAPSHOT_HASHES ? "-SNAPSHOT" : ""}"
	intermediary "net.fabricmc:intermediary:${MINECRAFT_VERSION}:v2"
}

quiltMappings {
	minecraftVersion = MINECRAFT_VERSION

	mappingsVersion = project.version.toString()

	mappingsDir = file('mappings/')

	enigmaProfileConfig = file('enigma/enigma_profile.json')

	unpickMeta = file('unpick/unpick.json')
}

tasks.combineUnpickDefinitions {
	// add project's static unpick definitions
	unpickDefinitions.from 'unpick/definitions/'
}

tasks.mappingLint {
	dictionaryFile = configurations.dictionary.singleFile
}

tasks.sourcesJar {
	sources.from sourceSets.constants.allSource
}

tasks.constantsJar {
	constants.from sourceSets.constants.output
}

// Only build jars for package infos if we need to actually expose stuff like annotation in the future.

tasks.build.dependsOn constantsJar, generatePackageInfoMappings,
	compressTiny, tinyJar, v2UnmergedMappingsJar, v2MergedMappingsJar

// configure lazily because we get buildDirectory
tasks.named(JAVADOC_TASK_NAME, Javadoc) {
	// Needed for javadoc to find the doclet classes.
	dependsOn docletClasses

	final versionParser = tasks
		.named(DOWNLOAD_WANTED_VERSION_MANIFEST_TASK_NAME, DownloadWantedVersionManifestTask)
		.flatMap(DownloadWantedVersionManifestTask::provideVersionParser)

	final MapProperty<String, String> minecraftLibVersionsByModule = OBJECTS.mapProperty(String, String)
	minecraftLibVersionsByModule.set(versionParser
		.map(VersionParser::get)
		.map(Version::getLibraries)
		.map {
			it.stream()
				.map(Library::getName)
				.flatMap { moduleName ->
					final delim = ':'
					final moduleParts = moduleName.split(delim)

					if (moduleParts.length == 3 || moduleParts.length == 4) {
						return Stream.of(Map.entry(moduleParts[0] + delim + moduleParts[1], moduleParts[2]))
					} else {
						logger.error("Unrecognized module format: ${moduleName}")

						return Stream.empty()
					}
				}
				.distinct()
				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
		}
	)

	final Closure<Provider<String>> provideModuleVersion = { String module ->
		final versionProperty = OBJECTS.property(String)
			.convention(PROVIDERS.provider { throw new GradleException("Missing version for module: ${module}") })

		versionProperty.set(minecraftLibVersionsByModule.getting(module))

		return versionProperty
	}

	final Closure<Provider<String>> formatVersionedUrl = { String baseUrl, Provider<String> version ->
		version.map {"${baseUrl}/${it}/" as String }
	}

	final gsonUrl = formatVersionedUrl(
		'https://javadoc.io/doc/com.google.code.gson/gson',
		provideModuleVersion('com.google.code.gson:gson')
	)

	// use hardcoded version because minecraft depends on a version that doesn't have javadocs
	final nettyUrl = formatVersionedUrl(
		'https://javadoc.io/doc/io.netty/netty-all',
		libs.versions.netty.with.javadoc
	)

	final commonsCompressUrl = formatVersionedUrl(
		'https://javadoc.io/doc/org.apache.commons/commons-compress',
		provideModuleVersion('org.apache.commons:commons-compress')
	)

	final commonsCodecUrl = formatVersionedUrl(
		'https://javadoc.io/doc/commons-codec/commons-codec',
		provideModuleVersion('commons-codec:commons-codec')
	)

	[
		gsonUrl: gsonUrl,
		nettyUrl: nettyUrl,
		commonsCompressUrl: commonsCompressUrl,
		commonsCodecUrl: commonsCodecUrl
	].each(inputs::property)

	destinationDir = layout.buildDirectory.get().dir('docs').dir(project.version.toString()).getAsFile()
	final docletResources = sourceSets.doclet.resources.asFileTree

	// Failing on error is important to ensure that a Javadoc jar is available.
	failOnError = true
	maxMemory = '2G'

	final debug = providers.gradleProperty('quilt.mappings.debug.javadoc')
		.map(Boolean::parseBoolean)
		.getOrElse(false)

	verbose = debug

	options {
		if (debug) {
			verbose()
		}

		source = '21'
		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 'quilt.internal.taglet.MappingTaglet'
		// taglet path, header, extra stylesheet settings deferred
		it.use()

		addBooleanOption '-allow-script-in-comments', true
		// https://docs.oracle.com/en/java/javase/21/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
		addStringOption '-notimestamp'
	}

	source sourceSets.constants.allJava + sourceSets.packageDocs.allJava

	doFirst {
		// lazy setting
		options {
			links(
				"https://javadoc.io/doc/com.google.guava/guava/${libs.versions.guava.get()}/",
				gsonUrl.get(),
				"https://javadoc.io/doc/org.jetbrains/annotations/${libs.versions.jetbrains.annotations.get()}/",
				"https://javadoc.io/doc/com.google.code.findbugs/jsr305/${libs.versions.jsr305.get()}/",
				commonsCompressUrl.get(),
				nettyUrl.get(),
				'https://javadoc.lwjgl.org/',
				'https://logging.apache.org/log4j/2.x/javadoc/log4j-api/',
				'https://fastutil.di.unimi.it/docs/',
				'https://commons.apache.org/proper/commons-logging/javadocs/api-release/',
				'https://commons.apache.org/proper/commons-lang/javadocs/api-release/',
				'https://commons.apache.org/proper/commons-io/apidocs/',
				commonsCodecUrl.get(),
				"https://javadoc.quiltmc.org/quilt-loader/${libs.versions.quilt.loader.get()}/",
				"https://docs.oracle.com/en/java/javase/${project.java}/docs/api/"
			)

			tagletPath sourceSets.doclet.output.classesDirs.files.toList()
			header docletResources.filter { it.name == 'javadoc_header.txt' }.singleFile.text.trim()
			addFileOption '-add-stylesheet', docletResources.filter { it.name == 'style.css' }.singleFile
		}
	}

	doLast {
		FILE_OPERATIONS.copy {
			it.from docletResources
			it.include 'copy_on_click.js'
			it.into destinationDir
		}
	}
}

java {
	sourceCompatibility = JavaVersion.VERSION_21
	targetCompatibility = JavaVersion.VERSION_21
}

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

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

publishing {
	publications {
		maven(MavenPublication) {
			groupId 'org.quiltmc'
			artifactId Constants.MAPPINGS_NAME
			version project.version

			// quilt-mappings-<version>-tiny.gz
			compressTiny.artifact maven
			// quilt-mappings-<version>.jar
			artifact tinyJar
			// quilt-mappings-<version>-v2.jar
			artifact v2UnmergedMappingsJar
			// quilt-mappings-<version>-mergedv2.jar
			artifact v2MergedMappingsJar
			// quilt-mappings-<version>-constants.jar
			artifact constantsJar

			// quilt-mappings-<version>-sources.jar
			artifact sourcesJar
			// quilt-mappings-<version>-javadoc.jar
			artifact javadocJar

			// See below the publishing block for intermediary artifact publishing
		}
	}

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

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

tasks.withType(AbstractPublishToMaven).configureEach {
	// Won't run if mapIntermediary.intermediaryFile is absent
	dependsOn buildIntermediary

	doFirst {
		if (mapIntermediary.intermediaryFile.isPresent()) {
			final addArtifact = { Task task, String artifactClassifier ->
				if (publication.artifacts.findAll { it.classifier == artifactClassifier }.isEmpty()) {
					publication.artifact(task) {
						classifier artifactClassifier
					}
				}
			}

			// quilt-mappings-<version>-intermediary-v2.jar
			addArtifact(intermediaryV2MappingsJar, Classifiers.INTERMEDIARY_V2)
			// quilt-mappings-<version>-intermediary-mergedv2.jar
			addArtifact(intermediaryV2MergedMappingsJar, Classifiers.INTERMEDIARY_V2_MERGED)
		}
	}
}