Allow gradual migration to go run

cmd/gex/main.go

@@ -20,6 +20,8 @@ const (
 
 var (
 	pkgsToBeAdded []string
+	flagBin       bool
+	flagNoBin     bool
 	flagBuild     bool
 	flagInit      bool
 	flagRegen     bool
@@ -31,6 +33,8 @@ var (
 func init() {
 	pflag.SetInterspersed(false)
 	pflag.StringArrayVar(&pkgsToBeAdded, "add", []string{}, "Add new tools")
+	pflag.BoolVar(&flagBin, "bin", false, "Enable build for the added tools")
+	pflag.BoolVar(&flagNoBin, "no-bin", false, "Disable build for the added tools")
 	pflag.BoolVar(&flagInit, "init", false, "Initialize tools manifest")
 	pflag.BoolVar(&flagBuild, "build", false, "Build all tools")
 	pflag.BoolVar(&flagRegen, "regen", false, "Regenerate manifest")
@@ -68,7 +72,13 @@ func run() error {
 
 	switch {
 	case len(pkgsToBeAdded) > 0:
-		err = toolRepo.Add(ctx, pkgsToBeAdded...)
+		buildMode := tool.BuildModeUnknown
+		if flagBin {
+			buildMode = tool.BuildModeBin
+		} else if flagNoBin {
+			buildMode = tool.BuildModeNoBin
+		}
+		err = toolRepo.AddOpt(ctx, buildMode, pkgsToBeAdded...)
 	case flagVersion:
 		fmt.Fprintf(os.Stdout, "%s %s\n", cliName, gex.Version)
 	case flagHelp:

pkg/manager/dep/manager.go

@@ -64,6 +64,10 @@ func (m *managerImpl) Build(ctx context.Context, binPath, pkg string, verbose bo
 	return errors.WithStack(m.executor.Exec(ctx, "go", args...))
 }
 
+func (m *managerImpl) RunInPlace(ctx context.Context, pkg string, verbose bool, args ...string) error {
+	return errors.New("Package must be built before run when in Dep mode")
+}
+
 func (m *managerImpl) Sync(ctx context.Context, verbose bool) error {
 	args := []string{"ensure"}
 	if verbose {

pkg/manager/manager.go

@@ -5,5 +5,6 @@ import "context"
 type Interface interface {
 	Add(ctx context.Context, pkgs []string, verbose bool) error
 	Build(ctx context.Context, binPath, pkg string, verbose bool) error
+	RunInPlace(ctx context.Context, pkg string, verbose bool, args ...string) error
 	Sync(ctx context.Context, verbose bool) error
 }

pkg/manager/mod/manager.go

@@ -37,6 +37,16 @@ func (m *managerImpl) Build(ctx context.Context, binPath, pkg string, verbose bo
 	return errors.WithStack(m.executor.Exec(ctx, "go", args...))
 }
 
+func (m *managerImpl) RunInPlace(ctx context.Context, pkg string, verbose bool, commandArgs ...string) error {
+	args := []string{"run"}
+	if verbose {
+		args = append(args, "-v")
+	}
+	args = append(args, pkg)
+	args = append(args, commandArgs...)
+	return errors.WithStack(m.executor.Exec(ctx, "go", args...))
+}
+
 func (m *managerImpl) Sync(ctx context.Context, verbose bool) error {
 	args := []string{"mod", "tidy"}
 	if verbose {

pkg/tool/manifest.go

@@ -2,27 +2,38 @@ package tool
 
 import (
 	"sort"
+	"strings"
 
 	"github.com/izumin5210/gex/pkg/manager"
 )
 
 // Manifest contains tool list
 type Manifest struct {
-	toolMap     map[string]Tool
-	managerType manager.Type
+	toolMap          map[string]Tool
+	managerType      manager.Type
+	defaultBuildMode BuildMode
 }
 
 // NewManifest creates a new Manifest instance.
-func NewManifest(tools []Tool, mType manager.Type) *Manifest {
+func NewManifest(tools []Tool, mType manager.Type, options ...ManifestOption) *Manifest {
 	toolMap := make(map[string]Tool, len(tools))
 	for _, t := range tools {
 		toolMap[t.Name()] = t
 	}
-	return &Manifest{toolMap: toolMap, managerType: mType}
+	m := &Manifest{toolMap: toolMap, managerType: mType}
+	for _, option := range options {
+		option(m)
+	}
+	if m.defaultBuildMode == BuildModeUnknown {
+		m.defaultBuildMode = BuildModeBin
+	}
+	return m
 }
 
 func (m *Manifest) ManagerType() manager.Type { return m.managerType }
 
+func (m *Manifest) DefaultBuildMode() BuildMode { return m.defaultBuildMode }
+
 // AddTool adds a new tool to the manifest.
 func (m *Manifest) AddTool(tool Tool) {
 	m.toolMap[tool.Name()] = tool
@@ -37,18 +48,25 @@ func (m *Manifest) FindTool(name string) (t Tool, ok bool) {
 // Tools returns a tool list.
 func (m *Manifest) Tools() []Tool {
 	n := len(m.toolMap)
-	s := make([]string, 0, n)
+	ts := make([]Tool, 0, n)
 	for _, t := range m.toolMap {
-		s = append(s, string(t))
-	}
-	sort.StringSlice(s).Sort()
-	ts := make([]Tool, n, n)
-	for i, t := range s {
-		ts[i] = Tool(t)
+		ts = append(ts, t)
 	}
+	sort.Slice(ts, func(i int, j int) bool {
+		return strings.Compare(ts[i].ImportPath, ts[j].ImportPath) < 0
+	})
 	return ts
 }
 
 func (m *Manifest) addTool(t Tool) {
 	m.toolMap[t.Name()] = t
 }
+
+type ManifestOption func(m *Manifest)
+
+// WithDefaultBuildMode configures default build mode.
+func WithDefaultBuildMode(buildMode BuildMode) ManifestOption {
+	return func(m *Manifest) {
+		m.defaultBuildMode = buildMode
+	}
+}

pkg/tool/parser.go

@@ -1,9 +1,11 @@
 package tool
 
 import (
+	"go/ast"
 	"go/parser"
 	"go/token"
 	"strconv"
+	"strings"
 
 	"github.com/izumin5210/gex/pkg/manager"
 	"github.com/pkg/errors"
@@ -35,18 +37,50 @@ func (p *parserImpl) Parse(path string) (*Manifest, error) {
 	}
 
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", string(data), parser.ImportsOnly)
+	f, err := parser.ParseFile(fset, "", string(data), parser.ImportsOnly|parser.ParseComments)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to parse %q", path)
 	}
 
 	tools := make([]Tool, 0, len(f.Imports))
 
+	comments := commentTraverser{comments: f.Comments}
+	fileComments := comments.consume(f.Pos())
+	fileBuildMode := parseBuildMode(fileComments)
 	for _, s := range f.Imports {
 		if pkg, err := strconv.Unquote(s.Path.Value); err == nil {
-			tools = append(tools, Tool(pkg))
+			importComments := comments.consume(s.Pos())
+			buildMode := parseBuildMode(importComments)
+			tools = append(tools, Tool{ImportPath: pkg, BuildMode: buildMode})
 		}
 	}
 
-	return NewManifest(tools, p.mType), nil
+	return NewManifest(tools, p.mType, WithDefaultBuildMode(fileBuildMode)), nil
+}
+
+type commentTraverser struct {
+	comments []*ast.CommentGroup
+	index    int
+}
+
+func (t *commentTraverser) consume(pos token.Pos) []*ast.CommentGroup {
+	start := t.index
+	for t.index < len(t.comments) && t.comments[t.index].Pos() < pos {
+		t.index++
+	}
+	return t.comments[start:t.index]
+}
+
+func parseBuildMode(groups []*ast.CommentGroup) BuildMode {
+	for _, group := range groups {
+		for _, element := range group.List {
+			if strings.Contains(element.Text, "gex:bin") {
+				return BuildModeBin
+			}
+			if strings.Contains(element.Text, "gex:nobin") {
+				return BuildModeNoBin
+			}
+		}
+	}
+	return BuildModeUnknown
 }