Add Fabric 26.1+ class templates (Mojmap)

src/main/kotlin/insight/generation/MinecraftClassCreateAction.kt

@@ -49,6 +49,7 @@ import com.intellij.psi.PsiNameHelper
 import com.intellij.psi.util.PsiTypesUtil
 import com.intellij.psi.util.PsiUtil
 import org.jetbrains.jps.model.java.JavaModuleSourceRootTypes
+import com.intellij.openapi.diagnostic.Logger
 
 class MinecraftClassCreateAction :
     CreateTemplateInPackageAction<PsiClass>(
@@ -58,6 +59,9 @@ class MinecraftClassCreateAction :
         JavaModuleSourceRootTypes.SOURCES,
     ),
     DumbAware {
+    companion object {
+        val LOG = Logger.getInstance(MinecraftClassCreateAction::class.java)
+    }
 
     override fun getActionName(directory: PsiDirectory?, newName: String, templateName: String?): String = Const.CAPTION
 
@@ -69,48 +73,61 @@ class MinecraftClassCreateAction :
         val isForge = MinecraftFacet.getInstance(module, ForgeModuleType) != null
         val isNeoForge = MinecraftFacet.getInstance(module, NeoForgeModuleType) != null
         val isFabric = MinecraftFacet.getInstance(module, FabricModuleType) != null
-        val mcVersion = MinecraftFacet.getInstance(module, McpModuleType)?.getSettings()
+        val forgeMcVersion = MinecraftFacet.getInstance(module, McpModuleType)?.getSettings()
             ?.minecraftVersion?.let(SemanticVersion::parse)
-
-        if (isForge && mcVersion != null) {
+        val fabricMcVersion =
+            MinecraftFacet.getInstance(module, FabricModuleType)?.computeVersion()
+        val neoforgeMcVersion = MinecraftFacet.getInstance(module, NeoForgeModuleType)?.computeVersion()
+        LOG.info("VERSIONI: $neoforgeMcVersion, $forgeMcVersion, $fabricMcVersion")
+        if (isForge && forgeMcVersion != null) {
             val icon = PlatformAssets.FORGE_ICON
 
-            if (mcVersion < MinecraftVersions.MC1_17) {
+            if (forgeMcVersion < MinecraftVersions.MC1_17) {
                 builder.addKind("Block", icon, MinecraftTemplates.FORGE_BLOCK_TEMPLATE)
                 builder.addKind("Enchantment", icon, MinecraftTemplates.FORGE_ENCHANTMENT_TEMPLATE)
                 builder.addKind("Item", icon, MinecraftTemplates.FORGE_ITEM_TEMPLATE)
                 builder.addKind("Packet", icon, MinecraftTemplates.FORGE_PACKET_TEMPLATE)
-            } else if (mcVersion < MinecraftVersions.MC1_18) {
+            } else if (forgeMcVersion < MinecraftVersions.MC1_18) {
                 builder.addKind("Block", icon, MinecraftTemplates.FORGE_1_17_BLOCK_TEMPLATE)
                 builder.addKind("Enchantment", icon, MinecraftTemplates.FORGE_1_17_ENCHANTMENT_TEMPLATE)
                 builder.addKind("Item", icon, MinecraftTemplates.FORGE_1_17_ITEM_TEMPLATE)
                 builder.addKind("Mob effect", icon, MinecraftTemplates.FORGE_1_17_MOB_EFFECT_TEMPLATE)
                 builder.addKind("Packet", icon, MinecraftTemplates.FORGE_1_17_PACKET_TEMPLATE)
             } else {
                 builder.addKind("Block", icon, MinecraftTemplates.FORGE_1_17_BLOCK_TEMPLATE)
-                builder.addKind("Enchantment", icon, MinecraftTemplates.FORGE_1_17_ENCHANTMENT_TEMPLATE)
                 builder.addKind("Item", icon, MinecraftTemplates.FORGE_1_17_ITEM_TEMPLATE)
                 builder.addKind("Mob effect", icon, MinecraftTemplates.FORGE_1_17_MOB_EFFECT_TEMPLATE)
                 builder.addKind("Packet", icon, MinecraftTemplates.FORGE_1_18_PACKET_TEMPLATE)
             }
+            if (forgeMcVersion < MinecraftVersions.MC1_21) {
+                builder.addKind("Enchantment", icon, MinecraftTemplates.FORGE_1_17_ENCHANTMENT_TEMPLATE)
+            }
         }
 
         if (isNeoForge) {
             val icon = PlatformAssets.NEOFORGE_ICON
             builder.addKind("Block", icon, MinecraftTemplates.NEOFORGE_BLOCK_TEMPLATE)
-            builder.addKind("Enchantment", icon, MinecraftTemplates.NEOFORGE_ENCHANTMENT_TEMPLATE)
             builder.addKind("Item", icon, MinecraftTemplates.NEOFORGE_ITEM_TEMPLATE)
             builder.addKind("Mob effect", icon, MinecraftTemplates.NEOFORGE_MOB_EFFECT_TEMPLATE)
             builder.addKind("Packet", icon, MinecraftTemplates.NEOFORGE_PACKET_TEMPLATE)
+            if (neoforgeMcVersion == null || neoforgeMcVersion < MinecraftVersions.MC1_21)
+                builder.addKind("Enchantment", icon, MinecraftTemplates.NEOFORGE_ENCHANTMENT_TEMPLATE)
         }
 
         if (isFabric) {
             val icon = PlatformAssets.FABRIC_ICON
+            if (fabricMcVersion != null && fabricMcVersion >= MinecraftVersions.MC26_1) {
+                builder.addKind("Block", icon, MinecraftTemplates.FABRIC_26_1_BLOCK_TEMPLATE)
+                builder.addKind("Item", icon, MinecraftTemplates.FABRIC_26_1_ITEM_TEMPLATE)
+                builder.addKind("Mob effect", icon, MinecraftTemplates.FABRIC_26_1_MOB_EFFECT_TEMPLATE)
 
-            builder.addKind("Block", icon, MinecraftTemplates.FABRIC_BLOCK_TEMPLATE)
-            builder.addKind("Enchantment", icon, MinecraftTemplates.FABRIC_ENCHANTMENT_TEMPLATE)
-            builder.addKind("Item", icon, MinecraftTemplates.FABRIC_ITEM_TEMPLATE)
-            builder.addKind("Status effect", icon, MinecraftTemplates.FABRIC_STATUS_EFFECT_TEMPLATE)
+            } else {
+                builder.addKind("Block", icon, MinecraftTemplates.FABRIC_1_21_11_BLOCK_TEMPLATE)
+                builder.addKind("Item", icon, MinecraftTemplates.FABRIC_1_21_11_ITEM_TEMPLATE)
+                builder.addKind("Status effect", icon, MinecraftTemplates.FABRIC_1_21_11_STATUS_EFFECT_TEMPLATE)
+            }
+            if (fabricMcVersion != null && fabricMcVersion < MinecraftVersions.MC1_21)
+                builder.addKind("Enchantment", icon, MinecraftTemplates.FABRIC_1_21_11_ENCHANTMENT_TEMPLATE)
         }
     }
 

src/main/kotlin/platform/AbstractModule.kt

@@ -24,10 +24,12 @@ import com.demonwav.mcdev.facet.MinecraftFacet
 import com.demonwav.mcdev.insight.generation.EventListenerGenerationSupport
 import com.demonwav.mcdev.inspection.IsCancelled
 import com.intellij.openapi.module.Module
+import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.util.Key
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiExpression
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiMethodCallExpression
 import com.intellij.psi.PsiReferenceExpression
@@ -36,6 +38,9 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import javax.swing.Icon
+import com.intellij.lang.properties.psi.PropertiesFile
+import com.demonwav.mcdev.insight.generation.MinecraftClassCreateAction.Companion.LOG
+
 
 abstract class AbstractModule(protected val facet: MinecraftFacet) {
 
@@ -107,4 +112,21 @@ abstract class AbstractModule(protected val facet: MinecraftFacet) {
     open fun init() {}
     open fun dispose() {}
     open fun refresh() {}
+
+    fun detectMinecraftVersionInProps(keyname: String): String? {
+        val contentRoots = ModuleRootManager.getInstance(module).contentRoots
+        var dir = contentRoots.firstOrNull() ?: return null
+
+        val projectBase = project.basePath
+        while (true) {
+            val found = dir.findChild("gradle.properties")
+            if (found != null) {
+                val propsFile = PsiManager.getInstance(project).findFile(found) as? PropertiesFile ?: return null
+                return propsFile.findPropertyByKey(keyname)?.value
+            }
+            val parent = dir.parent ?: return null
+            if (dir.path == projectBase) return null
+            dir = parent
+        }
+    }
 }

src/main/kotlin/platform/fabric/FabricModule.kt

@@ -22,6 +22,7 @@ package com.demonwav.mcdev.platform.fabric
 
 import com.demonwav.mcdev.asset.PlatformAssets
 import com.demonwav.mcdev.facet.MinecraftFacet
+import com.demonwav.mcdev.insight.generation.MinecraftClassCreateAction
 import com.demonwav.mcdev.platform.AbstractModule
 import com.demonwav.mcdev.platform.PlatformType
 import com.demonwav.mcdev.platform.fabric.reference.EntryPointReference
@@ -30,11 +31,14 @@ import com.demonwav.mcdev.platform.mcp.fabricloom.FabricLoomData
 import com.demonwav.mcdev.platform.mcp.mappings.HardcodedYarnToMojmap
 import com.demonwav.mcdev.platform.mcp.mappings.HasCustomNamedMappings
 import com.demonwav.mcdev.platform.mcp.mappings.MappingsManager
+import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.SourceType
 import com.demonwav.mcdev.util.nullable
 import com.demonwav.mcdev.util.runCatchingKtIdeaExceptions
 import com.intellij.json.JsonUtil
+import com.intellij.json.psi.JsonArray
 import com.intellij.json.psi.JsonFile
+import com.intellij.json.psi.JsonObject
 import com.intellij.json.psi.JsonStringLiteral
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
@@ -50,6 +54,7 @@ import org.jetbrains.uast.UClass
 import org.jetbrains.uast.UIdentifier
 import org.jetbrains.uast.UMethod
 import org.jetbrains.uast.toUElementOfType
+import com.demonwav.mcdev.insight.generation.MinecraftClassCreateAction.Companion.LOG
 
 class FabricModule internal constructor(facet: MinecraftFacet) : AbstractModule(facet), HasCustomNamedMappings {
 
@@ -67,6 +72,7 @@ class FabricModule internal constructor(facet: MinecraftFacet) : AbstractModule(
     override val moduleType = FabricModuleType
     override val type = PlatformType.FABRIC
     override val icon = PlatformAssets.FABRIC_ICON
+    var fabricMinecraftVersion: SemanticVersion? = null;
 
     override fun computeModIds(): List<String> {
         val jsonFile = PsiManager.getInstance(project).findFile(fabricJson ?: return emptyList()) as? JsonFile
@@ -75,6 +81,53 @@ class FabricModule internal constructor(facet: MinecraftFacet) : AbstractModule(
         return listOfNotNull((jsonObj.findProperty("id")?.value as? JsonStringLiteral)?.value)
     }
 
+    fun computeVersion(): SemanticVersion? {
+        val jsonFile = PsiManager.getInstance(project).findFile(fabricJson ?: return null) as? JsonFile
+            ?: return null
+        val jsonObj = JsonUtil.getTopLevelObject(jsonFile) ?: return null;
+        val depends = jsonObj.findProperty("depends")?.value as? JsonObject
+        val range = depends?.findProperty("minecraft")
+        var value = (range?.value as? JsonStringLiteral)?.value;
+        val arrayValue = (range?.value as? JsonArray)
+        if (value != null) {
+            if (value.contains("\${")) {
+                val varName = value.substring(value.indexOf("\${") + 2, value.lastIndexOf("}"))
+                value = value.replace("\${${varName}}", detectMinecraftVersionInProps(varName) ?: return null)
+            }
+            val end = value.trimStart { !it.isDigit() }
+            val parse = try {
+                SemanticVersion.parse(end)
+            } catch (_: NumberFormatException) {
+                null
+            }
+            fabricMinecraftVersion = parse
+            return parse
+        } else if (arrayValue != null) {
+            var majorVersion: SemanticVersion? = null;
+            for (child in arrayValue.valueList) {
+                var string = (child as? JsonStringLiteral)?.value.toString()
+                if (string.contains("\${")) {
+                    val varName = string.substring(string.indexOf("\${") + 2, string.lastIndexOf("}"))
+                    string = string.replace("\${${varName}}", detectMinecraftVersionInProps(varName) ?: return null)
+                }
+                LOG.info("Stringa Array: $string")
+                val end = string.trimStart { !it.isDigit() }
+                val value = try {
+                    SemanticVersion.parse(end)
+                } catch (_: NumberFormatException) {
+                    null
+                }
+                LOG.info("Valuta array:$value")
+                if (value != null) {
+                    if (majorVersion == null || value > majorVersion) majorVersion = value
+                };
+            }
+            fabricMinecraftVersion = majorVersion
+            return majorVersion
+        }
+        return null
+    }
+
     override fun isEventClassValid(eventClass: PsiClass, method: PsiMethod?) = true
 
     override fun writeErrorMessageForEventParameter(eventClass: PsiClass, method: PsiMethod) = ""
@@ -105,8 +158,10 @@ class FabricModule internal constructor(facet: MinecraftFacet) : AbstractModule(
         mappingNamespacesField = mappingDetection.namespaces
     }
 
-    private fun detectMappings(): MappingDetectionResult {
+    private fun
+        detectMappings(): MappingDetectionResult {
         val gradleData = GradleUtil.findGradleModuleData(facet.module) ?: return MappingDetectionResult.DEFAULT
+
         val loomData = gradleData.children.find { it.key == FabricLoomData.KEY }?.data as? FabricLoomData
             ?: return MappingDetectionResult.DEFAULT
         val mappingsFile = loomData.tinyMappings ?: return MappingDetectionResult.DEFAULT
@@ -147,7 +202,8 @@ class FabricModule internal constructor(facet: MinecraftFacet) : AbstractModule(
 
         override fun visitMethodArg(argPosition: Int, lvIndex: Int, srcName: String?) = false
 
-        override fun visitMethodVar(lvtRowIndex: Int, lvIndex: Int, startOpIdx: Int, endOpIdx: Int, srcName: String?) = false
+        override fun visitMethodVar(lvtRowIndex: Int, lvIndex: Int, startOpIdx: Int, endOpIdx: Int, srcName: String?) =
+            false
 
         override fun visitDstName(targetKind: MappedElementKind?, namespace: Int, name: String) {
             if (namespace == namedIndex && name == "net/minecraft/client/MinecraftClient") {

src/main/kotlin/platform/neoforge/NeoForgeModule.kt

@@ -28,22 +28,30 @@ import com.demonwav.mcdev.platform.AbstractModule
 import com.demonwav.mcdev.platform.PlatformType
 import com.demonwav.mcdev.platform.forge.ForgeModule
 import com.demonwav.mcdev.platform.neoforge.util.NeoForgeConstants
+import com.demonwav.mcdev.toml.stringValue
+import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.SourceType
 import com.demonwav.mcdev.util.nullable
 import com.demonwav.mcdev.util.runCatchingKtIdeaExceptions
 import com.demonwav.mcdev.util.runWriteTaskLater
 import com.demonwav.mcdev.util.waitForAllSmart
 import com.intellij.json.JsonFileType
 import com.intellij.lang.jvm.JvmModifier
+import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.fileTypes.FileTypeManager
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiMethodCallExpression
+import org.jetbrains.kotlin.util.removeSuffixIfPresent
 import org.jetbrains.uast.UClass
 import org.jetbrains.uast.UIdentifier
 import org.jetbrains.uast.toUElementOfType
+import org.toml.lang.psi.TomlArrayTable
+import org.toml.lang.psi.TomlFile
+import org.toml.lang.psi.ext.name
 
 class NeoForgeModule internal constructor(facet: MinecraftFacet) : AbstractModule(facet) {
 
@@ -57,7 +65,39 @@ class NeoForgeModule internal constructor(facet: MinecraftFacet) : AbstractModul
     override val icon = PlatformAssets.NEOFORGE_ICON
 
     override fun computeModIds() = ForgeModule.getModsFromModsToml(project, modsToml)
-
+    fun computeVersion(): SemanticVersion? {
+        val tomlFile = PsiManager.getInstance(project).findFile(modsToml ?: return null) as? TomlFile
+            ?: return null
+
+        for (child in tomlFile.children) {
+            if (child is TomlArrayTable && child.header.key?.name == "dependencies."+ computeModIds()[0]) {
+                var founded = false
+                for (entry in child.entries) {
+                    if (entry.key.name == computeModIds()[0]) {
+                        founded = true
+                    }
+                }
+                if(!founded) continue
+                else{
+                    for (entry in child.entries) {
+                        if (entry.key.name == "versionRange") {
+                            val value = entry.value.toString()
+                            var valueParsed = value;
+                            if(value.contains("\${")) {
+                                    val varName = value.substring(value.indexOf("\${")+2, value.lastIndexOf("}"))
+                                    valueParsed = value.replace("\${${varName}}", detectMinecraftVersionInProps(varName)?: return null)
+                            }
+                            return SemanticVersion.parse(valueParsed.trim()
+                                .removeSuffixIfPresent(")")
+                                .removeSuffixIfPresent("]")
+                                .substringAfter(","))
+                        }
+                    }
+                }
+            }
+        }
+        return null
+    }
     override val eventListenerGenSupport: EventListenerGenerationSupport = NeoForgeEventListenerGenerationSupport()
 
     override fun init() {

src/main/kotlin/util/MinecraftTemplates.kt

@@ -161,10 +161,15 @@ class MinecraftTemplates : FileTemplateGroupDescriptorFactory {
             }
             FileTemplateGroupDescriptor("Fabric", PlatformAssets.FABRIC_ICON).let { fabricSkeletonGroup ->
                 skeletonGroup.addTemplate(fabricSkeletonGroup)
-                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_BLOCK_TEMPLATE))
-                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_ITEM_TEMPLATE))
-                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_ENCHANTMENT_TEMPLATE))
-                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_STATUS_EFFECT_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_1_21_11_BLOCK_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_1_21_11_ITEM_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_1_21_11_ENCHANTMENT_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_1_21_11_STATUS_EFFECT_TEMPLATE))
+
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_26_1_BLOCK_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_26_1_ITEM_TEMPLATE))
+                fabricSkeletonGroup.addTemplate(FileTemplateDescriptor(FABRIC_26_1_MOB_EFFECT_TEMPLATE))
+
             }
         }
 
@@ -268,10 +273,14 @@ class MinecraftTemplates : FileTemplateGroupDescriptorFactory {
 
         const val FORGE_1_18_PACKET_TEMPLATE = "ForgePacket (1.18+).java"
 
-        const val FABRIC_BLOCK_TEMPLATE = "FabricBlock.java"
-        const val FABRIC_ITEM_TEMPLATE = "FabricItem.java"
-        const val FABRIC_ENCHANTMENT_TEMPLATE = "FabricEnchantment.java"
-        const val FABRIC_STATUS_EFFECT_TEMPLATE = "FabricStatusEffect.java"
+        const val FABRIC_1_21_11_BLOCK_TEMPLATE = "FabricBlock (1.21.11-).java"
+        const val FABRIC_1_21_11_ITEM_TEMPLATE = "FabricItem (1.21.11-).java"
+        const val FABRIC_1_21_11_ENCHANTMENT_TEMPLATE = "FabricEnchantment (1.21.11-).java"
+        const val FABRIC_1_21_11_STATUS_EFFECT_TEMPLATE = "FabricStatusEffect (1.21.11-).java"
+
+        const val FABRIC_26_1_BLOCK_TEMPLATE = "FabricBlock (26.1+).java"
+        const val FABRIC_26_1_ITEM_TEMPLATE = "FabricItem (26.1+).java"
+        const val FABRIC_26_1_MOB_EFFECT_TEMPLATE = "FabricMobEffect (26.1+).java"
 
         const val NEOFORGE_MIXINS_JSON_TEMPLATE = "NeoForge Mixins Config.json"
         const val NEOFORGE_MAIN_CLASS_TEMPLATE = "NeoForge Main Class.java"

src/main/kotlin/util/MinecraftVersions.kt

@@ -48,6 +48,7 @@ object MinecraftVersions {
     val MC1_21_1 = SemanticVersion.release(1, 21, 1)
     val MC1_21_11 = SemanticVersion.release(1, 21, 11)
     val MC26_1 = SemanticVersion.release(26, 1)
+    val MC26_2 = SemanticVersion.release(26, 2)
 
     fun requiredJavaVersion(minecraftVersion: SemanticVersion) = when {
         minecraftVersion <= MC1_16_5 -> JavaSdkVersion.JDK_1_8