feat: supports 'g use' switching to the version specified in go.mod. #163

Author: voidint

cli/commands.go

@@ -63,7 +63,7 @@ var (
 		},
 		{
 			Name:      "use",
-			Usage:     "Switch to specified version",
+			Usage:     "Switch to specified version. Uses go.mod if available and version is omitted.",
 			UsageText: "g use <version>",
 			Action:    use,
 		},

cli/install.go

@@ -31,6 +31,7 @@ import (
 	"github.com/dixonwille/wlog/v3"
 	"github.com/dixonwille/wmenu/v5"
 	"github.com/mholt/archiver/v3"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 	"github.com/voidint/g/collector"
 	"github.com/voidint/g/version"
@@ -169,13 +170,24 @@ func install(ctx *cli.Context) (err error) {
 		return nil
 	}
 
-	// Recreate symbolic link.
+	if err = switchVersion(vname); err != nil {
+		return cli.Exit(errstring(err), 1)
+	}
+	return nil
+}
+
+func switchVersion(vname string) error {
+	targetV := filepath.Join(versionsDir, vname)
+
+	// Recreate symbolic link
 	_ = os.Remove(goroot)
 
-	if err = mkSymlink(targetV, goroot); err != nil {
-		return cli.Exit(errstring(err), 1)
+	if err := mkSymlink(targetV, goroot); err != nil {
+		return errors.WithStack(err)
+	}
+	if output, err := exec.Command(filepath.Join(goroot, "bin", "go"), "version").Output(); err == nil {
+		fmt.Printf("Now using %s", strings.TrimPrefix(string(output), "go version "))
 	}
-	fmt.Printf("Now using go%s\n", v.Name())
 	return nil
 }
 
@@ -186,5 +198,8 @@ func mkSymlink(oldname, newname string) (err error) {
 			return nil
 		}
 	}
-	return os.Symlink(oldname, newname)
+	if err = os.Symlink(oldname, newname); err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
 }

cli/ls.go

@@ -25,16 +25,36 @@ import (
 	"sort"
 
 	"github.com/k0kubun/go-ansi"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 	"github.com/voidint/g/version"
 )
 
 func list(ctx *cli.Context) (err error) {
-	dirs, err := os.ReadDir(versionsDir)
-	if err != nil || len(dirs) <= 0 {
+	items, err := listLocalVersions(versionsDir)
+	if err != nil || len(items) <= 0 {
 		fmt.Printf("No version installed yet\n\n")
 		return nil
 	}
+
+	var renderMode uint8
+	switch ctx.String("output") {
+	case "json":
+		renderMode = jsonMode
+	default:
+		renderMode = textMode
+	}
+
+	render(renderMode, installed(), items, ansi.NewAnsiStdout())
+	return nil
+}
+
+// listLocalVersions List the versions in the specified directory in ascending order
+func listLocalVersions(dirPath string) ([]*version.Version, error) {
+	dirs, err := os.ReadDir(dirPath)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
 	items := make([]*version.Version, 0, len(dirs))
 	for _, d := range dirs {
 		if !d.IsDir() {
@@ -46,17 +66,7 @@ func list(ctx *cli.Context) (err error) {
 			continue
 		}
 		items = append(items, v)
-		sort.Sort(version.Collection(items))
-	}
-
-	var renderMode uint8
-	switch ctx.String("output") {
-	case "json":
-		renderMode = jsonMode
-	default:
-		renderMode = textMode
 	}
-
-	render(renderMode, installed(), items, ansi.NewAnsiStdout())
-	return nil
+	sort.Sort(version.Collection(items)) // asc order
+	return items, nil
 }

cli/use.go

@@ -22,30 +22,81 @@ package cli
 import (
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
+	"regexp"
 
+	"github.com/Masterminds/semver/v3"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 )
 
 func use(ctx *cli.Context) error {
 	vname := ctx.Args().First()
 	if vname == "" {
-		return cli.ShowSubcommandHelp(ctx)
+		// Uses go.mod if available and version is omitted
+		goModData, err := os.ReadFile("go.mod")
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				return cli.Exit(wrapstring("No go.mod file found"), 1)
+			}
+			return cli.Exit(errstring(err), 1)
+		}
+
+		goDirective := getGoDirective(goModData)
+		wd, err := os.Getwd()
+		if err != nil {
+			wd = "."
+		}
+		if goDirective == "" {
+			return cli.Exit(wrapstring(fmt.Sprintf("Go directive does not exist in %q files", filepath.Join(wd, "go.mod"))), 1)
+		}
+		fmt.Printf("Found %q with version <%s>\n", filepath.Join(wd, "go.mod"), goDirective)
+		vname = goDirective
 	}
-	targetV := filepath.Join(versionsDir, vname)
 
-	if finfo, err := os.Stat(targetV); err != nil || !finfo.IsDir() {
-		return cli.Exit(fmt.Sprintf("[g] The %q version does not exist, please install it first.", vname), 1)
+	versions, err := listLocalVersions(versionsDir)
+	if err != nil {
+		return cli.Exit(errstring(err), 1)
 	}
 
-	_ = os.Remove(goroot)
+	// Try to match the version number strictly first
+	for i := range versions {
+		if versions[i].Name() != vname {
+			continue
+		}
+		if err = switchVersion(versions[i].Name()); err != nil {
+			return cli.Exit(errstring(err), 1)
+		}
+		return nil
+	}
 
-	if err := mkSymlink(targetV, goroot); err != nil {
+	// Try fuzzy matching the version number again
+	cs, err := semver.NewConstraint(vname)
+	if err != nil {
 		return cli.Exit(errstring(err), 1)
 	}
-	if output, err := exec.Command(filepath.Join(goroot, "bin", "go"), "version").Output(); err == nil {
-		fmt.Print(string(output))
+
+	for j := len(versions) - 1; j >= 0; j-- {
+		if !versions[j].MatchConstraint(cs) {
+			continue
+		}
+		if err = switchVersion(versions[j].Name()); err != nil {
+			return cli.Exit(errstring(err), 1)
+		}
+		return nil
+	}
+
+	return cli.Exit(wrapstring(fmt.Sprintf("The %q version does not exist, please install it first.", vname)), 1)
+}
+
+var goDirectiveReg = regexp.MustCompile(`(?m)^go\s+(\d+\.\d+(?:\.\d+)?(?:beta\d+|rc\d+)?)\s*(?:$|//.*)`)
+
+// getGoDirective Extract the go directive from the go.mod file.
+func getGoDirective(goModData []byte) string {
+	// https://go.dev/ref/mod#go-mod-file-go
+	match := goDirectiveReg.FindStringSubmatch(string(goModData))
+	if len(match) > 1 {
+		return match[1]
 	}
-	return nil
+	return ""
 }