Expose version, minecraft version and version capabilities on the extension

shartte · shartte · commit ac2c6fe742e8 · 2024-12-29T00:45:01.000+01:00
diff --git a/src/main/java/net/neoforged/moddevgradle/dsl/ModDevExtension.java b/src/main/java/net/neoforged/moddevgradle/dsl/ModDevExtension.java
@@ -3,9 +3,8 @@
 import net.neoforged.moddevgradle.internal.Branding;
 import net.neoforged.moddevgradle.internal.IdeIntegration;
 import net.neoforged.moddevgradle.internal.ModDevArtifactsWorkflow;
-import net.neoforged.moddevgradle.internal.utils.ExtensionUtils;
+import net.neoforged.moddevgradle.internal.utils.VersionCapabilities;
 import org.gradle.api.Action;
-import org.gradle.api.GradleException;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
@@ -14,6 +13,7 @@
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskProvider;
+import org.jetbrains.annotations.Nullable;
 
 import javax.inject.Inject;
 import java.io.File;
@@ -158,4 +158,29 @@ public void ideSyncTask(Task task) {
     public void addModdingDependenciesTo(SourceSet sourceSet) {
         ModDevArtifactsWorkflow.get(project).addToSourceSet(sourceSet);
     }
+
+    /**
+     * After enabling modding, you can retrieve the version of the modding platform you picked using this getter.
+     * I.e. the NeoForge or Forge version. If you chose to enable vanilla-only mode, this getter returns null.
+     */
+    @Nullable
+    public String getVersion() {
+        var dependencies = ModDevArtifactsWorkflow.get(project).dependencies();
+        return dependencies.neoForgeDependency() != null ? dependencies.neoForgeDependency().getVersion() : null;
+    }
+
+    /**
+     * After enabling modding, you can retrieve the effective Minecraft version using this getter.
+     */
+    @Nullable
+    public String getMinecraftVersion() {
+        return ModDevArtifactsWorkflow.get(project).versionCapabilities().minecraftVersion();
+    }
+
+    /**
+     * After enabling modding, you can retrieve the capabilities of the version you picked using this getter.
+     */
+    public VersionCapabilities getVersionCapabilities() {
+        return ModDevArtifactsWorkflow.get(project).versionCapabilities();
+    }
 }
diff --git a/src/main/java/net/neoforged/moddevgradle/dsl/VersionCapabilities.java b/src/main/java/net/neoforged/moddevgradle/dsl/VersionCapabilities.java
@@ -0,0 +1,21 @@
+package net.neoforged.moddevgradle.dsl;
+
+/**
+ * Describes the capabilities of the currently chosen version of Minecraft.
+ */
+public interface VersionCapabilities {
+    /**
+     * The Java version used by this version of Minecraft.
+     */
+    int javaVersion();
+
+    /**
+     * Whether this version of Minecraft uses separate data-generation runs for client and server data.
+     */
+    boolean splitDataRuns();
+
+    /**
+     * Whether the NeoForge version for this version of Minecraft supports mod-loading in unit tests.
+     */
+    boolean testFixtures();
+}
diff --git a/src/main/java/net/neoforged/moddevgradle/internal/ModDevArtifactsWorkflow.java b/src/main/java/net/neoforged/moddevgradle/internal/ModDevArtifactsWorkflow.java
@@ -50,13 +50,12 @@ public record ModDevArtifactsWorkflow(
         Provider<Directory> modDevBuildDir,
         Provider<Directory> artifactsBuildDir
 ) {
-
     private static final String EXTENSION_NAME = "__internal_modDevArtifactsWorkflow";
 
     public static ModDevArtifactsWorkflow get(Project project) {
         var result = ExtensionUtils.findExtension(project, EXTENSION_NAME, ModDevArtifactsWorkflow.class);
         if (result == null) {
-            throw new IllegalStateException("Mod development has not been enabled yet for project " + project);
+            throw new InvalidUserCodeException("Mod development has not been enabled yet for project " + project);
         }
         return result;
     }
diff --git a/src/main/java/net/neoforged/moddevgradle/internal/utils/VersionCapabilities.java b/src/main/java/net/neoforged/moddevgradle/internal/utils/VersionCapabilities.java
@@ -9,16 +9,21 @@
 
 /**
  * Models the changing capabilities of the modding platform and Vanilla, which we tie to the Minecraft version.
- * @param javaVersion Which Java version Vanilla uses to compile and run.
- * @param splitDataRuns Whether Vanilla has separate main classes for generating client and server data.
- * @param testFixtures If the NeoForge version for this Minecraft version supports test fixtures.
+ *
+ * @param minecraftVersion The Minecraft version.
+ * @param javaVersion      Which Java version Vanilla uses to compile and run.
+ * @param splitDataRuns    Whether Vanilla has separate main classes for generating client and server data.
+ * @param testFixtures     If the NeoForge version for this Minecraft version supports test fixtures.
  */
-public record VersionCapabilities(int javaVersion, boolean splitDataRuns, boolean testFixtures) implements Serializable {
+public record VersionCapabilities(String minecraftVersion, int javaVersion, boolean splitDataRuns,
+                                  boolean testFixtures) implements net.neoforged.moddevgradle.dsl.VersionCapabilities, Serializable {
     private static final Logger LOG = LoggerFactory.getLogger(VersionCapabilities.class);
 
-    private static final VersionCapabilities LATEST = new VersionCapabilities(21, true, true);
+    private static final VersionCapabilities LATEST = new VersionCapabilities(MinecraftVersionList.VERSIONS.get(0), 21, true, true);
 
     private static final Pattern NEOFORGE_PATTERN = Pattern.compile("^(\\d+\\.\\d+)\\.\\d+(|-.*)$");
+    // Strips NeoForm timestamp suffixes OR dynamic version markers
+    private static final Pattern NEOFORM_PATTERN = Pattern.compile("^(.*)-(?:\\+|\\d{8}\\.\\d{6})$");
 
     private static final int MC_24W45A_INDEX = getReferenceVersionIndex("24w45a");
     private static final int MC_24W14A_INDEX = getReferenceVersionIndex("24w14a");
@@ -34,18 +39,23 @@ public static VersionCapabilities ofMinecraftVersion(String minecraftVersion) {
         var versionIndex = MinecraftVersionList.VERSIONS.indexOf(minecraftVersion);
         if (versionIndex == -1) {
             LOG.info("Minecraft Version {} is unknown. Assuming latest capabilities.", versionIndex);
-            return LATEST;
+            return LATEST.withMinecraftVersion(minecraftVersion);
         }
 
         return ofVersionIndex(versionIndex);
     }
 
     public static VersionCapabilities ofVersionIndex(int versionIndex) {
+        var minecraftVersion = MinecraftVersionList.VERSIONS.get(versionIndex);
+        return ofVersionIndex(versionIndex, minecraftVersion);
+    }
+
+    public static VersionCapabilities ofVersionIndex(int versionIndex, String minecraftVersion) {
         var javaVersion = getJavaVersion(versionIndex);
         var splitData = hasSplitDataEntrypoints(versionIndex);
         var testFixtures = hasTestFixtures(versionIndex);
 
-        return new VersionCapabilities(javaVersion, splitData, testFixtures);
+        return new VersionCapabilities(minecraftVersion, javaVersion, splitData, testFixtures);
     }
 
     static int getJavaVersion(int versionIndex) {
@@ -86,23 +96,38 @@ static int indexOfNeoForgeVersion(String version) {
     public static VersionCapabilities ofNeoForgeVersion(String version) {
         var index = indexOfNeoForgeVersion(version);
         if (index == -1) {
-            LOG.warn("Failed to parse MC version from NeoForge version {}. Using capabilities of latest known Minecraft version.", version);
-            return LATEST;
+            var capabilities = LATEST;
+            var m = NEOFORGE_PATTERN.matcher(version);
+            if (m.matches()) {
+                var minecraftVersion = "1." + m.group(1);
+                if (minecraftVersion.endsWith(".0")) {
+                    minecraftVersion = minecraftVersion.substring(0, minecraftVersion.length() - 2);
+                }
+                capabilities = capabilities.withMinecraftVersion(minecraftVersion);
+            }
+
+            LOG.warn("Failed to parse MC version from NeoForge version {}. Using capabilities of latest known Minecraft version with Minecraft version {}.", version, capabilities.minecraftVersion());
+            return capabilities;
         }
 
         return ofVersionIndex(index);
     }
 
-    static int indexOfNeoFormVersion(String version) {
+    public static VersionCapabilities ofNeoFormVersion(String version) {
         // Examples: 1.21-<timestamp>
-        return MinecraftVersionList.indexOfByPrefix(version, "-");
-    }
+        var index = MinecraftVersionList.indexOfByPrefix(version, "-");
 
-    public static VersionCapabilities ofNeoFormVersion(String version) {
-        var index = indexOfNeoFormVersion(version);
         if (index == -1) {
-            LOG.warn("Failed to parse MC version from NeoForm version {}. Using capabilities of latest known Minecraft version.", version);
-            return LATEST;
+            var capabilities = LATEST;
+            var m = NEOFORM_PATTERN.matcher(version);
+            if (m.matches()) {
+                capabilities = capabilities.withMinecraftVersion(m.group(1));
+            } else {
+                capabilities = capabilities.withMinecraftVersion(version);
+            }
+
+            LOG.warn("Failed to parse MC version from NeoForm version {}. Using capabilities of latest known Minecraft version with Minecraft version {}.", version, capabilities.minecraftVersion());
+            return capabilities;
         }
 
         return ofVersionIndex(index);
@@ -130,4 +155,13 @@ private static int getReferenceVersionIndex(String v) {
         }
         return idx;
     }
+
+    public VersionCapabilities withMinecraftVersion(String minecraftVersion) {
+        return new VersionCapabilities(
+                minecraftVersion,
+                javaVersion,
+                splitDataRuns,
+                testFixtures
+        );
+    }
 }
diff --git a/src/test/java/net/neoforged/moddevgradle/internal/ModDevPluginTest.java b/src/test/java/net/neoforged/moddevgradle/internal/ModDevPluginTest.java
@@ -3,18 +3,20 @@
 import net.neoforged.moddevgradle.AbstractProjectBuilderTest;
 import net.neoforged.moddevgradle.dsl.NeoForgeExtension;
 import net.neoforged.moddevgradle.internal.utils.ExtensionUtils;
+import net.neoforged.moddevgradle.internal.utils.VersionCapabilities;
 import org.gradle.api.InvalidUserCodeException;
-import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.jvm.toolchain.JavaLanguageVersion;
 import org.gradle.testfixtures.ProjectBuilder;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class ModDevPluginTest extends AbstractProjectBuilderTest {
@@ -39,32 +41,15 @@ public ModDevPluginTest() {
 
     @Test
     void testModdingCannotBeEnabledTwice() {
-        extension.setVersion("1.2.3");
-        var e = assertThrows(InvalidUserCodeException.class, () -> extension.setVersion("1.2.3"));
+        extension.setVersion("2.3.0");
+        var e = assertThrows(InvalidUserCodeException.class, () -> extension.setVersion("2.3.0"));
         assertThat(e).hasMessage("You cannot enable modding in the same project twice.");
     }
 
-    @Test
-    void testEnableVanillaOnlyMode() {
-        extension.setNeoFormVersion("1.2.3");
-
-        assertThatDependencies(mainSourceSet.getCompileClasspathConfigurationName())
-                .containsOnly(
-                        "build/moddev/artifacts/vanilla-1.2.3.jar",
-                        "net.neoforged:neoform:1.2.3[net.neoforged:neoform-dependencies]"
-                );
-        assertThatDependencies(mainSourceSet.getRuntimeClasspathConfigurationName())
-                .containsOnly(
-                        "build/moddev/artifacts/vanilla-1.2.3.jar",
-                        "build/moddev/artifacts/vanilla-1.2.3-client-extra-aka-minecraft-resources.jar",
-                        "net.neoforged:neoform:1.2.3[net.neoforged:neoform-dependencies]"
-                );
-    }
-
     @Test
     void testEnableForTestSourceSetOnly() {
         extension.enable(settings -> {
-            settings.setVersion("1.2.3");
+            settings.setVersion("2.3.0");
             settings.setEnabledSourceSets(Set.of(testSourceSet));
         });
 
@@ -73,25 +58,117 @@ void testEnableForTestSourceSetOnly() {
         assertThatDependencies(mainSourceSet.getRuntimeClasspathConfigurationName()).isEmpty();
 
         // While the test classpath should have modding dependencies
-        assertContainsModdingCompileDependencies("1.2.3", testSourceSet.getCompileClasspathConfigurationName());
-        assertContainsModdingRuntimeDependencies("1.2.3", testSourceSet.getRuntimeClasspathConfigurationName());
+        assertContainsModdingCompileDependencies("2.3.0", testSourceSet.getCompileClasspathConfigurationName());
+        assertContainsModdingRuntimeDependencies("2.3.0", testSourceSet.getRuntimeClasspathConfigurationName());
     }
 
     @Test
     void testAddModdingDependenciesTo() {
-        extension.setVersion("1.2.3");
+        extension.setVersion("2.3.0");
 
         // Initially, only the main source set should have the dependencies
-        assertContainsModdingCompileDependencies("1.2.3", mainSourceSet.getCompileClasspathConfigurationName());
-        assertContainsModdingRuntimeDependencies("1.2.3", mainSourceSet.getRuntimeClasspathConfigurationName());
+        assertContainsModdingCompileDependencies("2.3.0", mainSourceSet.getCompileClasspathConfigurationName());
+        assertContainsModdingRuntimeDependencies("2.3.0", mainSourceSet.getRuntimeClasspathConfigurationName());
         assertThatDependencies(testSourceSet.getCompileClasspathConfigurationName()).isEmpty();
         assertThatDependencies(testSourceSet.getRuntimeClasspathConfigurationName()).isEmpty();
 
         // Now add it to the test source set too
         extension.addModdingDependenciesTo(testSourceSet);
 
-        assertContainsModdingCompileDependencies("1.2.3", testSourceSet.getCompileClasspathConfigurationName());
-        assertContainsModdingRuntimeDependencies("1.2.3", testSourceSet.getRuntimeClasspathConfigurationName());
+        assertContainsModdingCompileDependencies("2.3.0", testSourceSet.getCompileClasspathConfigurationName());
+        assertContainsModdingRuntimeDependencies("2.3.0", testSourceSet.getRuntimeClasspathConfigurationName());
+    }
+
+    @Test
+    void testGetVersion() {
+        extension.setVersion("2.3.0");
+        assertEquals("2.3.0", extension.getVersion());
+    }
+
+    @Test
+    void testGetVersionCapabilities() {
+        extension.setVersion("2.3.0");
+        assertEquals(VersionCapabilities.ofMinecraftVersion("1.2.3"), extension.getVersionCapabilities());
+        assertEquals("1.2.3", extension.getVersionCapabilities().minecraftVersion());
+    }
+
+    @Test
+    void testGetMinecraftVersion() {
+        extension.setVersion("2.3.0-suffixstuff");
+        assertEquals("1.2.3", extension.getMinecraftVersion());
+    }
+
+    @Nested
+    class VanillaOnlyMode {
+        final static String VERSION = "1.21.4-20240101.235959";
+
+        @Test
+        void testEnable() {
+            extension.setNeoFormVersion(VERSION);
+
+            assertThatDependencies(mainSourceSet.getCompileClasspathConfigurationName())
+                    .containsOnly(
+                            "build/moddev/artifacts/vanilla-" + VERSION + ".jar",
+                            "net.neoforged:neoform:" + VERSION + "[net.neoforged:neoform-dependencies]"
+                    );
+            assertThatDependencies(mainSourceSet.getRuntimeClasspathConfigurationName())
+                    .containsOnly(
+                            "build/moddev/artifacts/vanilla-" + VERSION + ".jar",
+                            "build/moddev/artifacts/vanilla-" + VERSION + "-client-extra-aka-minecraft-resources.jar",
+                            "net.neoforged:neoform:" + VERSION + "[net.neoforged:neoform-dependencies]"
+                    );
+        }
+
+        @Test
+        void testGetVersion() {
+            extension.setNeoFormVersion(VERSION);
+            assertEquals(VersionCapabilities.ofNeoFormVersion(VERSION), extension.getVersionCapabilities());
+        }
+
+        @Test
+        void testGetMinecraftVersion() {
+            extension.setNeoFormVersion(VERSION);
+            assertEquals("1.21.4", extension.getMinecraftVersion());
+        }
+
+        @Test
+        void testGetVersionCapabilities() {
+            extension.setNeoFormVersion(VERSION);
+            assertEquals(VersionCapabilities.ofNeoFormVersion(VERSION), extension.getVersionCapabilities());
+        }
+
+        @Test
+        void testGetVersionCapabilitiesForUnknownVersion() {
+            extension.setNeoFormVersion("1.99.1-20990101.235959");
+            // Should use latest features, but with the specified Minecraft version
+            assertEquals(
+                    VersionCapabilities.latest().withMinecraftVersion("1.99.1"),
+                    extension.getVersionCapabilities()
+            );
+        }
+    }
+
+    @Nested
+    class CannotCallWhenModdingIsNotEnabled {
+        static String expectedMessage = "Mod development has not been enabled yet for project root project 'test'";
+
+        @Test
+        void testGettingMinecraftVersionThrows() {
+            var e = assertThrows(InvalidUserCodeException.class, extension::getVersionCapabilities);
+            assertThat(e).hasMessage(expectedMessage);
+        }
+
+        @Test
+        void testGettingVersionCapabilitiesThrows() {
+            var e = assertThrows(InvalidUserCodeException.class, extension::getVersion);
+            assertThat(e).hasMessage(expectedMessage);
+        }
+
+        @Test
+        void testAddModdingDependenciesToThrows() {
+            var e = assertThrows(InvalidUserCodeException.class, () -> extension.addModdingDependenciesTo(mainSourceSet));
+            assertThat(e).hasMessage(expectedMessage);
+        }
     }
 
     private void assertContainsModdingCompileDependencies(String version, String configurationName) {
diff --git a/src/test/java/net/neoforged/moddevgradle/internal/utils/VersionCapabilitiesTest.java b/src/test/java/net/neoforged/moddevgradle/internal/utils/VersionCapabilitiesTest.java

Original file line number	Diff line number	Diff line change
`@@ -50,13 +50,12 @@ public record ModDevArtifactsWorkflow(`
`50`	`50`	`Provider<Directory> modDevBuildDir,`
`51`	`51`	`Provider<Directory> artifactsBuildDir`
`52`	`52`	`) {`
`53`		`-`
`54`	`53`	`private static final String EXTENSION_NAME = "__internal_modDevArtifactsWorkflow";`
`55`	`54`
`56`	`55`	`public static ModDevArtifactsWorkflow get(Project project) {`
`57`	`56`	`var result = ExtensionUtils.findExtension(project, EXTENSION_NAME, ModDevArtifactsWorkflow.class);`
`58`	`57`	`if (result == null) {`
`59`		`- throw new IllegalStateException("Mod development has not been enabled yet for project " + project);`
	`58`	`+ throw new InvalidUserCodeException("Mod development has not been enabled yet for project " + project);`
`60`	`59`	`}`
`61`	`60`	`return result;`
`62`	`61`	`}`