Restructure SemanticVersion and make it more fool-proof

Author: marvin-roesch

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

@@ -19,7 +19,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import java.util.Properties
 
 object ForgeTemplate {
-    private val MC_1_12 = SemanticVersion("1.12")
+    private val MC_1_12 = SemanticVersion.parse("1.12")
 
     fun applyBuildGradleTemplate(project: Project,
                                  file: VirtualFile,
@@ -35,7 +35,7 @@ object ForgeTemplate {
             properties.setProperty("SPONGE_FORGE", "true")
         }
         // Fixes builds for MC1.12+, requires FG 2.3
-        val mcVersion = SemanticVersion(configuration.mcVersion)
+        val mcVersion = SemanticVersion.parse(configuration.mcVersion)
         if (mcVersion >= MC_1_12) {
             properties.setProperty("FORGEGRADLE_VERSION", "2.3")
         } else {

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

@@ -24,16 +24,16 @@ class ForgeVersion private constructor(private val map: Map<*, *>) {
     }
 
     fun getRecommended(versions: List<String>): String {
-        var recommended = SemanticVersion("1.7")
+        var recommended = SemanticVersion.parse("1.7")
         for (version in versions) {
             getPromo(version) ?: continue
-            val semantic = SemanticVersion(version)
+            val semantic = SemanticVersion.parse(version)
             if (recommended < semantic) {
                 recommended = semantic
             }
         }
 
-        return recommended.value
+        return recommended.toString()
     }
 
     fun getPromo(version: String): Double? {

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

@@ -13,18 +13,18 @@ package com.demonwav.mcdev.util
 import com.demonwav.mcdev.util.SemanticVersion.Companion.VersionPart.PreReleasePart
 import com.demonwav.mcdev.util.SemanticVersion.Companion.VersionPart.ReleasePart
 
-class SemanticVersion(val value: String) : Comparable<SemanticVersion> {
-    val parts = value.split(".").map {
-        if (it.contains("_pre")) {
-            val subParts = it.split("_pre")
-            PreReleasePart(subParts[0].toInt(), subParts[1].toInt())
-        } else {
-            ReleasePart(it.toInt())
-        }
-    }
-
+/**
+ * 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> {
     override fun compareTo(other: SemanticVersion): Int {
-        val result = parts.zip(other.parts).fold(0, { acc, (a, b) -> if (acc == -1) acc else a.compareTo(b) })
+        // 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
         }
@@ -37,18 +37,48 @@ class SemanticVersion(val value: String) : Comparable<SemanticVersion> {
             else -> false
         }
 
-    override fun hashCode(): Int {
-        return parts.hashCode()
-    }
+    override fun hashCode() = parts.hashCode()
+
+    override fun toString() = parts.map { it.toString() }.joinToString(".")
 
     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> {
             data class ReleasePart(val version: Int) : VersionPart() {
                 override fun compareTo(other: VersionPart) =
                     when (other) {
                         is PreReleasePart -> if (version != other.version) version - other.version else 1
                         is ReleasePart -> version - other.version
                     }
+
+                override fun toString() = version.toString()
             }
 
             data class PreReleasePart(val version: Int, val pre: Int) : VersionPart() {
@@ -57,6 +87,8 @@ class SemanticVersion(val value: String) : Comparable<SemanticVersion> {
                         is PreReleasePart -> if (version != other.version) version - other.version else pre - other.pre
                         is ReleasePart -> if (version != other.version) version - other.version else -1
                     }
+
+                override fun toString() = "${version}_pre$pre"
             }
         }
     }