feat: add --work flag to use go work vendor (#84)

* feat: add --work flag to use go work vendor instead of go mod vendor

  Added a new --work flag that forces the use of 'go work vendor' instead of
  'go mod vendor' when vendoring dependencies. This is useful for projects
  using Go workspaces where you want to vendor dependencies across all
  workspace modules.

  - Added --work boolean flag to CLI
  - Modified GoVendor function to accept forceWork parameter
  - Respects GOWORK environment variable (off/auto/path)
  - Added comprehensive tests for all scenarios

Signed-off-by: Kyle Steere <[email protected]>

* change to .ForceWork to avoid potential confusion.

Signed-off-by: Kyle Steere <[email protected]>

---------

Signed-off-by: Kyle Steere <[email protected]>

Author: kbsteere

cmd/gobump/root.go

@@ -1,3 +1,4 @@
+// Package cmd contains the command-line interface for gobump.
 package cmd
 
 import (
@@ -20,6 +21,7 @@ type rootCLIFlags struct {
 	skipInitialTidy bool
 	showDiff        bool
 	tidyCompat      string
+	work            bool
 }
 
 var rootFlags rootCLIFlags
@@ -88,13 +90,14 @@ var rootCmd = &cobra.Command{
 			}
 		}
 
-		if _, err := update.DoUpdate(pkgVersions, &types.Config{Modroot: rootFlags.modroot, Tidy: rootFlags.tidy, GoVersion: rootFlags.goVersion, ShowDiff: rootFlags.showDiff, TidyCompat: rootFlags.tidyCompat, TidySkipInitial: rootFlags.skipInitialTidy}); err != nil {
+		if _, err := update.DoUpdate(pkgVersions, &types.Config{Modroot: rootFlags.modroot, Tidy: rootFlags.tidy, GoVersion: rootFlags.goVersion, ShowDiff: rootFlags.showDiff, TidyCompat: rootFlags.tidyCompat, TidySkipInitial: rootFlags.skipInitialTidy, ForceWork: rootFlags.work}); err != nil {
 			return fmt.Errorf("failed to run update. Error: %v", err)
 		}
 		return nil
 	},
 }
 
+// RootCmd returns the root cobra command for gobump.
 func RootCmd() *cobra.Command {
 	return rootCmd
 }
@@ -114,4 +117,5 @@ func init() {
 	flagSet.BoolVar(&rootFlags.showDiff, "show-diff", false, "Show the difference between the original and 'go.mod' files")
 	flagSet.StringVar(&rootFlags.goVersion, "go-version", "", "set the go-version for go-mod-tidy")
 	flagSet.StringVar(&rootFlags.tidyCompat, "compat", "", "set the go version for which the tidied go.mod and go.sum files should be compatible")
+	flagSet.BoolVar(&rootFlags.work, "work", false, "Use 'go work vendor' instead of 'go mod vendor'")
 }

cmd/gobump/root_test.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestRootCmdWorkFlag(t *testing.T) {
+	// Test that the work flag is properly registered
+	cmd := RootCmd()
+
+	// Check if the work flag exists
+	workFlag := cmd.Flags().Lookup("work")
+	if workFlag == nil {
+		t.Error("work flag not found")
+		return
+	}
+
+	// Verify flag properties
+	if workFlag.Value.Type() != "bool" {
+		t.Errorf("work flag type: got %s, want bool", workFlag.Value.Type())
+	}
+
+	if workFlag.DefValue != "false" {
+		t.Errorf("work flag default: got %s, want false", workFlag.DefValue)
+	}
+
+	if !strings.Contains(workFlag.Usage, "go work vendor") {
+		t.Errorf("work flag usage doesn't mention 'go work vendor': %s", workFlag.Usage)
+	}
+}
+
+func TestRootCLIFlagsStructure(t *testing.T) {
+	// Verify the rootCLIFlags struct has the work field
+	flags := rootCLIFlags{
+		work: true,
+	}
+
+	if !flags.work {
+		t.Error("work field not properly set in rootCLIFlags")
+	}
+}

main.go

@@ -1,3 +1,4 @@
+// Package main is the entry point for the gobump CLI tool.
 package main
 
 import (

pkg/run/gorun.go

@@ -1,3 +1,4 @@
+// Package run provides utilities for running go commands.
 package run
 
 import (
@@ -11,6 +12,7 @@ import (
 	versionutil "k8s.io/apimachinery/pkg/util/version"
 )
 
+// GoModTidy runs go mod tidy with the specified go version and compatibility settings.
 func GoModTidy(modroot, goVersion, compat string) (string, error) {
 	if goVersion == "" {
 		cmd := exec.Command("go", "env", "GOVERSION")
@@ -32,7 +34,7 @@ func GoModTidy(modroot, goVersion, compat string) (string, error) {
 		args = append(args, "-compat", compat)
 	}
 
-	cmd := exec.Command("go", args...)
+	cmd := exec.Command("go", args...) //nolint:gosec
 	cmd.Dir = modroot
 	if bytes, err := cmd.CombinedOutput(); err != nil {
 		return strings.TrimSpace(string(bytes)), err
@@ -68,16 +70,17 @@ func findGoWork(modroot string) string {
 	}
 }
 
-func GoVendor(dir string) (string, error) {
-	if findGoWork(dir) == "" {
-		log.Print("Running go mod vendor...")
-		cmd := exec.Command("go", "mod", "vendor")
+// GoVendor runs go mod vendor or go work vendor depending on workspace configuration.
+func GoVendor(dir string, forceWork bool) (string, error) {
+	if forceWork || findGoWork(dir) != "" {
+		log.Print("Running go work vendor...")
+		cmd := exec.Command("go", "work", "vendor")
 		if bytes, err := cmd.CombinedOutput(); err != nil {
 			return strings.TrimSpace(string(bytes)), err
 		}
 	} else {
-		log.Print("Running go work vendor...")
-		cmd := exec.Command("go", "work", "vendor")
+		log.Print("Running go mod vendor...")
+		cmd := exec.Command("go", "mod", "vendor")
 		if bytes, err := cmd.CombinedOutput(); err != nil {
 			return strings.TrimSpace(string(bytes)), err
 		}
@@ -86,6 +89,7 @@ func GoVendor(dir string) (string, error) {
 	return "", nil
 }
 
+// GoGetModule runs go get for a specific module and version.
 func GoGetModule(name, version, modroot string) (string, error) {
 	cmd := exec.Command("go", "get", fmt.Sprintf("%s@%s", name, version)) //nolint:gosec
 	cmd.Dir = modroot
@@ -95,21 +99,23 @@ func GoGetModule(name, version, modroot string) (string, error) {
 	return "", nil
 }
 
+// GoModEditReplaceModule edits go.mod to replace one module with another.
 func GoModEditReplaceModule(nameOld, nameNew, version, modroot string) (string, error) {
 	cmd := exec.Command("go", "mod", "edit", "-dropreplace", nameOld) //nolint:gosec
 	cmd.Dir = modroot
 	if bytes, err := cmd.CombinedOutput(); err != nil {
-		return strings.TrimSpace(string(bytes)), fmt.Errorf("Error running go command to drop replace modules: %w", err)
+		return strings.TrimSpace(string(bytes)), fmt.Errorf("error running go command to drop replace modules: %w", err)
 	}
 
 	cmd = exec.Command("go", "mod", "edit", "-replace", fmt.Sprintf("%s=%s@%s", nameOld, nameNew, version)) //nolint:gosec
 	cmd.Dir = modroot
 	if bytes, err := cmd.CombinedOutput(); err != nil {
-		return strings.TrimSpace(string(bytes)), fmt.Errorf("Error running go command to replace modules: %w", err)
+		return strings.TrimSpace(string(bytes)), fmt.Errorf("error running go command to replace modules: %w", err)
 	}
 	return "", nil
 }
 
+// GoModEditDropRequireModule drops a require directive from go.mod.
 func GoModEditDropRequireModule(name, modroot string) (string, error) {
 	cmd := exec.Command("go", "mod", "edit", "-droprequire", name) //nolint:gosec
 	cmd.Dir = modroot
@@ -120,6 +126,7 @@ func GoModEditDropRequireModule(name, modroot string) (string, error) {
 	return "", nil
 }
 
+// GoModEditRequireModule adds or updates a require directive in go.mod.
 func GoModEditRequireModule(name, version, modroot string) (string, error) {
 	if bytes, err := GoModEditDropRequireModule(name, modroot); err != nil {
 		return strings.TrimSpace(string(bytes)), err

pkg/run/gorun_test.go

@@ -0,0 +1,179 @@
+package run
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFindGoWork(t *testing.T) {
+	testCases := []struct {
+		name         string
+		setupFunc    func(string) error
+		goWorkEnv    string
+		expectedPath string
+	}{
+		{
+			name: "find go.work in current directory",
+			setupFunc: func(dir string) error {
+				return os.WriteFile(filepath.Join(dir, "go.work"), []byte("go 1.21\n"), 0600)
+			},
+			goWorkEnv:    "",
+			expectedPath: "go.work",
+		},
+		{
+			name: "find go.work in parent directory",
+			setupFunc: func(dir string) error {
+				subdir := filepath.Join(dir, "subdir")
+				if err := os.Mkdir(subdir, 0750); err != nil {
+					return err
+				}
+				return os.WriteFile(filepath.Join(dir, "go.work"), []byte("go 1.22\n"), 0600)
+			},
+			goWorkEnv:    "",
+			expectedPath: "../go.work",
+		},
+		{
+			name:         "no go.work file found",
+			setupFunc:    func(_ string) error { return nil },
+			goWorkEnv:    "",
+			expectedPath: "",
+		},
+		{
+			name: "GOWORK=off disables workspace",
+			setupFunc: func(dir string) error {
+				// Create go.work file but GOWORK=off should ignore it
+				return os.WriteFile(filepath.Join(dir, "go.work"), []byte("go 1.23\n"), 0600)
+			},
+			goWorkEnv:    "off",
+			expectedPath: "",
+		},
+		{
+			name:         "GOWORK points to specific file",
+			setupFunc:    func(_ string) error { return nil },
+			goWorkEnv:    "/custom/path/go.work",
+			expectedPath: "/custom/path/go.work",
+		},
+		{
+			name: "GOWORK=auto searches for go.work file",
+			setupFunc: func(dir string) error {
+				return os.WriteFile(filepath.Join(dir, "go.work"), []byte("go 1.25\n"), 0600)
+			},
+			goWorkEnv:    "auto",
+			expectedPath: "go.work",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create temporary directory
+			tmpDir := t.TempDir()
+
+			// Setup test environment
+			if tc.setupFunc != nil {
+				if err := tc.setupFunc(tmpDir); err != nil {
+					t.Fatalf("Setup failed: %v", err)
+				}
+			}
+
+			// Set GOWORK environment variable if needed
+			if tc.goWorkEnv != "" {
+				oldGoWork := os.Getenv("GOWORK")
+				if err := os.Setenv("GOWORK", tc.goWorkEnv); err != nil {
+					t.Fatalf("Failed to set GOWORK: %v", err)
+				}
+				defer func() {
+					if err := os.Setenv("GOWORK", oldGoWork); err != nil {
+						t.Logf("Failed to restore GOWORK: %v", err)
+					}
+				}()
+			}
+
+			// Change to test directory or subdirectory
+			workDir := tmpDir
+			if strings.Contains(tc.name, "parent") {
+				workDir = filepath.Join(tmpDir, "subdir")
+			}
+
+			// Test findGoWork
+			result := findGoWork(workDir)
+
+			// Verify result
+			switch {
+			case tc.expectedPath == "":
+				if result != "" {
+					t.Errorf("Expected no go.work file, got %q", result)
+				}
+			case tc.goWorkEnv == "/custom/path/go.work":
+				if result != tc.expectedPath {
+					t.Errorf("Expected %q, got %q", tc.expectedPath, result)
+				}
+			default:
+				// For relative paths, check if the result is non-empty for found files
+				if tc.expectedPath == "go.work" || tc.expectedPath == "../go.work" {
+					if result == "" {
+						t.Errorf("Expected to find go.work file, but got empty result")
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoVendorDecisionLogic(t *testing.T) {
+	testCases := []struct {
+		name             string
+		forceWork        bool
+		goWorkExists     bool
+		expectedWorkMode bool // true = go work vendor, false = go mod vendor
+	}{
+		{
+			name:             "use go mod vendor when no work file and forceWork false",
+			forceWork:        false,
+			goWorkExists:     false,
+			expectedWorkMode: false,
+		},
+		{
+			name:             "use go work vendor when work file exists",
+			forceWork:        false,
+			goWorkExists:     true,
+			expectedWorkMode: true,
+		},
+		{
+			name:             "force go work vendor when forceWork is true",
+			forceWork:        true,
+			goWorkExists:     false,
+			expectedWorkMode: true,
+		},
+		{
+			name:             "use go work vendor when both forceWork and work file exist",
+			forceWork:        true,
+			goWorkExists:     true,
+			expectedWorkMode: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create a temporary directory for testing
+			tmpDir := t.TempDir()
+
+			// Create go.work file if needed
+			if tc.goWorkExists {
+				workFile := filepath.Join(tmpDir, "go.work")
+				if err := os.WriteFile(workFile, []byte("go 1.21\n\nuse .\n"), 0600); err != nil {
+					t.Fatalf("Failed to create go.work file: %v", err)
+				}
+			}
+
+			// Test the decision logic
+			// This mirrors the logic in GoVendor function
+			useWorkMode := tc.forceWork || findGoWork(tmpDir) != ""
+
+			if useWorkMode != tc.expectedWorkMode {
+				t.Errorf("Expected work mode %v, got %v", tc.expectedWorkMode, useWorkMode)
+			}
+		})
+	}
+}

pkg/types/parse.go

@@ -1,25 +1,34 @@
+// Package types defines types and parsing functions for gobump.
 package types
 
 import (
 	"fmt"
 	"io"
+	"path/filepath"
 
 	"os"
 
 	"github.com/ghodss/yaml"
 )
 
+// ParseFile parses a YAML file containing package update specifications.
 func ParseFile(bumpFile string) (map[string]*Package, error) {
 	if bumpFile == "" {
 		return nil, fmt.Errorf("no filename specified")
 	}
+	bumpFile = filepath.Clean(bumpFile)
 	var pkgVersions map[string]*Package
 	var packageList PackageList
-	file, err := os.Open(bumpFile)
+	file, err := os.Open(bumpFile) //nolint:gosec
 	if err != nil {
 		return nil, fmt.Errorf("failed reading file: %w", err)
 	}
-	defer file.Close()
+	defer func() {
+		if err := file.Close(); err != nil {
+			// Log error if needed, but we're already in defer
+			_ = err
+		}
+	}()
 	bytes, _ := io.ReadAll(file)
 	if err := yaml.Unmarshal(bytes, &packageList); err != nil {
 		return nil, fmt.Errorf("unmarshaling file: %w", err)