refactor: simplify Go version logic with centralized VersionManager

- Extract complex version handling logic into dedicated VersionManager struct
- Replace 100+ line judgeVersion function with focused, testable methods
- Use consistent semver library parsing for better reliability
- Eliminate recursive calls and nested conditions
- Improve error handling with proper validation
- Add comprehensive version resolution methods for different patterns
- Maintain backward compatibility with existing API
- Update test expectations to match corrected version resolution
- Clean up unused imports and fix compilation warnings

Author: juev

gobrew.go

@@ -7,9 +7,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"regexp"
 	"sort"
-	"strconv"
 	"strings"
 	"time"
 
@@ -58,6 +56,7 @@ type GoBrew struct {
 	currentGoDir  string
 	downloadsDir  string
 	cacheFile     string
+	versionManager *VersionManager
 	Config
 }
 
@@ -90,6 +89,8 @@ func NewGoBrew(config Config) GoBrew {
 		cacheFile:     cacheFile,
 	}
 
+	gb.versionManager = NewVersionManager(&gb)
+
 	if gb.ClearCache {
 		_ = os.RemoveAll(gb.cacheFile)
 	}
@@ -100,10 +101,10 @@ func NewGoBrew(config Config) GoBrew {
 // Interactive used by default
 func (gb *GoBrew) Interactive(ask bool) {
 	currentVersion := gb.CurrentVersion()
-	currentMajorVersion := extractMajorVersion(currentVersion)
+	currentMajorVersion := gb.versionManager.ExtractMajorVersion(currentVersion)
 
 	latestVersion := gb.getLatestVersion()
-	latestMajorVersion := extractMajorVersion(latestVersion)
+	latestMajorVersion := gb.versionManager.ExtractMajorVersion(latestVersion)
 
 	modVersion := NoneVersion
 	if gb.hasModFile() {
@@ -160,10 +161,18 @@ func (gb *GoBrew) Interactive(ask bool) {
 		fmt.Println("   Please consider updating your go.mod file")
 		c := true
 		if ask {
-			c = askForConfirmation("🤔 Do you want to use GO version same as go.mod version (" + modVersion + "@latest)?")
+			versionToUse := modVersion
+			if strings.Count(modVersion, ".") == 1 {
+				versionToUse = modVersion + "@latest"
+			}
+			c = askForConfirmation("🤔 Do you want to use GO version same as go.mod version (" + versionToUse + ")?")
 		}
 		if c {
-			gb.Use(modVersion + "@latest")
+			versionToUse := modVersion
+			if strings.Count(modVersion, ".") == 1 {
+				versionToUse = modVersion + "@latest"
+			}
+			gb.Use(versionToUse)
 		}
 		return
 	}
@@ -223,9 +232,12 @@ func (gb *GoBrew) ListVersions() {
 	cv := gb.CurrentVersion()
 
 	versionsSemantic := make([]*semver.Version, 0)
+	rcBetaVersions := make([]string, 0)
 
 	for _, f := range files {
-		if v, err := semver.NewVersion(f.Name()); err == nil {
+		if gb.versionManager.isBetaOrRC(f.Name()) {
+			rcBetaVersions = append(rcBetaVersions, f.Name())
+		} else if v, err := semver.NewVersion(f.Name()); err == nil {
 			versionsSemantic = append(versionsSemantic, v)
 		}
 	}
@@ -235,15 +247,9 @@ func (gb *GoBrew) ListVersions() {
 
 	for _, versionSemantic := range versionsSemantic {
 		version := versionSemantic.String()
-		// 1.8.0 -> 1.8, if version < 1.21.0
-		reMajorVersion := regexp.MustCompile("([0-9]+).([0-9]+).0")
-		if len(reMajorVersion.FindStringSubmatch(version)) > 1 {
-			vv, _ := strconv.Atoi(reMajorVersion.FindStringSubmatch(version)[2])
-			if vv < 21 {
-				if reMajorVersion.MatchString(version) {
-					version = strings.Split(version, ".")[0] + "." + strings.Split(version, ".")[1]
-				}
-			}
+		// For versions < 1.21.0, display as major.minor
+		if versionSemantic.Major() == 1 && versionSemantic.Minor() < 21 && versionSemantic.Patch() == 0 {
+			version = fmt.Sprintf("%d.%d", versionSemantic.Major(), versionSemantic.Minor())
 		}
 		if version == cv {
 			version = cv + "*"
@@ -254,17 +260,12 @@ func (gb *GoBrew) ListVersions() {
 	}
 
 	// print rc and beta versions in the end
-	for _, f := range files {
-		rcVersion := f.Name()
-		r := regexp.MustCompile("beta.*|rc.*")
-		matches := r.FindAllString(rcVersion, -1)
-		if len(matches) == 1 {
-			if rcVersion == cv {
-				rcVersion = cv + "*"
-				color.Successln(rcVersion)
-			} else {
-				color.Infoln(rcVersion)
-			}
+	for _, rcVersion := range rcBetaVersions {
+		if rcVersion == cv {
+			rcVersion = cv + "*"
+			color.Successln(rcVersion)
+		} else {
+			color.Infoln(rcVersion)
 		}
 	}
 
@@ -321,19 +322,18 @@ func (gb *GoBrew) Install(version string) string {
 		color.Errorln("[Error] No version provided")
 		os.Exit(1)
 	}
-	// if version has 2 dots, then remove the @latest or @dev-latest
-	if strings.Count(version, ".") == 2 {
-		if strings.HasSuffix(version, "@latest") || strings.HasSuffix(version, "@dev-latest") {
-			version = strings.TrimSuffix(version, "@latest")
-			version = strings.TrimSuffix(version, "@dev-latest")
-		}
-	}
+	// Use VersionManager to resolve the version
 	tmpVersion := version
-	version = gb.judgeVersion(version)
-	if version == NoneVersion {
+	resolvedVersion, err := gb.versionManager.ResolveVersion(version)
+	if err != nil {
+		color.Errorln("[Error]", err)
+		os.Exit(1)
+	}
+	if resolvedVersion == NoneVersion {
 		color.Errorln("[Error] Version", tmpVersion, "does not exists")
 		os.Exit(1)
 	}
+	version = resolvedVersion
 	if gb.existsVersion(version) {
 		color.Infof("==> [Info] Version: %s exists\n", version)
 		return version

helpers.go

@@ -12,7 +12,6 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
-	"slices"
 	"sort"
 	"strings"
 	"time"
@@ -25,29 +24,8 @@ import (
 )
 
 func (gb *GoBrew) getLatestVersion() string {
-	getGolangVersions := gb.getGolangVersions()
-
-	// Filter out beta and rc versions and create semantic versions
-	var validVersions []*semver.Version
-	for _, version := range getGolangVersions {
-		r := regexp.MustCompile("beta.*|rc.*")
-		matches := r.FindAllString(version, -1)
-		if len(matches) == 0 {
-			if v, err := semver.NewVersion(version); err == nil {
-				validVersions = append(validVersions, v)
-			}
-		}
-	}
-
-	if len(validVersions) == 0 {
-		return ""
-	}
-
-	// Sort semantic versions
-	sort.Sort(semver.Collection(validVersions))
-
-	// Return the latest version (last in sorted order)
-	return validVersions[len(validVersions)-1].String()
+	// Use VersionManager for better reliability
+	return gb.versionManager.getLatestStableVersion()
 }
 
 func (gb *GoBrew) getArch() string {
@@ -183,120 +161,14 @@ func (gb *GoBrew) cleanDownloadsDir() {
 	_ = os.RemoveAll(gb.downloadsDir)
 }
 
+// judgeVersion is a wrapper around VersionManager.ResolveVersion for backward compatibility
+// Deprecated: Use gb.versionManager.ResolveVersion() instead
 func (gb *GoBrew) judgeVersion(version string) string {
-	judgedVersion := NoneVersion
-	rcBetaOk := false
-	reRcOrBeta := regexp.MustCompile("beta.*|rc.*")
-
-	// check if version string ends with x
-	if strings.HasSuffix(version, "x") {
-		judgedVersion = strings.TrimSuffix(version, "x")
-	}
-
-	if strings.HasSuffix(version, ".x") {
-		judgedVersion = strings.TrimSuffix(version, ".x")
-	}
-	if strings.HasSuffix(version, "@latest") {
-		judgedVersion = strings.TrimSuffix(version, "@latest")
-	}
-	if strings.HasSuffix(version, "@dev-latest") {
-		judgedVersion = strings.TrimSuffix(version, "@dev-latest")
-		rcBetaOk = true
-	}
-
-	if version == "mod" {
-		// get version by reading the mod file of Go
-		modVersion := gb.getModVersion()
-		// if modVersion is like 1.19, 1.20, 1.21 then appened @latest to it
-		if strings.Count(modVersion, ".") == 1 {
-			modVersion += "@latest"
-		}
-		return gb.judgeVersion(modVersion)
-	}
-	groupedVersions := gb.ListRemoteVersions(false) // donot print
-
-	// latest will pick the latest version excluding rc and beta
-	// dev-latest will first remove rc and beta from the list of versions and then pick the latest version
-	if version == "latest" || version == "dev-latest" {
-		groupedVersionKeys := make([]string, 0, len(groupedVersions))
-		for groupedVersionKey := range groupedVersions {
-			groupedVersionKeys = append(groupedVersionKeys, groupedVersionKey)
-		}
-		versionsSemantic := make([]*semver.Version, 0)
-		for _, r := range groupedVersionKeys {
-			if v, err := semver.NewVersion(r); err == nil {
-				versionsSemantic = append(versionsSemantic, v)
-			}
-		}
-		if len(versionsSemantic) == 0 {
-			return NoneVersion
-		}
-
-		// sort semantic versions
-		sort.Sort(semver.Collection(versionsSemantic))
-		// loop in reverse
-		for i := len(versionsSemantic) - 1; i >= 0; i-- {
-			judgedVersions := groupedVersions[versionsSemantic[i].Original()]
-			// get last element
-			if version == "dev-latest" {
-				if len(judgedVersions) == 0 {
-					return NoneVersion
-				}
-				// Filter versions containing "rc" or "beta"
-				filteredVersions := gb.filterVersions(judgedVersions, []string{"rc", "beta"})
-
-				// Get the last element of the filtered slice
-				var lastVersion string
-				if len(filteredVersions) > 0 {
-					lastVersion = filteredVersions[len(filteredVersions)-1]
-				}
-
-				return lastVersion
-			}
-
-			// loop in reverse
-			for j := len(judgedVersions) - 1; j >= 0; j-- {
-				matches := reRcOrBeta.FindAllString(judgedVersions[j], -1)
-				if len(matches) == 0 {
-					return judgedVersions[j]
-				}
-			}
-		}
-
-		latest := versionsSemantic[len(versionsSemantic)-1].String()
-		return gb.judgeVersion(latest)
-	}
-
-	if judgedVersion != NoneVersion {
-		// check if judgedVersion is in the groupedVersions
-		if _, ok := groupedVersions[judgedVersion]; ok {
-			// get last item in the groupedVersions excluding rc and beta
-			// loop in reverse groupedVersions
-			for i := len(groupedVersions[judgedVersion]) - 1; i >= 0; i-- {
-				matches := reRcOrBeta.FindAllString(groupedVersions[judgedVersion][i], -1)
-				if len(matches) == 0 {
-					return groupedVersions[judgedVersion][i]
-				}
-			}
-			if rcBetaOk {
-				// return last element including beta and rc if present
-				return groupedVersions[judgedVersion][len(groupedVersions[judgedVersion])-1]
-			}
-		}
-	}
-
-	exists := false
-	for _, value := range groupedVersions {
-		if slices.Contains(value, version) {
-			exists = true
-			break
-		}
-	}
-	if !exists {
+	resolvedVersion, err := gb.versionManager.ResolveVersion(version)
+	if err != nil {
 		return NoneVersion
 	}
-
-	return version
+	return resolvedVersion
 }
 
 func (gb *GoBrew) hasModFile() bool {
@@ -498,6 +370,8 @@ func (gb *GoBrew) extract(srcTar string, dstDir string) error {
 	return nil
 }
 
+// extractMajorVersion is deprecated and replaced by VersionManager.ExtractMajorVersion
+// This function is kept for backward compatibility
 func extractMajorVersion(version string) string {
 	parts := strings.Split(version, ".")
 	if len(parts) < 2 {

helpers_test.go

@@ -36,11 +36,11 @@ func TestJudgeVersion(t *testing.T) {
 		},
 		{
 			version:     "1.18@latest",
-			wantVersion: "1.18.9",
+			wantVersion: "1.18.10",
 		},
 		{
 			version:     "1.18@dev-latest",
-			wantVersion: "1.18.9",
+			wantVersion: "1.18.10",
 		},
 		{
 			version:     "go1.18",