build.gradle

plugins {
	id 'java-library'
	id 'eclipse'
	id 'idea'
	id 'maven-publish'
	id 'fabric-loom' version '1.6-SNAPSHOT' apply false
	id 'ploceus' version '1.6-SNAPSHOT' apply false
}

setUpJar(project)

publishing {
	publications {
		mavenJava(MavenPublication) {
			pom.withXml {
				asNode().appendNode('dependencies')
			}
		}
	}
	repositories {
		def ENV = System.getenv()

		if (ENV.MAVEN_URL) {
			maven {
				url ENV.MAVEN_URL

				credentials {
					username ENV.MAVEN_USERNAME
					password ENV.MAVEN_PASSWORD
				}
			}
		} else {
			mavenLocal()
		}
	}
}

def setUpJar(project) {
	project.apply plugin: 'java-library'
	project.apply plugin: 'eclipse'
	project.apply plugin: 'idea'
	project.apply plugin: 'fabric-loom'
	project.apply plugin: 'ploceus'

	project.base {
		def archives_name = "${project.rootProject.root_archives_base_name}"
		if (!"*".equals(project.environment)) {
			archives_name += "-${project.environment}"
		}
		archivesName = archives_name
	}
	project.version = "${project.rootProject.root_version}"
	project.group = "${project.rootProject.root_maven_group}"

	project.repositories {
		maven {
			name = 'Quilt'
			url = 'https://maven.quiltmc.org/repository/release'
		}
	}

	project.dependencies {
		// dummy mc dependency to keep loom happy
		minecraft "com.mojang:minecraft:${project.rootProject.minecraft_version}"
		mappings project.ploceus.featherMappings(project.rootProject.feather_build)
		modImplementation "net.fabricmc:fabric-loader:${project.rootProject.loader_version}"
	}

	project.sourceSets {
		main {
			resources {
				if (!"*".equals(project.environment)) {
					srcDirs += project.rootProject.sourceSets.main.resources.srcDirs
				}
			}
		}
	}

	project.processResources {
		filesMatching('fabric.mod.json') {
			expand project.properties
		}
	}

	project.jar {
		from(project.rootProject.file('LICENSE')) {
			rename { "${it}_${project.base.archivesName.get()}" }
		}
	}
}

def getJar(String environment) {
	if ("client".equals(environment)) {
		return project(':client')
	}
	if ("server".equals(environment)) {
		return project(':server')
	}
	if ("*".equals(environment)) {
		return project(':')
	}
	throw new RuntimeException("unknown environment ${environment}")
}

def addPomDependency(project) {
	project.rootProject.publishing {
		publications {
			mavenJava(MavenPublication) {
				pom.withXml {
					def depsNode = asNode().get("dependencies")[0]
					def depNode = depsNode.appendNode("dependency")

					depNode.appendNode("groupId", project.group)
					depNode.appendNode("artifactId", project.name)
					depNode.appendNode("version", project.version)
					depNode.appendNode("scope", "compile")
				}
			}
		}
	}
}

def setUpJavadoc(project) {
	project.javadoc {
		options {
			source = "8"
			encoding = "UTF-8"
			charSet = "UTF-8"
			memberLevel = JavadocMemberLevel.PACKAGE
			// Disable the crazy super-strict doclint tool in Java 8
			addStringOption("Xdoclint:none", "-quiet")

			tags(
				'apiNote:a:API Note:',
				'implSpec:a:Implementation Requirements:',
				'implNote:a:Implementation Note:'
			)
		}

		failOnError true

		include("**/api/**")
		source(project.sourceSets.main.allJava)
	}
}

def setUpLibrary(project) {
	project.apply plugin: 'java-library'
	project.apply plugin: 'eclipse'
	project.apply plugin: 'idea'

	project.base {
		archivesName = "${project.rootProject.archives_base_name}-${project.archives_base_name}"
	}
	project.version = "${project.version}"
	project.group = "${project.rootProject.root_maven_group}.${project.rootProject.maven_group}"

	project.repositories {
		// needed for loader in subprojects without a mc dep
		// since in those subprojects loom is not applied
		maven {
			name = 'Fabric'
			url = 'https://maven.fabricmc.net/'
		}
		maven {
			name = 'Quilt'
			url = 'https://maven.quiltmc.org/repository/release'
		}
		mavenCentral()
	}

	project.dependencies {
		implementation "net.fabricmc:fabric-loader:${project.rootProject.loader_version}"

		implementation "org.apache.logging.log4j:log4j-api:${project.rootProject.log4j_version}"
		implementation "org.apache.logging.log4j:log4j-core:${project.rootProject.log4j_version}"

		implementation project.project(':libraries:core')
	}

	addPomDependency(project)
	setUpJavadoc(project)
}

def setUpModule(project, String... dependencies) {
	// normally modules have a 'root' and subprojects
	// for different mc version ranges
	// the Core API is the only exception to this
	def isCore = (project == project.project(':libraries:core'))

	project.apply plugin: 'java-library'
	project.apply plugin: 'eclipse'
	project.apply plugin: 'idea'
	project.apply plugin: 'maven-publish'
	project.apply plugin: 'fabric-loom'
	project.apply plugin: 'ploceus'

	if (isCore) {
		project.base {
			archivesName = "${project.rootProject.archives_base_name}-${project.archives_base_name}"
		}
		project.version = "${project.version}"
	} else {
		project.base {
			archivesName = "${project.rootProject.archives_base_name}-${project.parent.archives_base_name}"
		}
		def mc_version_range = "mc${project.min_mc_version}-mc${project.max_mc_version}"
		if ("*".equals(project.environment)) {
			project.version = "${project.parent.version}+${mc_version_range}"
		} else {
			project.version = "${project.parent.version}+${project.environment}-${mc_version_range}"
		}
	}
	project.group = "${project.rootProject.root_maven_group}.${project.rootProject.maven_group}"

	project.loom {
		if ("client".equals(project.environment)) {
			clientOnlyMinecraftJar()
		}
		if ("server".equals(project.environment)) {
			serverOnlyMinecraftJar()
		}
	}
	project.ploceus {
		if ("client".equals(project.environment)) {
			clientOnlyMappings()
		}
		if ("server".equals(project.environment)) {
			serverOnlyMappings()
		}
	}

	def libraries = getLibraryDependencies(project, dependencies)
	def modules = getModuleDependencies(project, dependencies)

	project.repositories {
	}

	project.dependencies {
		minecraft "com.mojang:minecraft:${project.max_mc_version}"
		mappings project.ploceus.featherMappings(project.feather_build)
		if (project.hasProperty('nests_build')) {
			nests project.ploceus.nests(project.nests_build)
		}
		modImplementation "net.fabricmc:fabric-loader:${project.rootProject.loader_version}"

		// log4j is only needed in 1.6.4 and below, but checking the mc version
		// is hard if you don't have normalized version ids, so as a workaround
		// we add log4j if the project uses nests (which coincides with 1.8.2-pre4
		// and below)
		if (isCore || project.hasProperty('nests_build')) {
			implementation "org.apache.logging.log4j:log4j-api:${project.rootProject.log4j_version}"
			implementation "org.apache.logging.log4j:log4j-core:${project.rootProject.log4j_version}"
		}

		implementation "org.quiltmc.parsers:json:${project.rootProject.quilt_parsers_version}"
		if (isCore) {
			include "org.quiltmc.parsers:json:${project.rootProject.quilt_parsers_version}"
		}

		libraries.each { library ->
			compileOnly library
		}
		modules.each { module ->
			compileOnly module
		}
	}

	if (isCore) {
		getJar('*').dependencies {
			include project
		}
		getJar('client').dependencies {
			include project
		}
		getJar('server').dependencies {
			include project
		}
	} else {
		getJar(project.environment).dependencies {
			include project
		}
	}

	project.sourceSets {
		main {
			java {
				if (!isCore) {
					srcDirs += project.parent.sourceSets.main.java.srcDirs
				}
			}
			resources {
				if (!isCore) {
					srcDirs += project.parent.sourceSets.main.resources.srcDirs
				}
			}
		}
	}

	project.processResources {
		filesMatching('fabric.mod.json') {
			expand project.properties
		}
	}

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

	project.java {
		// Still required by IDEs such as Eclipse and Visual Studio Code
		sourceCompatibility = JavaVersion.VERSION_1_8
		targetCompatibility = JavaVersion.VERSION_1_8

		// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task if it is present.
		// If you remove this line, sources will not be generated.
		withSourcesJar()

		// If this mod is going to be a library, then it should also generate Javadocs in order to aid with development.
		// Uncomment this line to generate them.
		withJavadocJar()
	}

	project.jar {
		from(project.rootProject.file('LICENSE')) {
			rename { "${it}_${project.base.archivesName.get()}" }
		}
	}

	project.publishing {
		publications {
			mavenJava(MavenPublication) {
				if (!isCore) {
					artifactId project.parent.name
				}

				from project.components.java
			}
		}
		repositories {
			def ENV = System.getenv()

			if (ENV.MAVEN_URL && shouldPublish(project, ENV.MAVEN_URL)) {
				maven {
					url ENV.MAVEN_URL

					credentials {
						username ENV.MAVEN_USERNAME
						password ENV.MAVEN_PASSWORD
					}
				}
			} else {
				mavenLocal()
			}
		}
	}

	if (isCore) {
		addPomDependency(project)
	}

	setUpJavadoc(project)
}

def getLibraryDependencies(project, String... moduleNames) {
	def libraries = new ArrayList<>()

	if (project != project.project(':libraries:core')) {
		libraries.add(project.parent)
	}

	for (moduleName : moduleNames) {
		def i = moduleName.indexOf('-mc')
		if (!"*".equals(project.environment)) {
			i -= "-${project.environment}".length()
		}
		def libraryName = moduleName.substring(0, i)

		libraries.add(project.project(":libraries:${libraryName}"))
	}

	return libraries
}

def getModuleDependencies(project, String... moduleNames) {
	def modules = new ArrayList<>()

	if (project != project.project(':libraries:core')) {
		modules.add(project.project(':libraries:core'))
	}

	for (moduleName : moduleNames) {
		def i = moduleName.indexOf('-mc')
		if (!"*".equals(project.environment)) {
			i -= "-${project.environment}".length()
		}
		def libraryName = moduleName.substring(0, i)

		modules.add(project.project(":libraries:${libraryName}:${moduleName}"))
	}

	return modules
}

def shouldPublish(project, mavenUrl) {
	def groupId = project.publishing.publications.mavenJava.groupId
	def artifactId = project.publishing.publications.mavenJava.artifactId
	def version = project.publishing.publications.mavenJava.version

	def exists = false

	try {
		def xml = new URL("${mavenUrl}/${groupId.replace('.', '/')}/${artifactId}/maven-metadata.xml").text
		def metadata = new XmlSlurper().parseText(xml)

		exists = metadata.versioning.versions.version.stream().filter({
			return it == version
		}).findFirst().isPresent()
	} catch (FileNotFoundException ignored) {
		// only happens if no publications exist yet
	}

	return !exists
}

allprojects {
	tasks.withType(GenerateModuleMetadata) {
		enabled = false
	}

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

	java {
		// Still required by IDEs such as Eclipse and Visual Studio Code
		sourceCompatibility = JavaVersion.VERSION_1_8
		targetCompatibility = JavaVersion.VERSION_1_8
	}
}