comparisons

Author: bbengfort

semver/semver.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 	"regexp"
 	"strconv"
+	"strings"
 )
 
 // See: https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
@@ -85,6 +86,137 @@ func (v Version) IsZero() bool {
 	return v.Major == 0 && v.Minor == 0 && v.Patch == 0 && v.PreRelease == "" && v.BuildMeta == ""
 }
 
+//===========================================================================
+// Comparison
+//===========================================================================
+
+// Compare returns the precedence of version v compared to version o. See Compare
+// for more details about how precedence is determined.
+func (v Version) Compare(o Version) int {
+	return Compare(v, o)
+}
+
+// Compare returns the precedence of version a compared to version b. If a has a higher
+// precedence than b (a > b), the result is 1. If a has a lower precedence than b (a < b),
+// the result is -1. If they have the same precedence (a == b), the result is 0.
+// Note that BuildMeta is not factored into precedence so it is possible to have two
+// semantically equivalent versions with different string values.
+//
+// Precedence is determined by the first difference when comparing each of these
+// identifiers from left to right as follows: Major, minor, and patch versions are
+// always compared numerically.
+//
+// When major, minor, and patch are equal, a pre-release version has lower precedence
+// than a normal version.
+//
+// Precedence for two pre-release versions with the same major, minor, and patch version
+// MUST be determined by comparing each dot separated identifier from left to right
+// until a difference is found as follows:
+//
+//  1. Identifiers consisting of only digits are compared numerically.
+//  2. Identifiers with letters or hyphens are compared lexically in ASCII sort order.
+//  3. Numeric identifiers always have lower precedence than non-numeric identifiers.
+//  4. A larger set of pre-release fields has a higher precedence than a smaller set,
+//     if all of the preceding identifiers are equal.
+func Compare(a, b Version) int {
+	if a.Major != b.Major {
+		if a.Major > b.Major {
+			return 1
+		}
+		return -1
+	}
+
+	if a.Minor != b.Minor {
+		if a.Minor > b.Minor {
+			return 1
+		}
+		return -1
+	}
+
+	if a.Patch != b.Patch {
+		if a.Patch > b.Patch {
+			return 1
+		}
+		return -1
+	}
+
+	if a.PreRelease != b.PreRelease {
+		// a doesn't have a prerelease so it has a higher precedence
+		if a.PreRelease == "" {
+			return 1
+		}
+
+		// b doesn't have a prerelease so it has a higher precedence
+		if b.PreRelease == "" {
+			return -1
+		}
+
+		ar := strings.Split(a.PreRelease, ".")
+		br := strings.Split(b.PreRelease, ".")
+
+		if len(ar) >= len(br) {
+			for i, bv := range br {
+				av := ar[i]
+				if precedence := compareIdentifier(av, bv); precedence != 0 {
+					return precedence
+				}
+			}
+
+			// a has more pre-release fields than b and all are equal so a has a higher precedence
+			// if len(ar) == len(br) then the first difference would have been found in the loop
+			return 1
+		} else {
+			for i, av := range ar {
+				bv := br[i]
+				if precedence := compareIdentifier(av, bv); precedence != 0 {
+					return precedence
+				}
+			}
+
+			// b has more pre-release fields than a and all are equal so b has a higher precedence
+			return -1
+		}
+	}
+
+	// At this point we know the versions are semantically equivalent.
+	return 0
+}
+
+func compareIdentifier(a, b string) int {
+	if a == b {
+		return 0
+	}
+
+	// Determine if a and b are numeric or non-numeric.
+	na, aIsNumeric := isNumeric(a)
+	nb, bIsNumeric := isNumeric(b)
+
+	switch {
+	// If both are numeric, compare numerically.
+	case aIsNumeric && bIsNumeric:
+		if na > nb {
+			return 1
+		}
+		return -1
+	// If one is numeric and the other is not, the numeric one has lower precedence.
+	case aIsNumeric:
+		return -1
+	case bIsNumeric:
+		return 1
+	default:
+		// Compare lexicographically in ASCII sort order.
+		return strings.Compare(a, b)
+	}
+}
+
+func isNumeric(s string) (v uint16, ok bool) {
+	n, err := strconv.ParseUint(s, 10, 16)
+	if err != nil {
+		return 0, false
+	}
+	return uint16(n), true
+}
+
 //===========================================================================
 // Serialization and Deserialization
 //===========================================================================

semver/semver_test.go

@@ -152,6 +152,39 @@ func TestMarshal(t *testing.T) {
 	})
 }
 
+func TestCompare(t *testing.T) {
+	tests := []struct {
+		a, b     string
+		expected int
+	}{
+		{"1.0.0", "1.0.0", 0},
+		{"2.3.0", "2.3.0", 0},
+		{"3.1.4", "3.1.4", 0},
+		{"1.0.0", "1.0.1", -1},
+		{"1.0.0", "1.1.0", -1},
+		{"2.1.1", "2.1.0", 1},
+		{"2.1.0", "2.0.0", 1},
+		{"2.0.0", "1.0.0", 1},
+		{"1.0.0-alpha", "1.0.0", -1},
+		{"1.0.0-alpha", "1.0.0-alpha.1", -1},
+		{"1.0.0-alpha.1", "1.0.0-alpha.beta", -1},
+		{"1.0.0-alpha.beta", "1.0.0-beta", -1},
+		{"1.0.0-beta", "1.0.0-beta.2", -1},
+		{"1.0.0-beta.2", "1.0.0-beta.11", -1},
+		{"1.0.0-beta.11", "1.0.0-rc.1", -1},
+		{"1.0.0-rc.1", "1.0.0", -1},
+		{"1.0.0", "1.0.0+20130313144700", 0},
+		{"1.0.0+20130313144700", "1.0.0+exp.sha.5114f85", 0},
+	}
+
+	for i, tc := range tests {
+		a := MustParse(tc.a)
+		b := MustParse(tc.b)
+		assert.Equal(t, tc.expected, a.Compare(b), "test case %d failed", i)
+		assert.Equal(t, -1*tc.expected, Compare(b, a), "test case %d failed", i)
+	}
+}
+
 func TestSQL(t *testing.T) {
 	t.Run("Scan", func(t *testing.T) {
 		a := Version{}