Support dynamically selecting MC Versions in vanilla mode.

Author: marchermans

utils/src/main/java/net/neoforged/gradle/util/UrlConstants.java

@@ -12,4 +12,5 @@ private UrlConstants() {
     public static final String MOJANG_MANIFEST = "https://piston-meta.mojang.com/mc/game/version_manifest.json";
     public static final String NEO_FORGE_MAVEN = "https://maven.neoforged.net/releases/";
     public static final String MOJANG_MAVEN = "https://libraries.minecraft.net/";
+    public static final String MINECRAFT_METADATA = "https://maven.neoforged.net/mojang-meta";
 }

vanilla/src/functionalTest/groovy/net/neoforged/gradle/vanilla/VersionRangeTests.groovy

@@ -0,0 +1,81 @@
+package net.neoforged.gradle.vanilla
+
+import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification
+import org.gradle.testkit.runner.TaskOutcome
+
+class VersionRangeTests extends BuilderBasedTestSpecification {
+
+    @Override
+    protected void configurePluginUnderTest() {
+        pluginUnderTest = "net.neoforged.gradle.vanilla";
+        injectIntoAllProject = true;
+    }
+
+    def "the vanilla runtime supports finding an mc version from a range"() {
+        given:
+        def project = create("vanilla_loads_from_a_range", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+
+            dependencies {
+                implementation ('net.minecraft:client') {
+                    version {
+                        strictly '[1.21.6,1.21.7)'
+                    }
+                } 
+            }
+            """)
+
+            it.withToolchains()
+            it.withGlobalCacheDirectory(tempDir)
+        })
+
+        when:
+        def initialRun = project.run {
+            it.tasks('build')
+            it.stacktrace()
+        }
+
+        then:
+        initialRun.task(":build").outcome == TaskOutcome.SUCCESS
+    }
+
+    def "the_vanilla_runtime_supports_loading_a_range_with_a_preferred_option_chosen"() {
+        given:
+        def project = create("vanilla_supports_ats_from_file", {
+            it.build("""
+            java {
+                toolchain {
+                    languageVersion = JavaLanguageVersion.of(21)
+                }
+            }
+
+            dependencies {
+                implementation ('net.minecraft:client') {
+                    version {
+                        strictly '[1.21.6,1.21.7)'
+                        prefer '1.21.6'
+                    }
+                } 
+            }
+            """)
+
+            it.withToolchains()
+            it.withGlobalCacheDirectory(tempDir)
+        })
+
+        when:
+        def initialRun = project.run {
+            it.tasks('build')
+            it.stacktrace()
+        }
+
+        then:
+        initialRun.task(":build").outcome == TaskOutcome.SUCCESS
+        initialRun.task(":cacheVersionManifest1.21.6").outcome == TaskOutcome.SUCCESS
+    }
+}

vanilla/src/main/java/net/neoforged/gradle/vanilla/VanillaProjectPlugin.java

@@ -23,5 +23,14 @@ public void apply(Project project) {
             e.setUrl(UrlConstants.NEO_FORGE_MAVEN);
             e.metadataSources(MavenArtifactRepository.MetadataSources::mavenPom);
         });
+
+        //Add Known repos, -> We need this to resolve the minecraft dependencies to properly get the correct version.
+        project.getRepositories().maven(e -> {
+            e.setUrl(UrlConstants.MINECRAFT_METADATA);
+            e.metadataSources(MavenArtifactRepository.MetadataSources::mavenPom);
+            e.mavenContent(content -> {
+                content.includeModule("net.neoforged", "minecraft-dependencies");
+            });
+        });
     }
 }

vanilla/src/main/java/net/neoforged/gradle/vanilla/dependency/VanillaDependencyManager.java

@@ -7,6 +7,7 @@
 import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.ReplacementResult;
 import net.neoforged.gradle.vanilla.runtime.VanillaRuntimeDefinition;
 import net.neoforged.gradle.vanilla.runtime.extensions.VanillaRuntimeExtension;
+import net.neoforged.gradle.vanilla.util.MinecraftDependencyUtil;
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Dependency;
@@ -95,7 +96,10 @@ private static VanillaRuntimeDefinition buildVanillaRuntimeDefinition(Project pr
         final VanillaRuntimeExtension runtimeExtension = project.getExtensions().getByType(VanillaRuntimeExtension.class);
 
         return runtimeExtension.maybeCreateFor(dependency, builder -> {
-            final String version = dependency.getVersion() == null ? runtimeExtension.getVersion().get() : dependency.getVersion();
+            String version = MinecraftDependencyUtil.resolveMinecraftDependenciesVersion(project, dependency);
+            if (version == null) {
+                version = runtimeExtension.getVersion().get();
+            }
 
             builder.withMinecraftArtifact(StringCapitalizationUtils.deCapitalize(dependency.getName()));
             builder.withDistributionType(DistributionType.valueOf(dependency.getName().toUpperCase(Locale.ROOT)));

vanilla/src/main/java/net/neoforged/gradle/vanilla/util/MinecraftDependencyUtil.java

@@ -0,0 +1,75 @@
+package net.neoforged.gradle.vanilla.util;
+
+import net.neoforged.gradle.common.util.ConfigurationUtils;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.*;
+import org.gradle.api.attributes.Attribute;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@SuppressWarnings("ConstantValue")
+public class MinecraftDependencyUtil
+{
+
+    @Nullable
+    public static String resolveMinecraftDependenciesVersion(final Project project, final ExternalModuleDependency dependency)
+    {
+        final Dependency minecraftDependenciesDependency = project.getDependencies().create("net.neoforged:minecraft-dependencies" + (
+            dependency.getVersion() != null ? ":" + dependency.getVersion() : ""
+        ));
+
+        AtomicBoolean configured = new AtomicBoolean(dependency.getVersion() != null);
+        if (minecraftDependenciesDependency instanceof ExternalModuleDependency emd)
+        {
+            emd.version(version -> {
+                final VersionConstraint versionConstraint = dependency.getVersionConstraint();
+
+                if (versionConstraint.getPreferredVersion() != null && !versionConstraint.getPreferredVersion().isEmpty())
+                {
+                    version.prefer(versionConstraint.getPreferredVersion());
+                    configured.set(true);
+                }
+
+                if (versionConstraint.getRejectedVersions() != null && !versionConstraint.getRejectedVersions().isEmpty())
+                {
+                    version.reject(versionConstraint.getRejectedVersions().toArray(new String[0]));
+                    configured.set(true);
+                }
+
+                if (versionConstraint.getRequiredVersion() != null && !versionConstraint.getRequiredVersion().isEmpty())
+                {
+                    version.require(versionConstraint.getRequiredVersion());
+                    configured.set(true);
+                }
+
+                if (versionConstraint.getStrictVersion() != null && !versionConstraint.getStrictVersion().isEmpty())
+                {
+                    version.strictly(versionConstraint.getStrictVersion());
+                    configured.set(true);
+                }
+
+                if (versionConstraint.getBranch() != null && !versionConstraint.getBranch().isEmpty())
+                {
+                    version.setBranch(versionConstraint.getBranch());
+                    configured.set(true);
+                }
+            });
+        }
+
+        if (!configured.get())
+        {
+            return null;
+        }
+
+        final Configuration dependenciesLookup =
+            ConfigurationUtils.temporaryUnhandledConfiguration(project.getConfigurations(), "ResolveRequestedMinecraftVersion", minecraftDependenciesDependency);
+
+        dependenciesLookup.attributes(attributes -> {
+            attributes.attribute(Attribute.of("net.neoforged.distribution", String.class), "client"); //The distribution does not matter here.
+            attributes.attribute(Attribute.of("net.neoforged.operatingsystem", String.class), "linux"); //Again the OS does not matter, we only need the resolved version, and it will always exist for all of them
+        });
+
+        return dependenciesLookup.getResolvedConfiguration().getFirstLevelModuleDependencies().iterator().next().getModuleVersion();
+    }
+}