Release NG 7.1. Closes #278

Author: marchermans

.github/workflows/build-prs.yml

@@ -19,5 +19,5 @@ jobs:
   build:
     uses: neoforged/actions/.github/workflows/build-prs.yml@main
     with:
-      java: 8
+      java: 17
       gradle_tasks: assemble

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
   release:
     uses: neoforged/actions/.github/workflows/gradle-publish.yml@main
     with:
-      java: 8
+      java: 17
       gradle_tasks: publish 
     secrets:
       DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

README.md

@@ -510,7 +510,10 @@ using [Gradle properties](https://docs.gradle.org/current/userguide/project_prop
 | `neogradle.subsystems.recompiler.args`       | Pass additional command line arguments to the Java compiler.                                                                         |
 | `neogradle.subsystems.recompiler.shouldFork` | Indicates whether or not a process fork should be used for the recompiler. (Default is true).                                        |
 
-## Run specific dependency management
+## <a id="common-dep-run-specific-dependency-management" /> Run specific dependency management
+> [!WARNING]
+> Minecraft Version 21.9 and later do not need Run Specific dependency management anymore. Please remove your gradle code. It is not used by NeoGradle anymore to configure NeoForge or FML
+
 This implements run specific dependency management for the classpath of a run.
 In the past this had to happen via a manual modification of the "minecraft_classpath" token, however tokens don't exist anymore as a component that can be configured on a run.
 It was as such not possible to add none FML aware libraries to your classpath of a run.

build.gradle

@@ -4,15 +4,16 @@ import org.gradle.util.GradleVersion
 plugins {
     id 'eclipse'
     id 'maven-publish'
-    id 'org.cadixdev.licenser' version '0.6.1'
-    id 'net.neoforged.gradleutils' version '3.0.0-alpha.10'
+    id 'net.neoforged.licenser' version '0.7.5'
+    id 'net.neoforged.gradleutils' version '5.0.1'
 }
 
 gradleutils {
     version {
         branches {
             suffixBranch()
             suffixExemptedBranch('NG_7.0')
+            suffixExemptedBranch('NG_7.1')
         }
     }
 }
@@ -90,14 +91,15 @@ subprojects.forEach { Project subProject ->
         repository.name 'NeoForged'
         repository.url = 'https://maven.neoforged.net/releases'
     }
+    subProject.repositories.mavenCentral()
     subProject.repositories.gradlePluginPortal()
 
     //Basic dependencies: Jetbrains Annotations, JUnit and Mockito for now.
     subProject.dependencies.api "org.jetbrains:annotations:${project.jetbrains_annotations_version}"
     subProject.dependencies.testImplementation "org.junit.jupiter:junit-jupiter-api:${project.junit_version}"
-    subProject.dependencies.testImplementation "org.junit.jupiter:junit-jupiter-params:${project.junit_version}"
     subProject.dependencies.testImplementation "org.junit.jupiter:junit-jupiter-engine:${project.junit_version}"
-    subProject.dependencies.testImplementation "org.junit.platform:junit-platform-engine:${project.junit_platform_version}"
+    subProject.dependencies.testRuntimeOnly    "org.junit.platform:junit-platform-launcher"
+    subProject.dependencies.testImplementation "org.junit.jupiter:junit-jupiter-params:${project.junit_version}"
     subProject.dependencies.testImplementation "org.mockito:mockito-junit-jupiter:${project.mockito_version}"
     subProject.dependencies.testImplementation "org.mockito:mockito-core:${project.mockito_version}"
     subProject.dependencies.testImplementation "org.mockito:mockito-inline:${project.mockito_version}"
@@ -131,6 +133,7 @@ subprojects.forEach { Project subProject ->
 
     //Run tests in parallel
     subProject.test {
+        useJUnitPlatform()
         maxParallelForks = Runtime.runtime.availableProcessors() - 1
     }
 
@@ -170,7 +173,9 @@ subprojects.forEach { subProject ->
 
         //All dependencies needed to run the functional tests.
         evalSubProject.dependencies.functionalTestImplementation subProject.dependencies.gradleTestKit()
-        evalSubProject.dependencies.functionalTestImplementation "org.junit.jupiter:junit-jupiter:${project.junit_version}"
+        evalSubProject.dependencies.functionalTestImplementation "org.junit.jupiter:junit-jupiter-api:${project.junit_version}"
+        evalSubProject.dependencies.functionalTestImplementation "org.junit.jupiter:junit-jupiter-engine:${project.junit_version}"
+        evalSubProject.dependencies.functionalTestRuntimeOnly    "org.junit.platform:junit-platform-launcher"
         evalSubProject.dependencies.functionalTestImplementation("org.spockframework:spock-core:${project.spock_version}-groovy-${project.groovy_version}") { spec ->
             spec.exclude group: 'org.codehaus.groovy'
         }
@@ -215,6 +220,8 @@ subprojects.forEach { subProject ->
 
         //Run task which will run the functional tests.
         evalSubProject.tasks.register('functionalTest', Test) {
+            useJUnitPlatform()
+
             group 'verification'
 
             testClassesDirs = evalSubProject.sourceSets.functionalTest.output.classesDirs

common/build.gradle

@@ -16,11 +16,6 @@ sourceSets {
 dependencies {
     api project(':utils')
     api project(':dsl-common')
-    api (project(':eclipse')) {
-        capabilities {
-            requireCapability('net.neoforged.gradle:eclipse-impl')
-        }
-    }
 
     api "commons-io:commons-io:${project.commons_io_version}"
     api "com.google.code.gson:gson:${project.gson_version}"

common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java

@@ -13,6 +13,7 @@
 import net.neoforged.gradle.common.interfaceinjection.InterfaceInjectionPublishing;
 import net.neoforged.gradle.common.rules.LaterAddedReplacedDependencyRule;
 import net.neoforged.gradle.common.runs.ide.IdeRunIntegrationManager;
+import net.neoforged.gradle.common.runs.run.RunImpl;
 import net.neoforged.gradle.common.runs.run.RunManagerImpl;
 import net.neoforged.gradle.common.runs.run.RunTypeManagerImpl;
 import net.neoforged.gradle.common.runs.tasks.RunsReport;
@@ -36,7 +37,6 @@
 import net.neoforged.gradle.dsl.common.runs.run.RunManager;
 import net.neoforged.gradle.dsl.common.runs.type.RunTypeManager;
 import net.neoforged.gradle.dsl.common.util.NamingConstants;
-import net.neoforged.gradle.eclipse.EclipseMetadataReader;
 import net.neoforged.gradle.util.UrlConstants;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
@@ -162,9 +162,6 @@ public void apply(Project project) {
         ConventionConfigurator.configureConventions(project);
 
         project.afterEvaluate(this::applyAfterEvaluate);
-
-        //EMR Init
-        EclipseMetadataReader.init(project);
     }
 
     private void applyAfterEvaluate(final Project project) {
@@ -175,6 +172,12 @@ private void applyAfterEvaluate(final Project project) {
                 run,
                 !runs.getNames().contains(run.getName()) //Internal runs are not directly registered, so they don't show up in the name list.
         ));
+        //Second loop over all internal and public runs to validate their configuration and emit warnings.
+        runs.realizeAll(run -> {
+            if (run instanceof RunImpl runImpl) {
+                runImpl.performSdkValidation();
+            }
+        });
         IdeRunIntegrationManager.getInstance().apply(project);
     }
 }

common/src/main/java/net/neoforged/gradle/common/dependency/ExtraJarDependencyManager.java

@@ -94,13 +94,9 @@ private ReplacementResult generateReplacement(final Project project, final Depen
 
             final TaskProvider<GenerateExtraJar> extraJarTaskProvider = project.getTasks().register("create" + minecraftVersion + StringUtils.capitalize(dependency.getName()) + "ExtraJar", GenerateExtraJar.class, task -> {
                 task.getOriginalJar().set(tasks.get(GameArtifact.CLIENT_JAR).flatMap(WithOutput::getOutput));
-                task.getServerJar().set(tasks.get(GameArtifact.SERVER_JAR).flatMap(WithOutput::getOutput));
+                task.getServerJar().set(tasks.get(GameArtifact.EXTRACTED_SERVER_JAR).flatMap(WithOutput::getOutput));
                 task.getMappings().set(tasks.get(GameArtifact.CLIENT_MAPPINGS).flatMap(WithOutput::getOutput));
                 task.getOutput().set(project.getLayout().getBuildDirectory().dir("jars/extra/" + dependency.getName()).map(cacheDir -> cacheDir.dir(Objects.requireNonNull(minecraftVersion)).file( dependency.getName() + "-extra.jar")));
-
-                task.dependsOn(tasks.get(GameArtifact.CLIENT_JAR));
-                task.dependsOn(tasks.get(GameArtifact.SERVER_JAR));
-                task.dependsOn(tasks.get(GameArtifact.CLIENT_MAPPINGS));
             });
 
             return new ReplacementResult(

common/src/main/java/net/neoforged/gradle/common/extensions/ConfigurationDataExtension.java

@@ -1,6 +1,6 @@
 package net.neoforged.gradle.common.extensions;
 
-import net.minecraftforge.gdi.ConfigurableDSLElement;
+import net.neoforged.gdi.ConfigurableDSLElement;
 import net.neoforged.gradle.dsl.common.extensions.ConfigurationData;
 import org.gradle.api.Project;
 

common/src/main/java/net/neoforged/gradle/common/extensions/MappingsExtension.java

@@ -1,7 +1,7 @@
 package net.neoforged.gradle.common.extensions;
 
 import groovy.lang.MissingMethodException;
-import net.minecraftforge.gdi.ConfigurableDSLElement;
+import net.neoforged.gdi.ConfigurableDSLElement;
 import net.neoforged.gradle.dsl.common.extensions.Mappings;
 import net.neoforged.gradle.dsl.common.extensions.Minecraft;
 import net.neoforged.gradle.dsl.common.util.NamingConstants;

common/src/main/java/net/neoforged/gradle/common/extensions/MinecraftArtifactCacheExtension.java

@@ -3,11 +3,10 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import net.minecraftforge.gdi.ConfigurableDSLElement;
+import net.neoforged.gdi.ConfigurableDSLElement;
 import net.neoforged.gradle.common.tasks.MinecraftVersionManifestFileCacheProvider;
 import net.neoforged.gradle.common.util.FileCacheUtils;
 import net.neoforged.gradle.common.util.FileDownloadingUtils;
-import net.neoforged.gradle.common.util.MinecraftArtifactType;
 import net.neoforged.gradle.common.util.SerializationUtils;
 import net.neoforged.gradle.dsl.common.extensions.MinecraftArtifactCache;
 import net.neoforged.gradle.dsl.common.tasks.WithOutput;
@@ -99,10 +98,24 @@ public final Map<GameArtifact, TaskProvider<? extends WithOutput>> cacheGameVers
             final TaskProvider<MinecraftVersionManifestFileCacheProvider> manifest = FileCacheUtils.createVersionManifestFileCacheProvidingTask(project, resolvedVersion);
 
             GameArtifact.VERSION_MANIFEST.doWhenRequired(side, () -> results.put(GameArtifact.VERSION_MANIFEST, manifest));
-            GameArtifact.CLIENT_JAR.doWhenRequired(side, () -> results.put(GameArtifact.CLIENT_JAR, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), DistributionType.CLIENT, MinecraftArtifactType.EXECUTABLE, manifest, results.values())));
-            GameArtifact.SERVER_JAR.doWhenRequired(side, () -> results.put(GameArtifact.SERVER_JAR, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), DistributionType.SERVER, MinecraftArtifactType.EXECUTABLE, manifest, results.values())));
-            GameArtifact.CLIENT_MAPPINGS.doWhenRequired(side, () -> results.put(GameArtifact.CLIENT_MAPPINGS, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), DistributionType.CLIENT, MinecraftArtifactType.MAPPINGS, manifest, results.values())));
-            GameArtifact.SERVER_MAPPINGS.doWhenRequired(side, () -> results.put(GameArtifact.SERVER_MAPPINGS, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), DistributionType.SERVER, MinecraftArtifactType.MAPPINGS, manifest, results.values())));
+            GameArtifact.CLIENT_JAR.doWhenRequired(side, () -> results.put(GameArtifact.CLIENT_JAR, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), GameArtifact.CLIENT_JAR, manifest)));
+            GameArtifact.SERVER_JAR.doWhenRequired(side, () -> results.put(GameArtifact.SERVER_JAR, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), GameArtifact.SERVER_JAR, manifest)));
+            GameArtifact.CLIENT_MAPPINGS.doWhenRequired(side, () -> results.put(GameArtifact.CLIENT_MAPPINGS, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), GameArtifact.CLIENT_MAPPINGS, manifest)));
+            GameArtifact.SERVER_MAPPINGS.doWhenRequired(side, () -> results.put(GameArtifact.SERVER_MAPPINGS, FileCacheUtils.createArtifactFileCacheProvidingTask(project, resolvedVersion.getVersion(), GameArtifact.SERVER_MAPPINGS, manifest)));
+
+            GameArtifact.EXTRACTED_SERVER_JAR.doWhenRequired(side, () -> {
+                if (!results.containsKey(GameArtifact.SERVER_JAR))
+                    throw new RuntimeException("Invalid configuration, for an extracted server jar, a wrapped server jar is required!");
+
+                final TaskProvider<? extends WithOutput> bundledServerProvider = results.get(GameArtifact.SERVER_JAR);
+
+                results.put(GameArtifact.EXTRACTED_SERVER_JAR, FileCacheUtils.createExtractedServerFileCacheProvidingTask(
+                    project,
+                    gameVersion,
+                    GameArtifact.EXTRACTED_SERVER_JAR,
+                    bundledServerProvider
+                ));
+            });
 
             return results;
         });