Added string-sorting support

Author: cmaglie

version.go

@@ -416,3 +416,77 @@ func (v *Version) CompatibleWith(u *Version) bool {
 	}
 	return compareNumber(vPatch, uPatch) == 0
 }
+
+// SortableString returns the version encoded as a string that when compared
+// with alphanumeric ordering it respects the original semver ordering:
+//
+//	(v1.SortableString() < v2.SortableString()) == v1.LessThan(v2)
+//	cmp.Compare[string](v1.SortableString(), v2.SortableString()) == v1.CompareTo(v2)
+//
+// This may turn out useful when the version is saved in a database or is
+// introduced in a system that doesn't support semver ordering.
+func (v *Version) SortableString() string {
+	// Encode a number in a string that when compared as string it respects
+	// the original numeric order.
+	// To allow longer numbers to be compared correctly, a prefix of ":"s
+	// with the length of the number is added minus 1.
+	// For example: 123 -> "::123"
+	//              45  -> ":45"
+	// The number written as string compare as ("123" < "99") but the encoded
+	// version keeps the original integer ordering ("::123" > ":99").
+	encodeNumber := func(in []byte) string {
+		if len(in) == 0 {
+			return "0"
+		}
+		p := ""
+		for range in {
+			p += ":"
+		}
+		return p[:len(p)-1] + string(in)
+	}
+
+	var vMajor, vMinor, vPatch []byte
+	vMajor = v.bytes[:v.major]
+	if v.minor > v.major {
+		vMinor = v.bytes[v.major+1 : v.minor]
+	}
+	if v.patch > v.minor {
+		vPatch = v.bytes[v.minor+1 : v.patch]
+	}
+
+	res := encodeNumber(vMajor) + "." + encodeNumber(vMinor) + "." + encodeNumber(vPatch)
+	// If there is no pre-release, add a ";" to the end, otherwise add a "-" followed by the pre-release.
+	// This ensure the correct ordering of the pre-release versions (that are always lower than the normal versions).
+	if v.prerelease == v.patch {
+		return res + ";"
+	}
+	res += "-"
+
+	isAlpha := false
+	add := func(in []byte) {
+		// if the pre-release piece is alphanumeric, add a ";" before the piece
+		// otherwise add an ":" before the piece. This ensure the correct ordering
+		// of the pre-release piece (numeric are lower than alphanumeric).
+		if isAlpha {
+			res += ";" + string(in)
+		} else {
+			res += ":" + encodeNumber(in)
+		}
+		isAlpha = false
+	}
+	prerelease := v.bytes[v.patch+1 : v.prerelease]
+	start := 0
+	for curr, c := range prerelease {
+		if c == '.' {
+			add(prerelease[start:curr])
+			res += "."
+			start = curr + 1
+			continue
+		}
+		if !isNumeric(c) {
+			isAlpha = true
+		}
+	}
+	add(prerelease[start:])
+	return res
+}

version_test.go

@@ -7,6 +7,7 @@
 package semver
 
 import (
+	"cmp"
 	"fmt"
 	"testing"
 
@@ -54,6 +55,41 @@ func ascending(t *testing.T, allowEqual bool, list ...string) {
 			require.True(t, b.GreaterThan(a))
 		}
 	}
+
+	for i := range list[0 : len(list)-1] {
+		a := MustParse(list[i]).SortableString()
+		b := MustParse(list[i+1]).SortableString()
+		comp := cmp.Compare(a, b)
+		if allowEqual {
+			fmt.Printf("%s %s= %s\n", list[i], sign[comp], list[i+1])
+			require.LessOrEqual(t, comp, 0)
+			require.True(t, a <= b)
+			require.False(t, a > b)
+		} else {
+			fmt.Printf("%s %s %s\n", list[i], sign[comp], list[i+1])
+			require.Equal(t, comp, -1, "cmp(%s, %s) (%s, %s) must return '<', but returned '%s'", list[i], list[i+1], a, b, sign[comp])
+			require.True(t, a < b)
+			require.True(t, a <= b)
+			require.False(t, a == b)
+			require.False(t, a >= b)
+			require.False(t, a > b)
+		}
+
+		comp = cmp.Compare(b, a)
+		fmt.Printf("%s %s %s\n", b, sign[comp], a)
+		if allowEqual {
+			require.GreaterOrEqual(t, comp, 0, "cmp(%s, %s) must return '>=', but returned '%s'", b, a, sign[comp])
+			require.False(t, b < a)
+			require.True(t, b >= a)
+		} else {
+			require.Equal(t, comp, 1)
+			require.False(t, b < a)
+			require.False(t, b <= a)
+			require.False(t, b == a)
+			require.True(t, b >= a)
+			require.True(t, b > a)
+		}
+	}
 }
 
 func TestVersionComparator(t *testing.T) {
@@ -124,6 +160,10 @@ func TestVersionComparator(t *testing.T) {
 		"17.3.0-atmel3a.16.1-arduino7",
 		"17.3.0-atmel3a.16.12-arduino7",
 		"17.3.0-atmel3a.16.2-arduino7",
+		"34.0.0",
+		"51.0.0",
+		"99.0.0",
+		"123.0.0",
 	)
 	equal(
 		MustParse(""),