Add NeoGradle version dropdown

src/main/kotlin/platform/neoforge/creator/gradle-steps.kt

@@ -71,6 +71,7 @@ class NeoForgeGradleFilesStep(parent: NewProjectWizardStep) : AbstractLongRunnin
     override fun setupAssets(project: Project) {
         val mcVersion = data.getUserData(NeoForgeVersionChainStep.MC_VERSION_KEY) ?: return
         val neoforgeVersion = data.getUserData(NeoForgeVersionChainStep.NEOFORGE_VERSION_KEY) ?: return
+        val neogradleVersion = data.getUserData(NeoForgeVersionChainStep.NEOGRADLE_VERSION_KEY) ?: return
         val modId = data.getUserData(AbstractModIdStep.KEY) ?: return
         val modName = data.getUserData(AbstractModNameStep.KEY) ?: return
         val buildSystemProps = findStep<BuildSystemPropertiesStep<*>>()
@@ -95,6 +96,7 @@ class NeoForgeGradleFilesStep(parent: NewProjectWizardStep) : AbstractLongRunnin
             "MC_NEXT_VERSION" to mcNextVersion,
             "NEOFORGE_VERSION" to neoforgeVersion,
             "NEOFORGE_SPEC_VERSION" to neoforgeVersion.parts[0].versionString,
+            "NEOGRADLE_VERSION" to neogradleVersion,
             "GROUP_ID" to buildSystemProps.groupId,
             "ARTIFACT_ID" to buildSystemProps.artifactId,
             "MOD_VERSION" to buildSystemProps.version,

src/main/kotlin/platform/neoforge/creator/ui-steps.kt

@@ -36,6 +36,7 @@ import com.demonwav.mcdev.creator.step.UpdateUrlStep
 import com.demonwav.mcdev.creator.step.UseMixinsStep
 import com.demonwav.mcdev.creator.step.WebsiteStep
 import com.demonwav.mcdev.platform.neoforge.version.NeoForgeVersion
+import com.demonwav.mcdev.platform.neoforge.version.NeoGradleVersion
 import com.demonwav.mcdev.util.MinecraftVersions
 import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.asyncIO
@@ -47,25 +48,31 @@ import kotlinx.coroutines.coroutineScope
 
 private val minSupportedMcVersion = MinecraftVersions.MC1_20_2
 
-class NeoForgePlatformStep(parent: ModPlatformStep) : AbstractLatentStep<NeoForgeVersion>(parent) {
+class NeoForgePlatformStep(parent: ModPlatformStep) :
+    AbstractLatentStep<Pair<NeoForgeVersion, NeoGradleVersion>>(parent) {
     override val description = "fetch NeoForge versions"
 
     override suspend fun computeData() = coroutineScope {
-        asyncIO { NeoForgeVersion.downloadData() }.await()
+        val neoforgeJob = asyncIO { NeoForgeVersion.downloadData() }
+        val neogradleJob = asyncIO { NeoGradleVersion.downloadData() }
+        val neoforge = neoforgeJob.await() ?: return@coroutineScope null
+        val neogradle = neogradleJob.await() ?: return@coroutineScope null
+        neoforge to neogradle
     }
 
-    override fun createStep(data: NeoForgeVersion) = NeoForgeVersionChainStep(this, data)
-        .nextStep(::ForgeStyleModIdStep)
-        .nextStep(::ModNameStep)
-        .nextStep(::MainClassStep)
-        .nextStep(::UseMixinsStep)
-        .nextStep(::LicenseStep)
-        .nextStep(::NeoForgeOptionalSettingsStep)
-        .nextStep(::NeoForgeBuildSystemStep)
-        .nextStep(::NeoForgeProjectFilesStep)
-        .nextStep(::NeoForgeMixinsJsonStep)
-        .nextStep(::NeoForgePostBuildSystemStep)
-        .nextStep(::NeoForgeReformatPackDescriptorStep)
+    override fun createStep(data: Pair<NeoForgeVersion, NeoGradleVersion>): NewProjectWizardStep =
+        NeoForgeVersionChainStep(this, data.first, data.second)
+            .nextStep(::ForgeStyleModIdStep)
+            .nextStep(::ModNameStep)
+            .nextStep(::MainClassStep)
+            .nextStep(::UseMixinsStep)
+            .nextStep(::LicenseStep)
+            .nextStep(::NeoForgeOptionalSettingsStep)
+            .nextStep(::NeoForgeBuildSystemStep)
+            .nextStep(::NeoForgeProjectFilesStep)
+            .nextStep(::NeoForgeMixinsJsonStep)
+            .nextStep(::NeoForgePostBuildSystemStep)
+            .nextStep(::NeoForgeReformatPackDescriptorStep)
 
     class Factory : ModPlatformStep.Factory {
         override val name = "NeoForge"
@@ -76,20 +83,26 @@ class NeoForgePlatformStep(parent: ModPlatformStep) : AbstractLatentStep<NeoForg
 class NeoForgeVersionChainStep(
     parent: NewProjectWizardStep,
     private val neoforgeVersionData: NeoForgeVersion,
-) : AbstractMcVersionChainStep(parent, "NeoForge Version:") {
+    private val neogradleVersionData: NeoGradleVersion,
+) : AbstractMcVersionChainStep(parent, "NeoForge Version:", "NeoGradle Version:") {
     companion object {
         private const val NEOFORGE_VERSION = 1
+        private const val NEOGRADLE_VERSION = 2
 
         val MC_VERSION_KEY = Key.create<SemanticVersion>("${NeoForgeVersionChainStep::class.java}.mcVersion")
         val NEOFORGE_VERSION_KEY =
             Key.create<SemanticVersion>("${NeoForgeVersionChainStep::class.java}.neoforgeVersion")
+        val NEOGRADLE_VERSION_KEY =
+            Key.create<SemanticVersion>("${NeoForgeVersionChainStep::class.java}.neogradleVersion")
     }
 
     override fun getAvailableVersions(versionsAbove: List<Comparable<*>>): List<Comparable<*>> {
         return when (versionsAbove.size) {
             MINECRAFT_VERSION -> neoforgeVersionData.sortedMcVersions.filter { it >= minSupportedMcVersion }
             NEOFORGE_VERSION ->
                 neoforgeVersionData.getNeoForgeVersions(versionsAbove[MINECRAFT_VERSION] as SemanticVersion)
+
+            NEOGRADLE_VERSION -> neogradleVersionData.versions
             else -> throw IncorrectOperationException()
         }
     }
@@ -98,6 +111,7 @@ class NeoForgeVersionChainStep(
         super.setupProject(project)
         data.putUserData(MC_VERSION_KEY, getVersion(MINECRAFT_VERSION) as SemanticVersion)
         data.putUserData(NEOFORGE_VERSION_KEY, getVersion(NEOFORGE_VERSION) as SemanticVersion)
+        data.putUserData(NEOGRADLE_VERSION_KEY, getVersion(NEOGRADLE_VERSION) as SemanticVersion)
     }
 }
 

src/main/kotlin/platform/neoforge/version/NeoGradleVersion.kt

@@ -0,0 +1,48 @@
+/*
+ * Minecraft Development for IntelliJ
+ *
+ * https://mcdev.io/
+ *
+ * Copyright (C) 2024 minecraft-dev
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, version 3.0 only.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.demonwav.mcdev.platform.neoforge.version
+
+import com.demonwav.mcdev.creator.collectMavenVersions
+import com.demonwav.mcdev.util.SemanticVersion
+import com.intellij.openapi.diagnostic.logger
+import java.io.IOException
+
+class NeoGradleVersion private constructor(val versions: List<SemanticVersion>) {
+
+    companion object {
+        private val LOGGER = logger<NeoGradleVersion>()
+
+        suspend fun downloadData(): NeoGradleVersion? {
+            try {
+                val url = "https://maven.neoforged.net/releases/net/neoforged/gradle/userdev/maven-metadata.xml"
+                val versions = collectMavenVersions(url)
+                    .asSequence()
+                    .mapNotNull(SemanticVersion.Companion::tryParse)
+                    .sortedDescending()
+                    .toList()
+                return NeoGradleVersion(versions)
+            } catch (e: IOException) {
+                LOGGER.error("Failed to retrieve NeoForge version data", e)
+            }
+            return null
+        }
+    }
+}

src/main/resources/fileTemplates/j2ee/neoforge/NeoForge build.gradle.ft

@@ -3,7 +3,7 @@ plugins {
     id 'eclipse'
     id 'idea'
     id 'maven-publish'
-    id 'net.neoforged.gradle.userdev' version '7.0.97'
+    id 'net.neoforged.gradle.userdev' version '${NEOGRADLE_VERSION}'
 }
 
 version = mod_version