fix: alpha version

Author: ivklgn

internal/update/update.go

@@ -95,8 +95,8 @@ func NeedsUpdate(current, latest string) bool {
 		return true
 	}
 
-	curParts := parseSemver(current)
-	latParts := parseSemver(latest)
+	curParts, curPre := parseSemver(current)
+	latParts, latPre := parseSemver(latest)
 
 	if curParts == nil || latParts == nil {
 		// Fall back to string comparison if parsing fails.
@@ -111,7 +111,20 @@ func NeedsUpdate(current, latest string) bool {
 			return false
 		}
 	}
-	return false
+
+	// Major.minor.patch are equal — compare pre-release.
+	// Per SemVer: release (no pre-release) > any pre-release.
+	if curPre != "" && latPre == "" {
+		return true // current is pre-release, latest is release
+	}
+	if curPre == "" && latPre != "" {
+		return false // current is release, latest is pre-release
+	}
+	if curPre == "" && latPre == "" {
+		return false // both are releases, identical
+	}
+
+	return comparePreRelease(curPre, latPre) < 0
 }
 
 // stripV removes the leading "v" prefix from a version string.
@@ -120,28 +133,79 @@ func stripV(v string) string {
 }
 
 // parseSemver splits a version string like "1.2.3" or "1.2.3-beta.1" into
-// [major, minor, patch]. Pre-release suffixes are stripped before parsing.
+// [major, minor, patch] and an optional pre-release string.
 // Returns nil if parsing fails.
-func parseSemver(v string) []int {
-	// Strip pre-release suffix for comparison purposes.
+func parseSemver(v string) ([]int, string) {
+	var preRelease string
 	if idx := strings.Index(v, "-"); idx != -1 {
+		preRelease = v[idx+1:]
 		v = v[:idx]
 	}
 
 	parts := strings.Split(v, ".")
 	if len(parts) != 3 {
-		return nil
+		return nil, ""
 	}
 
 	result := make([]int, 3)
 	for i, p := range parts {
 		n, err := strconv.Atoi(p)
 		if err != nil {
-			return nil
+			return nil, ""
 		}
 		result[i] = n
 	}
-	return result
+	return result, preRelease
+}
+
+// comparePreRelease compares two pre-release strings per SemVer 2.0.0 §11.
+// Returns -1 if a < b, 0 if a == b, +1 if a > b.
+func comparePreRelease(a, b string) int {
+	aParts := strings.Split(a, ".")
+	bParts := strings.Split(b, ".")
+
+	n := len(aParts)
+	if len(bParts) < n {
+		n = len(bParts)
+	}
+
+	for i := range n {
+		aNum, aErr := strconv.Atoi(aParts[i])
+		bNum, bErr := strconv.Atoi(bParts[i])
+
+		switch {
+		case aErr == nil && bErr == nil:
+			// Both numeric: compare as integers.
+			if aNum < bNum {
+				return -1
+			}
+			if aNum > bNum {
+				return 1
+			}
+		case aErr == nil && bErr != nil:
+			// Numeric < alphanumeric per SemVer.
+			return -1
+		case aErr != nil && bErr == nil:
+			return 1
+		default:
+			// Both alphanumeric: compare lexically.
+			if aParts[i] < bParts[i] {
+				return -1
+			}
+			if aParts[i] > bParts[i] {
+				return 1
+			}
+		}
+	}
+
+	// All compared identifiers are equal — shorter set has lower precedence.
+	if len(aParts) < len(bParts) {
+		return -1
+	}
+	if len(aParts) > len(bParts) {
+		return 1
+	}
+	return 0
 }
 
 // ArchiveName returns the expected archive filename for the current platform.

internal/update/update_test.go

@@ -37,8 +37,13 @@ func TestNeedsUpdate(t *testing.T) {
 		{"no v prefix current", "1.0.0", "v1.1.0", true},
 		{"no v prefix latest", "v1.0.0", "1.1.0", true},
 		{"no v prefix both", "1.0.0", "1.1.0", true},
-		{"pre-release stripped", "v1.0.0-alpha.1", "v1.0.0", false},
-		{"pre-release to release", "v0.9.0-beta.1", "v1.0.0", true},
+		{"pre-release to release", "v1.0.0-alpha.1", "v1.0.0", true},
+		{"pre-release major update", "v0.9.0-beta.1", "v1.0.0", true},
+		{"same pre-release", "v0.0.1-alpha.7", "v0.0.1-alpha.7", false},
+		{"pre-release bump", "v0.0.1-alpha.7", "v0.0.1-alpha.8", true},
+		{"pre-release newer current", "v0.0.1-alpha.8", "v0.0.1-alpha.7", false},
+		{"release to pre-release", "v1.0.0", "v1.0.0-alpha.1", false},
+		{"alpha to beta", "v1.0.0-alpha.1", "v1.0.0-beta.1", true},
 	}
 
 	for _, tt := range tests {
@@ -255,21 +260,23 @@ func TestArchiveName(t *testing.T) {
 
 func TestParseSemver(t *testing.T) {
 	tests := []struct {
-		input string
-		want  []int
+		input   string
+		want    []int
+		wantPre string
 	}{
-		{"1.2.3", []int{1, 2, 3}},
-		{"0.0.1", []int{0, 0, 1}},
-		{"10.20.30", []int{10, 20, 30}},
-		{"1.2.3-alpha.1", []int{1, 2, 3}},
-		{"invalid", nil},
-		{"1.2", nil},
-		{"1.2.x", nil},
+		{"1.2.3", []int{1, 2, 3}, ""},
+		{"0.0.1", []int{0, 0, 1}, ""},
+		{"10.20.30", []int{10, 20, 30}, ""},
+		{"1.2.3-alpha.1", []int{1, 2, 3}, "alpha.1"},
+		{"0.0.1-beta.2", []int{0, 0, 1}, "beta.2"},
+		{"invalid", nil, ""},
+		{"1.2", nil, ""},
+		{"1.2.x", nil, ""},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.input, func(t *testing.T) {
-			got := parseSemver(tt.input)
+			got, gotPre := parseSemver(tt.input)
 			if tt.want == nil {
 				if got != nil {
 					t.Errorf("parseSemver(%q) = %v, want nil", tt.input, got)
@@ -284,6 +291,34 @@ func TestParseSemver(t *testing.T) {
 					t.Errorf("parseSemver(%q)[%d] = %d, want %d", tt.input, i, got[i], tt.want[i])
 				}
 			}
+			if gotPre != tt.wantPre {
+				t.Errorf("parseSemver(%q) pre-release = %q, want %q", tt.input, gotPre, tt.wantPre)
+			}
+		})
+	}
+}
+
+func TestComparePreRelease(t *testing.T) {
+	tests := []struct {
+		name string
+		a, b string
+		want int
+	}{
+		{"equal", "alpha.1", "alpha.1", 0},
+		{"numeric bump", "alpha.7", "alpha.8", -1},
+		{"numeric reverse", "alpha.8", "alpha.7", 1},
+		{"alpha vs beta", "alpha.1", "beta.1", -1},
+		{"numeric vs alpha", "1", "alpha", -1},
+		{"shorter is less", "alpha", "alpha.1", -1},
+		{"longer is more", "alpha.1", "alpha", 1},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := comparePreRelease(tt.a, tt.b)
+			if got != tt.want {
+				t.Errorf("comparePreRelease(%q, %q) = %d, want %d", tt.a, tt.b, got, tt.want)
+			}
 		})
 	}
 }