goanywhere command

Signed-off-by: Chris Koch <[email protected]>

src/cmd/goanywhere/.gitignore

@@ -0,0 +1 @@
+goanywhere

src/cmd/goanywhere/main.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"text/template"
+
+	"github.com/u-root/gobusybox/src/pkg/bb/findpkg"
+	"github.com/u-root/gobusybox/src/pkg/golang"
+	"github.com/u-root/uio/ulog"
+	"golang.org/x/exp/maps"
+	"golang.org/x/exp/slices"
+)
+
+var (
+	debug = flag.Bool("d", false, "Show debug string")
+	tmp   = flag.Bool("tmp", true, "Create workspace in temp dir")
+)
+
+func run(dir string, args []string, paths []string) {
+	var relPaths []string
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		relPaths = paths
+	} else {
+		for _, p := range paths {
+			rp, err := filepath.Rel(absDir, p)
+			if err != nil || len(rp) >= len(p) {
+				relPaths = append(relPaths, p)
+			} else {
+				relPaths = append(relPaths, "./"+rp)
+			}
+		}
+	}
+	if *debug {
+		if dir != "" {
+			fmt.Printf("+ cd %s\n", dir)
+		}
+		fmt.Printf("+ %s %s\n", strings.Join(args, " "), strings.Join(relPaths, " "))
+	}
+	c := exec.Command(args[0], append(args[1:], relPaths...)...)
+	c.Stdin, c.Stdout, c.Stderr = os.Stdin, os.Stdout, os.Stderr
+	c.Dir = dir
+	if err := c.Run(); err != nil {
+		log.Fatalf("Exited with %v", err)
+		os.Exit(1)
+	}
+	os.Exit(0)
+}
+
+func main() {
+	flag.Parse()
+	log.SetPrefix("[goanywhere] ")
+
+	args := flag.Args()
+	if len(args) == 0 {
+		log.Fatalf("Usage: goanywhere $pkg... -- <command> ...")
+	}
+	dashIndex := slices.Index(args, "--")
+	if dashIndex == -1 {
+		log.Fatalf("Must use -- to distinguish Go packages from command. Usage: goanywhere $pkg... -- <command> ...")
+	}
+	if len(args) == dashIndex+1 {
+		log.Fatalf("Must provide command to run. Usage: goanywhere $pkg... -- <command> ...")
+	}
+	pkgs := args[:dashIndex]
+	args = args[dashIndex+1:]
+
+	env := golang.Default()
+	paths := findpkg.GlobPaths(ulog.Log, findpkg.DefaultEnv(), pkgs...)
+	mods, noModulePaths := findpkg.Modules(paths)
+
+	if env.GO111MODULE == "off" {
+		run("", args, paths)
+	}
+
+	if len(noModulePaths) > 0 {
+		log.Fatalf("No modules found for %v", noModulePaths)
+	}
+
+	var dir string
+	if *tmp {
+		var err error
+		dir, err = os.MkdirTemp("", "goanywhere-")
+		if err != nil {
+			log.Fatalf("Could not create temp dir: %v", err)
+		}
+		defer os.RemoveAll(dir)
+	}
+
+	tpl := `go {{.Version}}
+
+use ({{range .Modules}}
+	{{.}}{{end}}
+)
+`
+
+	vars := struct {
+		Version string
+		Modules []string
+	}{
+		Version: "1.22",
+		Modules: maps.Keys(mods),
+	}
+	t := template.Must(template.New("tpl").Parse(tpl))
+	var b bytes.Buffer
+	if err := t.Execute(&b, vars); err != nil {
+		log.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "go.work"), b.Bytes(), 0o644); err != nil {
+		log.Fatal(err)
+	}
+	defer os.Remove(filepath.Join(dir, "go.work"))
+
+	run(dir, args, paths)
+}

src/pkg/bb/findpkg/bb.go

@@ -445,3 +445,51 @@ func ResolveGlobs(l ulog.Logger, genv *golang.Environ, env Env, patterns []strin
 	sort.Strings(paths)
 	return paths, nil
 }
+
+// Modules returns a list of module directories => directories of packages
+// inside that module as well as packages that have no discernible module.
+//
+// The module for a package is determined by the **first** parent directory
+// that contains a go.mod.
+func Modules(paths []string) (map[string][]string, []string) {
+	// list of module directory => directories of packages it likely contains
+	moduledPackages := make(map[string][]string)
+	var noModulePkgs []string
+	for _, fullPath := range paths {
+		components := strings.Split(fullPath, "/")
+
+		inModule := false
+		for i := len(components); i >= 1; i-- {
+			prefixPath := "/" + filepath.Join(components[:i]...)
+			if _, err := os.Stat(filepath.Join(prefixPath, "go.mod")); err == nil {
+				moduledPackages[prefixPath] = append(moduledPackages[prefixPath], fullPath)
+				inModule = true
+				break
+			}
+		}
+		if !inModule {
+			noModulePkgs = append(noModulePkgs, fullPath)
+		}
+	}
+	return moduledPackages, noModulePkgs
+}
+
+func globPaths(l ulog.Logger, env Env, patterns []string) []string {
+	var ret []string
+	for _, pattern := range patterns {
+		if match, directories := env.Glob(l, pattern); len(directories) > 0 {
+			ret = append(ret, directories...)
+		} else if !match {
+			l.Printf("No match found for %v", pattern)
+		}
+	}
+	return ret
+}
+
+func GlobPaths(l ulog.Logger, env Env, patterns ...string) []string {
+	includes, excludes := splitExclusions(patterns)
+	includes = globPaths(l, env, expand(includes))
+	excludes = globPaths(l, env, expand(excludes))
+	paths := excludePaths(includes, excludes)
+	return paths
+}

src/pkg/bb/findpkg/bb_test.go

@@ -7,7 +7,6 @@ package findpkg
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -58,15 +57,15 @@ func TestResolve(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { _ = os.RemoveAll("./test/resolvebroken") })
-	if err := ioutil.WriteFile("./test/resolvebroken/main.go", []byte("broken"), 0777); err != nil {
+	if err := os.WriteFile("./test/resolvebroken/main.go", []byte("broken"), 0777); err != nil {
 		t.Fatal(err)
 	}
 
 	if err := os.Mkdir("./test/parsebroken", 0777); err != nil {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { _ = os.RemoveAll("./test/parsebroken") })
-	if err := ioutil.WriteFile("./test/parsebroken/main.go", []byte("package main\n\nimport \"fmt\""), 0777); err != nil {
+	if err := os.WriteFile("./test/parsebroken/main.go", []byte("package main\n\nimport \"fmt\""), 0777); err != nil {
 		t.Fatal(err)
 	}
 
@@ -440,3 +439,56 @@ func TestDefaultEnv(t *testing.T) {
 		})
 	}
 }
+
+func TestModules(t *testing.T) {
+	dir := t.TempDir()
+
+	_ = os.MkdirAll(filepath.Join(dir, "mod1/cmd/cmd1"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "mod1/cmd/cmd2"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "mod1/nestedmod1/cmd/cmd5"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "mod1/nestedmod2/cmd/cmd6"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "mod2/cmd/cmd3"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "mod2/cmd/cmd4"), 0755)
+	_ = os.MkdirAll(filepath.Join(dir, "nomod/cmd/cmd7"), 0755)
+	_ = os.WriteFile(filepath.Join(dir, "mod1/go.mod"), nil, 0644)
+	_ = os.WriteFile(filepath.Join(dir, "mod1/nestedmod1/go.mod"), nil, 0644)
+	_ = os.WriteFile(filepath.Join(dir, "mod1/nestedmod2/go.mod"), nil, 0644)
+	_ = os.WriteFile(filepath.Join(dir, "mod2/go.mod"), nil, 0644)
+
+	paths := []string{
+		filepath.Join(dir, "mod1/cmd/cmd1"),
+		filepath.Join(dir, "mod1/cmd/cmd2"),
+		filepath.Join(dir, "mod1/nestedmod1/cmd/cmd5"),
+		filepath.Join(dir, "mod1/nestedmod2/cmd/cmd6"),
+		filepath.Join(dir, "mod2/cmd/cmd3"),
+		filepath.Join(dir, "mod2/cmd/cmd4"),
+		filepath.Join(dir, "nomod/cmd/cmd7"),
+	}
+	mods, noModulePkgs := Modules(paths)
+
+	want := map[string][]string{
+		filepath.Join(dir, "mod1"): {
+			filepath.Join(dir, "mod1/cmd/cmd1"),
+			filepath.Join(dir, "mod1/cmd/cmd2"),
+		},
+		filepath.Join(dir, "mod1/nestedmod1"): {
+			filepath.Join(dir, "mod1/nestedmod1/cmd/cmd5"),
+		},
+		filepath.Join(dir, "mod1/nestedmod2"): {
+			filepath.Join(dir, "mod1/nestedmod2/cmd/cmd6"),
+		},
+		filepath.Join(dir, "mod2"): {
+			filepath.Join(dir, "mod2/cmd/cmd3"),
+			filepath.Join(dir, "mod2/cmd/cmd4"),
+		},
+	}
+	if !reflect.DeepEqual(mods, want) {
+		t.Errorf("modules() = %v, want %v", mods, want)
+	}
+	wantNoModule := []string{
+		filepath.Join(dir, "nomod/cmd/cmd7"),
+	}
+	if !reflect.DeepEqual(noModulePkgs, wantNoModule) {
+		t.Errorf("modules() no module pkgs = %v, want %v", noModulePkgs, wantNoModule)
+	}
+}