chore: refactor commands interfaces

.goreleaser.yml

@@ -61,7 +61,7 @@ changelog:
     - '^spec:'
     - '^tmp:'
     - '^context:'
-    - '^\d\.\d\.\d:'
+    - '^\d+\.\d+\.\d+:'
 
 snapcrafts:
   -

internal/config/command.go

@@ -47,7 +47,7 @@ func (c Command) Validate() error {
 }
 
 func (c Command) DoSkip(gitState git.State) bool {
-	skipChecker := NewSkipChecker(system.Executor{})
+	skipChecker := NewSkipChecker(system.Cmd)
 	return skipChecker.check(gitState, c.Skip, c.Only)
 }
 

internal/config/command_executor.go

@@ -1,21 +1,19 @@
 package config
 
 import (
+	"io"
 	"runtime"
-)
 
-// Executor is a general execution interface for implicit commands.
-type Executor interface {
-	Execute(args []string, root string) (string, error)
-}
+	"github.com/evilmartians/lefthook/internal/system"
+)
 
 // commandExecutor implements execution of a skip checks passed in a `run` option.
 type commandExecutor struct {
-	exec Executor
+	cmd system.Command
 }
 
 // cmd runs plain string command in a subshell returning the success of it.
-func (c *commandExecutor) cmd(commandLine string) bool {
+func (c *commandExecutor) execute(commandLine string) bool {
 	if commandLine == "" {
 		return false
 	}
@@ -27,7 +25,7 @@ func (c *commandExecutor) cmd(commandLine string) bool {
 		args = []string{"sh", "-c", commandLine}
 	}
 
-	_, err := c.exec.Execute(args, "")
+	err := c.cmd.Run(args, "", system.NullReader, io.Discard)
 
 	return err == nil
 }

internal/config/hook.go

@@ -44,7 +44,7 @@ func (h *Hook) Validate() error {
 }
 
 func (h *Hook) DoSkip(gitState git.State) bool {
-	skipChecker := NewSkipChecker(system.Executor{})
+	skipChecker := NewSkipChecker(system.Cmd)
 	return skipChecker.check(gitState, h.Skip, h.Only)
 }
 

internal/config/script.go

@@ -30,7 +30,7 @@ type scriptRunnerReplace struct {
 }
 
 func (s Script) DoSkip(gitState git.State) bool {
-	skipChecker := NewSkipChecker(system.Executor{})
+	skipChecker := NewSkipChecker(system.Cmd)
 	return skipChecker.check(gitState, s.Skip, s.Only)
 }
 

internal/config/skip_checker.go

@@ -5,14 +5,15 @@ import (
 
 	"github.com/evilmartians/lefthook/internal/git"
 	"github.com/evilmartians/lefthook/internal/log"
+	"github.com/evilmartians/lefthook/internal/system"
 )
 
 type skipChecker struct {
 	exec *commandExecutor
 }
 
-func NewSkipChecker(executor Executor) *skipChecker {
-	return &skipChecker{&commandExecutor{executor}}
+func NewSkipChecker(cmd system.Command) *skipChecker {
+	return &skipChecker{&commandExecutor{cmd}}
 }
 
 // check returns the result of applying a skip/only setting which can be a branch, git state, shell command, etc.
@@ -84,7 +85,7 @@ func (sc *skipChecker) matchesCommands(typedState map[string]interface{}) bool {
 		return false
 	}
 
-	result := sc.exec.cmd(commandLine)
+	result := sc.exec.execute(commandLine)
 
 	log.Debugf("[lefthook] skip/only cmd: %s, result: %t", commandLine, result)
 

internal/config/skip_checker_test.go

@@ -2,23 +2,24 @@ package config
 
 import (
 	"errors"
+	"io"
 	"testing"
 
 	"github.com/evilmartians/lefthook/internal/git"
 )
 
-type mockExecutor struct{}
+type mockCmd struct{}
 
-func (mc mockExecutor) Execute(args []string, _root string) (string, error) {
-	if len(args) == 3 && args[2] == "success" {
-		return "", nil
+func (mc mockCmd) Run(cmd []string, _root string, _in io.Reader, _out io.Writer) error {
+	if len(cmd) == 3 && cmd[2] == "success" {
+		return nil
 	} else {
-		return "", errors.New("failure")
+		return errors.New("failure")
 	}
 }
 
 func TestDoSkip(t *testing.T) {
-	skipChecker := NewSkipChecker(mockExecutor{})
+	skipChecker := NewSkipChecker(mockCmd{})
 
 	for _, tt := range [...]struct {
 		name       string

internal/git/command_executor.go

@@ -1,33 +1,29 @@
 package git
 
 import (
+	"bytes"
 	"fmt"
 	"path/filepath"
 	"strings"
 
+	"github.com/evilmartians/lefthook/internal/log"
 	"github.com/evilmartians/lefthook/internal/system"
 )
 
-// Executor is a general execution interface for implicit commands.
-// Added here mostly for mockable tests.
-type Executor interface {
-	Execute(args []string, root string) (string, error)
-}
-
 // CommandExecutor provides some methods that take some effect on execution and/or result data.
 type CommandExecutor struct {
-	exec Executor
+	cmd  system.Command
 	root string
 }
 
 // NewExecutor returns an object that executes given commands in the OS.
-func NewExecutor(exec Executor) *CommandExecutor {
-	return &CommandExecutor{exec: exec}
+func NewExecutor(cmd system.Command) *CommandExecutor {
+	return &CommandExecutor{cmd: cmd}
 }
 
 // Cmd runs plain string command. Trims spaces around output.
-func (c CommandExecutor) Cmd(args []string) (string, error) {
-	out, err := c.exec.Execute(args, c.root)
+func (c CommandExecutor) Cmd(cmd []string) (string, error) {
+	out, err := c.execute(cmd, c.root)
 	if err != nil {
 		return "", err
 	}
@@ -55,7 +51,7 @@ func (c CommandExecutor) BatchedCmd(cmd []string, args []string) (string, error)
 
 // CmdLines runs plain string command, returns its output split by newline.
 func (c CommandExecutor) CmdLines(cmd []string) ([]string, error) {
-	out, err := c.exec.Execute(cmd, c.root)
+	out, err := c.execute(cmd, c.root)
 	if err != nil {
 		return nil, err
 	}
@@ -66,14 +62,24 @@ func (c CommandExecutor) CmdLines(cmd []string) ([]string, error) {
 // CmdLines runs plain string command, returns its output split by newline.
 func (c CommandExecutor) CmdLinesWithinFolder(cmd []string, folder string) ([]string, error) {
 	root := filepath.Join(c.root, folder)
-	out, err := c.exec.Execute(cmd, root)
+	out, err := c.execute(cmd, root)
 	if err != nil {
 		return nil, err
 	}
 
 	return strings.Split(strings.TrimSpace(out), "\n"), nil
 }
 
+func (c CommandExecutor) execute(cmd []string, root string) (string, error) {
+	out := bytes.NewBuffer(make([]byte, 0))
+	err := c.cmd.Run(cmd, root, system.NullReader, out)
+	strOut := out.String()
+
+	log.Debug("[lefthook] out: ", strOut)
+
+	return strOut, err
+}
+
 func batchByLength(s []string, length int) [][]string {
 	batches := make([][]string, 0)
 

internal/git/repository_test.go

@@ -3,21 +3,27 @@ package git
 import (
 	"errors"
 	"fmt"
+	"io"
 	"strings"
 	"testing"
 )
 
-type GitMock struct {
+type gitCmd struct {
 	cases map[string]string
 }
 
-func (g GitMock) Execute(cmd []string, _root string) (string, error) {
+func (g gitCmd) Run(cmd []string, _root string, _in io.Reader, out io.Writer) error {
 	res, ok := g.cases[(strings.Join(cmd, " "))]
 	if !ok {
-		return "", errors.New("doesn't exist")
+		return errors.New("doesn't exist")
 	}
 
-	return strings.TrimSpace(res), nil
+	_, err := out.Write([]byte(strings.TrimSpace(res)))
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func TestPartiallyStagedFiles(t *testing.T) {
@@ -37,7 +43,7 @@ MM staged but changed
 		t.Run(fmt.Sprintf("%d: %s", i, tt.name), func(t *testing.T) {
 			repository := &Repository{
 				Git: &CommandExecutor{
-					exec: GitMock{
+					cmd: gitCmd{
 						cases: map[string]string{
 							"git status --short --porcelain": tt.gitOut,
 						},

internal/lefthook/lefthook.go

@@ -51,7 +51,7 @@ func initialize(opts *Options) (*Lefthook, error) {
 
 	log.SetColors(!opts.NoColors)
 
-	repo, err := git.NewRepository(opts.Fs, git.NewExecutor(system.Executor{}))
+	repo, err := git.NewRepository(opts.Fs, git.NewExecutor(system.Cmd))
 	if err != nil {
 		return nil, err
 	}

internal/lefthook/run_test.go

@@ -2,6 +2,7 @@ package lefthook
 
 import (
 	"fmt"
+	"io"
 	"path/filepath"
 	"slices"
 	"testing"
@@ -11,10 +12,10 @@ import (
 	"github.com/evilmartians/lefthook/internal/git"
 )
 
-type GitMock struct{}
+type gitCmd struct{}
 
-func (g GitMock) Execute(_cmd []string, root string) (string, error) {
-	return "", nil
+func (g gitCmd) Run([]string, string, io.Reader, io.Writer) error {
+	return nil
 }
 
 func TestRun(t *testing.T) {
@@ -157,7 +158,7 @@ post-commit:
 				Options: &Options{Fs: fs},
 				repo: &git.Repository{
 					Fs:        fs,
-					Git:       git.NewExecutor(GitMock{}),
+					Git:       git.NewExecutor(gitCmd{}),
 					HooksPath: hooksPath,
 					RootPath:  root,
 					GitPath:   gitPath,

internal/lefthook/runner/exec/execute_unix.go

@@ -68,16 +68,6 @@ func (e CommandExecutor) Execute(ctx context.Context, opts Options, in io.Reader
 	return nil
 }
 
-func (e CommandExecutor) RawExecute(ctx context.Context, command []string, in io.Reader, out io.Writer) error {
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
-
-	cmd.Stdin = in
-	cmd.Stdout = out
-	cmd.Stderr = os.Stderr
-
-	return cmd.Run()
-}
-
 func (e CommandExecutor) execute(ctx context.Context, cmdstr string, args *executeArgs) error {
 	command := exec.CommandContext(ctx, "sh", "-c", cmdstr)
 	command.Dir = args.root

internal/lefthook/runner/exec/execute_windows.go

@@ -59,16 +59,6 @@ func (e CommandExecutor) Execute(ctx context.Context, opts Options, in io.Reader
 	return nil
 }
 
-func (e CommandExecutor) RawExecute(ctx context.Context, command []string, in io.Reader, out io.Writer) error {
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
-
-	cmd.Stdin = in
-	cmd.Stdout = out
-	cmd.Stderr = os.Stderr
-
-	return cmd.Run()
-}
-
 func (e CommandExecutor) execute(cmdstr string, args *executeArgs) error {
 	cmdargs := strings.Split(cmdstr, " ")
 	command := exec.Command(cmdargs[0])

internal/lefthook/runner/exec/executor.go

@@ -16,6 +16,5 @@ type Options struct {
 // Executor provides an interface for command execution.
 // It is used here for testing purpose mostly.
 type Executor interface {
-	Execute(ctx context.Context, opts Options, in io.Reader, out io.Writer) error
-	RawExecute(ctx context.Context, command []string, in io.Reader, out io.Writer) error
+	Execute(context.Context, Options, io.Reader, io.Writer) error
 }

internal/lefthook/runner/runner.go

@@ -25,6 +25,7 @@ import (
 	"github.com/evilmartians/lefthook/internal/lefthook/runner/exec"
 	"github.com/evilmartians/lefthook/internal/lefthook/runner/filters"
 	"github.com/evilmartians/lefthook/internal/log"
+	"github.com/evilmartians/lefthook/internal/system"
 )
 
 const (
@@ -55,6 +56,7 @@ type Runner struct {
 	partiallyStagedFiles []string
 	failed               atomic.Bool
 	executor             exec.Executor
+	cmd                  system.CommandWithContext
 }
 
 func New(opts Options) *Runner {
@@ -65,6 +67,7 @@ func New(opts Options) *Runner {
 		// and scripts access the same Git data STDIN is cached via cachedReader.
 		stdin:    NewCachedReader(os.Stdin),
 		executor: exec.CommandExecutor{},
+		cmd:      system.Cmd,
 	}
 }
 
@@ -143,12 +146,13 @@ func (r *Runner) runLFSHook(ctx context.Context) error {
 			"[git-lfs] executing hook: git lfs %s %s", r.HookName, strings.Join(r.GitArgs, " "),
 		)
 		out := bytes.NewBuffer(make([]byte, 0))
-		err := r.executor.RawExecute(
+		err := r.cmd.RunWithContext(
 			ctx,
 			append(
 				[]string{"git", "lfs", r.HookName},
 				r.GitArgs...,
 			),
+			"",
 			r.stdin,
 			out,
 		)
@@ -497,7 +501,7 @@ func (r *Runner) run(ctx context.Context, opts exec.Options, follow bool) bool {
 	defer log.UnsetName(opts.Name)
 
 	// If the command does not explicitly `use_stdin` no input will be provided.
-	var in io.Reader = NewNullReader()
+	var in io.Reader = system.NullReader
 	if opts.UseStdin {
 		in = r.stdin
 	}