Merge pull request #272 from PaleoCrafter/fix/forge-project-template

Fix Forge project generation for MC1.12+ and enhance Minecraft version selection

Author: DenWav

src/main/kotlin/com/demonwav/mcdev/creator/ForgeProjectSettingsWizard.kt

@@ -201,6 +201,7 @@ class ForgeProjectSettingsWizard(private val creator: MinecraftProjectCreator) :
         if (fullVersion != null) {
             settings!!.forgeVersion = fullVersion
         }
+        settings!!.mcVersion = minecraftVersionBox.selectedItem as String
     }
 
     fun error() {

src/main/kotlin/com/demonwav/mcdev/platform/forge/ForgeProjectConfiguration.kt

@@ -27,6 +27,7 @@ open class ForgeProjectConfiguration : ProjectConfiguration() {
 
     var mcpVersion: String = ""
     var forgeVersion: String = ""
+    var mcVersion: String = ""
 
     init {
         type = PlatformType.FORGE

src/main/kotlin/com/demonwav/mcdev/platform/forge/ForgeTemplate.kt

@@ -13,11 +13,13 @@ package com.demonwav.mcdev.platform.forge
 import com.demonwav.mcdev.platform.BaseTemplate
 import com.demonwav.mcdev.platform.hybrid.SpongeForgeProjectConfiguration
 import com.demonwav.mcdev.util.MinecraftFileTemplateGroupFactory
+import com.demonwav.mcdev.util.SemanticVersion
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import java.util.Properties
 
 object ForgeTemplate {
+    private val MC_1_12 = SemanticVersion.parse("1.12")
 
     fun applyBuildGradleTemplate(project: Project,
                                  file: VirtualFile,
@@ -32,6 +34,13 @@ object ForgeTemplate {
         if (configuration is SpongeForgeProjectConfiguration) {
             properties.setProperty("SPONGE_FORGE", "true")
         }
+        // Fixes builds for MC1.12+, requires FG 2.3
+        val mcVersion = SemanticVersion.parse(configuration.mcVersion)
+        if (mcVersion >= MC_1_12) {
+            properties.setProperty("FORGEGRADLE_VERSION", "2.3")
+        } else {
+            properties.setProperty("FORGEGRADLE_VERSION", "2.2")
+        }
 
         BaseTemplate.applyTemplate(project, file, MinecraftFileTemplateGroupFactory.FORGE_BUILD_GRADLE_TEMPLATE, properties)
 

src/main/kotlin/com/demonwav/mcdev/platform/forge/version/ForgeVersion.kt

@@ -11,6 +11,7 @@
 package com.demonwav.mcdev.platform.forge.version
 
 import com.demonwav.mcdev.util.gson
+import com.demonwav.mcdev.util.SemanticVersion
 import com.demonwav.mcdev.util.sortVersions
 import java.io.IOException
 import java.net.URL
@@ -23,16 +24,16 @@ class ForgeVersion private constructor(private val map: Map<*, *>) {
     }
 
     fun getRecommended(versions: List<String>): String {
-        var recommended = "1.7"
+        var recommended = SemanticVersion.parse("1.7")
         for (version in versions) {
             getPromo(version) ?: continue
-
-            if (recommended < version) {
-                recommended = version
+            val semantic = SemanticVersion.parse(version)
+            if (recommended < semantic) {
+                recommended = semantic
             }
         }
 
-        return recommended
+        return recommended.versionString
     }
 
     fun getPromo(version: String): Double? {

src/main/kotlin/com/demonwav/mcdev/util/SemanticVersion.kt

@@ -0,0 +1,97 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.util
+
+import com.demonwav.mcdev.util.SemanticVersion.Companion.VersionPart.PreReleasePart
+import com.demonwav.mcdev.util.SemanticVersion.Companion.VersionPart.ReleasePart
+
+/**
+ * Represents a comparable and generalised "semantic version".
+ * Each constituent part (delimited by periods in a version string) contributes
+ * to the version ranking with decreasing priority from left to right.
+ */
+class SemanticVersion(val parts: List<VersionPart>) : Comparable<SemanticVersion> {
+    val versionString = parts.map { it.versionString }.joinToString(".");
+
+    override fun compareTo(other: SemanticVersion): Int {
+        // Zipping limits the compared parts to the shorter version, then we perform a component-wise comparison
+        // Short-circuits if any component of this version is smaller/older
+        val result = parts.zip(other.parts).fold(0) { acc, (a, b) -> if (acc == -1) acc else a.compareTo(b) }
+        // When all the parts are equal, the longer version wins
+        // Generally speaking, 1.0 is considered older than 1.0.1 (see MC 1.12 vs 1.12.1)
+        if (parts.size != other.parts.size && result == 0) {
+            return parts.size - other.parts.size
+        }
+        return result
+    }
+
+    override fun equals(other: Any?) =
+        when (other) {
+            is SemanticVersion -> parts.size == other.parts.size && parts.zip(other.parts).all { (a, b) -> a == b }
+            else -> false
+        }
+
+    override fun hashCode() = parts.hashCode()
+
+    companion object {
+        /**
+         * Parses a version string into a comparable representation.
+         * @throws IllegalArgumentException if any part of the version string cannot be parsed as integer or split into pre-release parts.
+         */
+        fun parse(value: String): SemanticVersion {
+            fun parseInt(part: String): Int =
+                if (part.all { it.isDigit() })
+                    part.toInt()
+                else
+                    throw IllegalArgumentException("Failed to parse version part as integer: $part")
+
+            val parts = value.split('.').map {
+                if (it.contains("_pre")) {
+                    // There have been cases of Forge builds for MC pre-releases (1.7.10_pre4)
+                    // We're consuming the 10_pre4 and extracting 10 and 4 from it
+                    val subParts = it.split("_pre")
+                    if (subParts.size == 2) {
+                        PreReleasePart(parseInt(subParts[0]), parseInt(subParts[1]))
+                    } else {
+                        throw IllegalArgumentException("Failed to split pre-release version part into two numbers: $it")
+                    }
+                } else {
+                    ReleasePart(parseInt(it))
+                }
+            }
+            return SemanticVersion(parts)
+        }
+
+        sealed class VersionPart : Comparable<VersionPart> {
+            abstract val versionString: String
+
+            data class ReleasePart(val version: Int) : VersionPart() {
+                override val versionString = version.toString()
+
+                override fun compareTo(other: VersionPart) =
+                    when (other) {
+                        is PreReleasePart -> if (version != other.version) version - other.version else 1
+                        is ReleasePart -> version - other.version
+                    }
+            }
+
+            data class PreReleasePart(val version: Int, val pre: Int) : VersionPart() {
+                override val versionString = "${version}_pre$pre"
+
+                override fun compareTo(other: VersionPart) =
+                    when (other) {
+                        is PreReleasePart -> if (version != other.version) version - other.version else pre - other.pre
+                        is ReleasePart -> if (version != other.version) version - other.version else -1
+                    }
+            }
+        }
+    }
+}

src/main/resources/fileTemplates/j2ee/forge_build.gradle.ft

@@ -12,7 +12,7 @@ buildscript {
 #end
     }
     dependencies {
-        classpath "net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT"
+        classpath "net.minecraftforge.gradle:ForgeGradle:${FORGEGRADLE_VERSION}-SNAPSHOT"
 #if (${SPONGE_FORGE})
         classpath "gradle.plugin.org.spongepowered:spongegradle:0.8.1"
 #end