buildscript { dependencies { classpath 'org.kohsuke:github-api:1.135' } } plugins { id "java-library" id "eclipse" id "idea" id "maven-publish" id 'jacoco' id "fabric-loom" version "1.1.8" apply false id "com.diffplug.spotless" version "6.11.0" id "org.ajoberstar.grgit" version "3.1.0" id "com.matthewprenger.cursegradle" version "1.4.0" id "com.modrinth.minotaur" version "2.4.3" id "me.modmuss50.remotesign" version "0.4.0" apply false } def ENV = System.getenv() def signingEnabled = ENV.SIGNING_SERVER version = project.version + "+" + (ENV.GITHUB_RUN_NUMBER ? "" : "local-") + getBranch() logger.lifecycle("Building Fabric: " + version) import org.apache.commons.codec.digest.DigestUtils def getSubprojectVersion(project) { // Get the version from the gradle.properties file def version = project.properties["${project.name}-version"] if (!version) { throw new NullPointerException("Could not find version for " + project.name) } if (grgit == null) { return version + "+nogit" } def latestCommits = grgit.log(paths: [project.name], maxCommits: 1) if (latestCommits.isEmpty()) { return version + "+uncommited" } return version + "+" + latestCommits.get(0).id.substring(0, 8) + DigestUtils.sha256Hex(project.rootProject.minecraft_version).substring(0, 2) } def getBranch() { def ENV = System.getenv() if (ENV.GITHUB_REF) { def branch = ENV.GITHUB_REF return branch.substring(branch.lastIndexOf("/") + 1) } if (grgit == null) { return "unknown" } def branch = grgit.branch.current().name return branch.substring(branch.lastIndexOf("/") + 1) } def moduleDependencies(project, List depNames) { def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'namedElements') } def clientOutputs = depNames.iterator().collect { findProject(":$it").sourceSets.client.output } project.dependencies { deps.each { api it } clientOutputs.each { clientImplementation it } } // As we manually handle the maven artifacts, we need to also manually specify the deps. project.publishing { publications { mavenJava(MavenPublication) { pom.withXml { def depsNode = asNode().appendNode("dependencies") deps.each { def depNode = depsNode.appendNode("dependency") depNode.appendNode("groupId", it.group) depNode.appendNode("artifactId", it.name) depNode.appendNode("version", it.version) depNode.appendNode("scope", "compile") } } } } } } def testDependencies(project, List depNames) { def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'namedElements') } def clientOutputs = depNames.iterator().collect { findProject(":$it").sourceSets.client.output } project.dependencies { deps.each { testmodImplementation it } clientOutputs.each { testmodImplementation it } } } allprojects { group = "net.fabricmc.fabric-api" apply plugin: "maven-publish" apply plugin: "me.modmuss50.remotesign" tasks.withType(GenerateModuleMetadata) { enabled = false } if (signingEnabled) { remoteSign { requestUrl = ENV.SIGNING_SERVER pgpAuthKey = ENV.SIGNING_PGP_KEY jarAuthKey = ENV.SIGNING_JAR_KEY afterEvaluate { // PGP sign all maven publications. sign publishing.publications.mavenJava } } } publishing { setupRepositories(repositories) } if (it.name == "deprecated") return apply plugin: "java-library" apply plugin: "checkstyle" apply plugin: "fabric-loom" apply plugin: "com.diffplug.spotless" tasks.withType(JavaCompile).configureEach { it.options.release = 17 } java { // Must be added before the split source sets are setup. withSourcesJar() } loom { splitEnvironmentSourceSets() } sourceSets { testmod { compileClasspath += main.compileClasspath runtimeClasspath += main.runtimeClasspath compileClasspath += client.compileClasspath runtimeClasspath += client.runtimeClasspath } } loom { runtimeOnlyLog4j = true runs { testmodClient { client() ideConfigGenerated project.rootProject == project name = "Testmod Client" source sourceSets.testmod } testmodServer { server() ideConfigGenerated project.rootProject == project name = "Testmod Server" source sourceSets.testmod } } } allprojects.each { p -> if (project.name == "deprecated") return loom.mods.register(p.name) { sourceSet p.sourceSets.main sourceSet p.sourceSets.client } loom.mods.register(p.name + "-testmod") { sourceSet p.sourceSets.testmod } } dependencies { minecraft "com.mojang:minecraft:$rootProject.minecraft_version" mappings "net.fabricmc:yarn:${rootProject.minecraft_version}${project.yarn_version}:v2" modApi "net.fabricmc:fabric-loader:${project.loader_version}" testmodImplementation sourceSets.main.output testmodImplementation sourceSets.client.output } tasks.withType(ProcessResources).configureEach { inputs.property "version", project.version filesMatching("fabric.mod.json") { expand "version": project.version } } spotless { java { licenseHeaderFile(rootProject.file("HEADER")) } } checkstyle { configFile = rootProject.file("checkstyle.xml") toolVersion = "10.3.3" } tasks.withType(AbstractArchiveTask) { preserveFileTimestamps = false reproducibleFileOrder = true } if (signingEnabled) { remoteSign { sign remapJar } } // Run this task after updating minecraft to regenerate any required resources task generateResources { group = "fabric" } task testmodJar(type: Jar) { from sourceSets.testmod.output destinationDirectory = new File(project.buildDir, "devlibs") archiveClassifier = "testmod" } [jar, sourcesJar].each { it.from(rootProject.file("LICENSE")) { rename { "${it}-${project.archivesBaseName}"} } } if (file("src/client").exists() && !file("src/main").exists()) { remapJar { additionalClientOnlyEntries.add("LICENSE-${project.archivesBaseName}") } remapSourcesJar { additionalClientOnlyEntries.add("LICENSE-${project.archivesBaseName}") } } task remapTestmodJar(type: net.fabricmc.loom.task.RemapJarTask, dependsOn: testmodJar) { input = testmodJar.archiveFile archiveClassifier = "testmod" addNestedDependencies = false } build.dependsOn remapTestmodJar task validateMixinNames(type: net.fabricmc.loom.task.ValidateMixinNameTask) { source(sourceSets.main.output) source(sourceSets.client.output) source(sourceSets.testmod.output) } // Apply to each valid subproject. apply from: rootProject.file('gradle/package-info.gradle') apply from: rootProject.file('gradle/validate-annotations.gradle') } remapTestmodJar { def testModJarTasks = [] subprojects { if (it.name == "deprecated" || !it.file("src/testmod").exists()) return testModJarTasks += it.tasks.remapTestmodJar } nestedJars.setFrom(testModJarTasks) addNestedDependencies = true } // Apply auxiliary buildscripts to submodules // This must be done after all plugins are applied to subprojects apply from: "gradle/module-validation.gradle" apply from: "gradle/module-versioning.gradle" loom { // Required as the item-group API uses access widened classes in its API, without this the javadoc generation fails. accessWidenerPath = file("fabric-item-group-api-v1/src/main/resources/fabric-item-group-api-v1.accesswidener") } javadoc { options { source = "17" encoding = "UTF-8" charSet = "UTF-8" memberLevel = JavadocMemberLevel.PACKAGE links( "https://maven.fabricmc.net/docs/yarn-${rootProject.minecraft_version}${project.yarn_version}/" ) // Disable the crazy super-strict doclint tool in Java 8 addStringOption("Xdoclint:none", "-quiet") } allprojects.each { if (it.name == "deprecated") return source(it.sourceSets.main.allJava) source(it.sourceSets.client.allJava) } classpath = files(sourceSets.main.compileClasspath, sourceSets.client.compileClasspath) include("**/api/**") failOnError true } task javadocJar(type: Jar) { dependsOn javadoc from javadoc.destinationDir //Set as `fatjavadoc` to prevent an ide form trying to use this javadoc, over using the modules javadoc archiveClassifier = "fatjavadoc" } build.dependsOn javadocJar loom { runs { gametest { inherit testmodServer name "Game Test" // Enable the gametest runner vmArg "-Dfabric-api.gametest" vmArg "-Dfabric-api.gametest.report-file=${project.buildDir}/junit.xml" runDir "build/gametest" } autoTestServer { inherit testmodServer name "Auto Test Server" vmArg "-Dfabric.autoTest" } autoTestClient { inherit testmodClient name "Auto Test Client" vmArg "-Dfabric.autoTest" } // Create duplicate tasks for this, as jacoco slows things down a bit gametestCoverage { inherit gametest name "Game Test Coverage" ideConfigGenerated = false } autoTestClientCoverage { inherit autoTestClient name "Auto Test Client Coverage" ideConfigGenerated = false } } } test.dependsOn runGametest def coverageTasks = [runGametestCoverage, runAutoTestClientCoverage] jacoco { coverageTasks.forEach { applyTo it } } task coverage(type: JacocoReport, dependsOn: coverageTasks) { coverageTasks.forEach { executionData it } // Add all source as input allprojects { p -> if (p.path.startsWith(":deprecated")) return sourceSets p.sourceSets.main, p.sourceSets.client, p.sourceSets.testmod } // Exclude mixins afterEvaluate { classDirectories.setFrom(files(classDirectories.files.collect { fileTree(dir: it, exclude: '**/mixin/**') })) } } configurations { productionRuntime { extendsFrom configurations.minecraftLibraries extendsFrom configurations.loaderLibraries extendsFrom configurations.minecraftRuntimeOnlyLibraries } productionRuntimeServer } dependencies { productionRuntime "net.fabricmc:fabric-loader:${project.loader_version}" productionRuntime "net.fabricmc:intermediary:${project.minecraft_version}" productionRuntimeServer "net.fabricmc:fabric-installer:${project.installer_version}:server" } import net.fabricmc.loom.util.OperatingSystem // This is very far beyond loom's API if you copy this, you're on your own. task runProductionAutoTestClient(type: JavaExec, dependsOn: [remapJar, remapTestmodJar]) { classpath.from configurations.productionRuntime mainClass = "net.fabricmc.loader.impl.launch.knot.KnotClient" workingDir = file("run") afterEvaluate { dependsOn downloadAssets } doFirst { classpath.from loom.minecraftProvider.minecraftClientJar workingDir.mkdirs() args( "--assetIndex", loom.minecraftProvider.versionInfo.assetIndex().fabricId(loom.minecraftProvider.minecraftVersion()), "--assetsDir", new File(loom.files.userCache, "assets").absolutePath, "--gameDir", workingDir.absolutePath ) if (OperatingSystem.CURRENT_OS == OperatingSystem.MAC_OS) { jvmArgs( "-XstartOnFirstThread" ) } jvmArgs( "-Dfabric.addMods=${remapJar.archiveFile.get().asFile.absolutePath}${File.pathSeparator}${remapTestmodJar.archiveFile.get().asFile.absolutePath}", "-Dfabric.autoTest" ) } } task serverPropertiesJar(type: Jar) { def propsFile = file("build/tmp/install.properties") doFirst { propsFile.text = """\ fabric-loader-version=${project.loader_version} game-version=${project.minecraft_version} """.stripMargin().stripIndent() } archiveFileName = "test-server-properties.jar" destinationDirectory = file("build/tmp") from(propsFile) } task runProductionAutoTestServer(type: JavaExec, dependsOn: [remapJar, remapTestmodJar, serverPropertiesJar]) { classpath.from configurations.productionRuntimeServer, serverPropertiesJar mainClass = "net.fabricmc.installer.ServerLauncher" workingDir = file("run") doFirst { workingDir.mkdirs() jvmArgs( "-Dfabric.addMods=${remapJar.archiveFile.get().asFile.absolutePath}${File.pathSeparator}${remapTestmodJar.archiveFile.get().asFile.absolutePath}", "-Dfabric.autoTest" ) args("nogui") } } subprojects { if (it.name == "deprecated") return dependencies { testmodImplementation sourceSets.main.output // Make all modules depend on the gametest api (and thus res loader) to try and promote its usage. if (project.name != "fabric-gametest-api-v1") { testmodImplementation project(path: ':fabric-gametest-api-v1', configuration: 'namedElements') testmodImplementation project(path: ':fabric-resource-loader-v0', configuration: 'namedElements') } // Make all testmods run with registry-sync-v0 as it is required to register new objects. if (project.name != "fabric-registry-sync-v0") { testmodRuntimeOnly project(path: ':fabric-registry-sync-v0', configuration: 'namedElements') } } publishing { publications { mavenJava(MavenPublication) { artifact(signingEnabled ? signRemapJar.output : remapJar) { builtBy(signingEnabled ? signRemapJar : remapJar) } artifact(remapSourcesJar) { builtBy remapSourcesJar } } } } // We manually handle the pom generation loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava) javadoc.enabled = false } publishing { publications { mavenJava(MavenPublication) { artifact(signingEnabled ? signRemapJar.output : remapJar) { builtBy(signingEnabled ? signRemapJar : remapJar) } artifact(sourcesJar) { builtBy remapSourcesJar } artifact javadocJar artifact remapTestmodJar pom.withXml { def depsNode = asNode().appendNode("dependencies") subprojects.each { // Dont depend on the deprecated modules in the main artifact. if (it.path.startsWith(":deprecated")) return def depNode = depsNode.appendNode("dependency") depNode.appendNode("groupId", it.group) depNode.appendNode("artifactId", it.name) depNode.appendNode("version", it.version) depNode.appendNode("scope", "compile") } } } } } // Required until the deprecation is removed. Fabric API's main jar that is published to maven does not contain sub modules. loom.disableDeprecatedPomGeneration(publishing.publications.mavenJava) void setupRepositories(RepositoryHandler repositories) { //repositories.mavenLocal() // uncomment for testing def ENV = System.getenv() if (ENV.MAVEN_URL) { repositories.maven { url ENV.MAVEN_URL if (ENV.MAVEN_USERNAME) { credentials { username ENV.MAVEN_USERNAME password ENV.MAVEN_PASSWORD } } } } } subprojects.each { if (it.name == "deprecated") return remapJar.dependsOn("${it.path}:remapJar") } sourceSets { testmod } // These modules are not included in the fat jar, maven will resolve them via the pom. def devOnlyModules = [ "fabric-gametest-api-v1", ] dependencies { afterEvaluate { subprojects.each { if (it.name == "deprecated") return api project(path: "${it.path}", configuration: "namedElements") clientImplementation project("${it.path}:").sourceSets.client.output testmodImplementation project("${it.path}:").sourceSets.testmod.output } } } remapJar { afterEvaluate { subprojects.each { if (it.name in devOnlyModules || it.name == "deprecated") return // Include the signed or none signed jar from the sub project. nestedJars.from project("${it.path}").tasks.getByName(signingEnabled ? "signRemapJar" : "remapJar") } } } curseforge { if (ENV.CURSEFORGE_API_KEY) { apiKey = ENV.CURSEFORGE_API_KEY } project { id = "306612" changelog = ENV.CHANGELOG ?: "No changelog provided" releaseType = project.prerelease == "true" ? "beta" : "release" addGameVersion "1.19.4" addGameVersion "Fabric" mainArtifact(signingEnabled ? signRemapJar.output : remapJar) { displayName = "[$project.minecraft_version] Fabric API $project.version" } afterEvaluate { uploadTask.dependsOn("remapJar") } } options { forgeGradleIntegration = false } } if (signingEnabled) { project.tasks.curseforge.dependsOn signRemapJar project.tasks.modrinth.dependsOn signRemapJar build.dependsOn signRemapJar } import org.kohsuke.github.GHReleaseBuilder import org.kohsuke.github.GitHub task github(dependsOn: (signingEnabled ? signRemapJar : remapJar)) { onlyIf { ENV.GITHUB_TOKEN } doLast { def github = GitHub.connectUsingOAuth(ENV.GITHUB_TOKEN as String) def repository = github.getRepository(ENV.GITHUB_REPOSITORY) def releaseBuilder = new GHReleaseBuilder(repository, version as String) releaseBuilder.name("[$project.minecraft_version] Fabric API $project.version") releaseBuilder.body(ENV.CHANGELOG ?: "No changelog provided") releaseBuilder.commitish(getBranch()) releaseBuilder.prerelease(project.prerelease == "true") def ghRelease = releaseBuilder.create() ghRelease.uploadAsset(signingEnabled ? signRemapJar.output.get().getAsFile() : remapJar.archiveFile.get().getAsFile(), "application/java-archive"); } } modrinth { projectId = "fabric-api" versionName = "[$project.minecraft_version] Fabric API $project.version" versionType = project.prerelease == "true" ? "beta" : "release" changelog = ENV.CHANGELOG ?: "No changelog provided" uploadFile = signingEnabled ? signRemapJar.output : remapJar } // A task to ensure that the version being released has not already been released. task checkVersion { doFirst { def xml = new URL("https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api/maven-metadata.xml").text def metadata = new XmlSlurper().parseText(xml) def versions = metadata.versioning.versions.version*.text(); if (versions.contains(version)) { throw new RuntimeException("${version} has already been released!") } } } github.mustRunAfter checkVersion project.tasks.modrinth.mustRunAfter checkVersion publish.mustRunAfter checkVersion project.tasks.curseforge.mustRunAfter checkVersion