feat: add skip option merge-commit (#850)

* feat: add skip merge commit option

* refactor: tests

* docs: add skip option merge-commit

* docs: give a list of possible skip options

.golangci.yml

@@ -44,7 +44,6 @@ linters:
     - errname
     - errorlint
     - exhaustive
-    - exportloopref
     - forbidigo
     - gci
     - gochecknoinits

docs/configuration.md

@@ -799,6 +799,13 @@ pre-commit:
 
 You can skip all or specific commands and scripts using `skip` option. You can also skip when merging, rebasing, or being on a specific branch. Globs are available for branches.
 
+Possible skip values:
+- `rebase` - when in rebase git state
+- `merge` - when in merge git state
+- `merge-commit` - when current HEAD commit is the merge commit
+- `ref: main` - when on a `main` branch
+- `run: test ${SKIP_ME} -eq 1` - when `test ${SKIP_ME} -eq 1` is successful (return code is 0)
+
 **Example**
 
 Always skipping a command:
@@ -839,6 +846,18 @@ pre-commit:
       run: yarn lint
 ```
 
+Skipping when your are on a merge commit:
+
+```yml
+# lefthook.yml
+
+pre-push:
+  commands:
+    lint:
+      skip: merge-commit
+      run: yarn lint
+```
+
 Skipping the whole hook on `main` branch:
 
 ```yml

internal/config/command.go

@@ -46,9 +46,9 @@ func (c Command) Validate() error {
 	return nil
 }
 
-func (c Command) DoSkip(gitState git.State) bool {
+func (c Command) DoSkip(state func() git.State) bool {
 	skipChecker := NewSkipChecker(system.Cmd)
-	return skipChecker.check(gitState, c.Skip, c.Only)
+	return skipChecker.check(state, c.Skip, c.Only)
 }
 
 func (c Command) ExecutionPriority() int {

internal/config/hook.go

@@ -43,9 +43,9 @@ func (h *Hook) Validate() error {
 	return nil
 }
 
-func (h *Hook) DoSkip(gitState git.State) bool {
+func (h *Hook) DoSkip(state func() git.State) bool {
 	skipChecker := NewSkipChecker(system.Cmd)
-	return skipChecker.check(gitState, h.Skip, h.Only)
+	return skipChecker.check(state, h.Skip, h.Only)
 }
 
 func unmarshalHooks(base, extra *viper.Viper) (*Hook, error) {

internal/config/script.go

@@ -29,9 +29,9 @@ type scriptRunnerReplace struct {
 	Runner string `mapstructure:"runner"`
 }
 
-func (s Script) DoSkip(gitState git.State) bool {
+func (s Script) DoSkip(state func() git.State) bool {
 	skipChecker := NewSkipChecker(system.Cmd)
-	return skipChecker.check(gitState, s.Skip, s.Only)
+	return skipChecker.check(state, s.Skip, s.Only)
 }
 
 func (s Script) ExecutionPriority() int {

internal/config/skip_checker.go

@@ -17,37 +17,41 @@ func NewSkipChecker(cmd system.Command) *skipChecker {
 }
 
 // check returns the result of applying a skip/only setting which can be a branch, git state, shell command, etc.
-func (sc *skipChecker) check(gitState git.State, skip interface{}, only interface{}) bool {
+func (sc *skipChecker) check(state func() git.State, skip interface{}, only interface{}) bool {
+	if skip == nil && only == nil {
+		return false
+	}
+
 	if skip != nil {
-		if sc.matches(gitState, skip) {
+		if sc.matches(state, skip) {
 			return true
 		}
 	}
 
 	if only != nil {
-		return !sc.matches(gitState, only)
+		return !sc.matches(state, only)
 	}
 
 	return false
 }
 
-func (sc *skipChecker) matches(gitState git.State, value interface{}) bool {
+func (sc *skipChecker) matches(state func() git.State, value interface{}) bool {
 	switch typedValue := value.(type) {
 	case bool:
 		return typedValue
 	case string:
-		return typedValue == gitState.Step
+		return typedValue == state().State
 	case []interface{}:
-		return sc.matchesSlices(gitState, typedValue)
+		return sc.matchesSlices(state, typedValue)
 	}
 	return false
 }
 
-func (sc *skipChecker) matchesSlices(gitState git.State, slice []interface{}) bool {
+func (sc *skipChecker) matchesSlices(gitState func() git.State, slice []interface{}) bool {
 	for _, state := range slice {
 		switch typedState := state.(type) {
 		case string:
-			if typedState == gitState.Step {
+			if typedState == gitState().State {
 				return true
 			}
 		case map[string]interface{}:
@@ -64,19 +68,20 @@ func (sc *skipChecker) matchesSlices(gitState git.State, slice []interface{}) bo
 	return false
 }
 
-func (sc *skipChecker) matchesRef(gitState git.State, typedState map[string]interface{}) bool {
+func (sc *skipChecker) matchesRef(state func() git.State, typedState map[string]interface{}) bool {
 	ref, ok := typedState["ref"].(string)
 	if !ok {
 		return false
 	}
 
-	if ref == gitState.Branch {
+	branch := state().Branch
+	if ref == branch {
 		return true
 	}
 
 	g := glob.MustCompile(ref)
 
-	return g.Match(gitState.Branch)
+	return g.Match(branch)
 }
 
 func (sc *skipChecker) matchesCommands(typedState map[string]interface{}) bool {

internal/config/skip_checker_test.go

@@ -23,123 +23,129 @@ func TestDoSkip(t *testing.T) {
 
 	for _, tt := range [...]struct {
 		name       string
-		state      git.State
+		state      func() git.State
 		skip, only interface{}
 		skipped    bool
 	}{
 		{
 			name:    "when true",
-			state:   git.State{},
+			state:   func() git.State { return git.State{} },
 			skip:    true,
 			skipped: true,
 		},
 		{
 			name:    "when false",
-			state:   git.State{},
+			state:   func() git.State { return git.State{} },
 			skip:    false,
 			skipped: false,
 		},
 		{
 			name:    "when merge",
-			state:   git.State{Step: "merge"},
+			state:   func() git.State { return git.State{State: "merge"} },
 			skip:    "merge",
 			skipped: true,
 		},
+		{
+			name:    "when merge-commit",
+			state:   func() git.State { return git.State{State: "merge-commit"} },
+			skip:    "merge-commit",
+			skipped: true,
+		},
 		{
 			name:    "when rebase (but want merge)",
-			state:   git.State{Step: "rebase"},
+			state:   func() git.State { return git.State{State: "rebase"} },
 			skip:    "merge",
 			skipped: false,
 		},
 		{
 			name:    "when rebase",
-			state:   git.State{Step: "rebase"},
+			state:   func() git.State { return git.State{State: "rebase"} },
 			skip:    []interface{}{"rebase"},
 			skipped: true,
 		},
 		{
 			name:    "when rebase (but want merge)",
-			state:   git.State{Step: "rebase"},
+			state:   func() git.State { return git.State{State: "rebase"} },
 			skip:    []interface{}{"merge"},
 			skipped: false,
 		},
 		{
 			name:    "when branch",
-			state:   git.State{Branch: "feat/skipme"},
+			state:   func() git.State { return git.State{Branch: "feat/skipme"} },
 			skip:    []interface{}{map[string]interface{}{"ref": "feat/skipme"}},
 			skipped: true,
 		},
 		{
 			name:    "when branch doesn't match",
-			state:   git.State{Branch: "feat/important"},
+			state:   func() git.State { return git.State{Branch: "feat/important"} },
 			skip:    []interface{}{map[string]interface{}{"ref": "feat/skipme"}},
 			skipped: false,
 		},
 		{
 			name:    "when branch glob",
-			state:   git.State{Branch: "feat/important"},
+			state:   func() git.State { return git.State{Branch: "feat/important"} },
 			skip:    []interface{}{map[string]interface{}{"ref": "feat/*"}},
 			skipped: true,
 		},
 		{
 			name:    "when branch glob doesn't match",
-			state:   git.State{Branch: "feat"},
+			state:   func() git.State { return git.State{Branch: "feat"} },
 			skip:    []interface{}{map[string]interface{}{"ref": "feat/*"}},
 			skipped: false,
 		},
 		{
 			name:    "when only specified",
-			state:   git.State{Branch: "feat"},
+			state:   func() git.State { return git.State{Branch: "feat"} },
 			only:    []interface{}{map[string]interface{}{"ref": "feat"}},
 			skipped: false,
 		},
 		{
 			name:    "when only branch doesn't match",
-			state:   git.State{Branch: "dev"},
+			state:   func() git.State { return git.State{Branch: "dev"} },
 			only:    []interface{}{map[string]interface{}{"ref": "feat"}},
 			skipped: true,
 		},
 		{
 			name:    "when only branch with glob",
-			state:   git.State{Branch: "feat/important"},
+			state:   func() git.State { return git.State{Branch: "feat/important"} },
 			only:    []interface{}{map[string]interface{}{"ref": "feat/*"}},
 			skipped: false,
 		},
 		{
 			name:    "when only merge",
-			state:   git.State{Step: "merge"},
+			state:   func() git.State { return git.State{State: "merge"} },
 			only:    []interface{}{"merge"},
 			skipped: false,
 		},
 		{
 			name:    "when only and skip",
-			state:   git.State{Step: "rebase"},
+			state:   func() git.State { return git.State{State: "rebase"} },
 			skip:    []interface{}{map[string]interface{}{"ref": "feat/*"}},
 			only:    "rebase",
 			skipped: false,
 		},
 		{
 			name:    "when only and skip applies skip",
-			state:   git.State{Step: "rebase"},
+			state:   func() git.State { return git.State{State: "rebase"} },
 			skip:    []interface{}{"rebase"},
 			only:    "rebase",
 			skipped: true,
 		},
 		{
 			name:    "when skip with run command",
-			state:   git.State{},
+			state:   func() git.State { return git.State{} },
 			skip:    []interface{}{map[string]interface{}{"run": "success"}},
 			skipped: true,
 		},
 		{
 			name:    "when skip with multi-run command",
-			state:   git.State{Branch: "feat"},
+			state:   func() git.State { return git.State{Branch: "feat"} },
 			skip:    []interface{}{map[string]interface{}{"run": "success", "ref": "feat"}},
 			skipped: true,
 		},
 		{
 			name:    "when only with run command",
-			state:   git.State{},
+			state:   func() git.State { return git.State{} },
 			only:    []interface{}{map[string]interface{}{"run": "fail"}},
 			skipped: true,
 		},

internal/git/state.go

@@ -5,38 +5,68 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strings"
 )
 
 type State struct {
-	Branch, Step string
+	Branch, State string
 }
 
 const (
-	NilStep    string = ""
-	MergeStep  string = "merge"
-	RebaseStep string = "rebase"
+	Nil         string = ""
+	Merge       string = "merge"
+	MergeCommit string = "merge-commit"
+	Rebase      string = "rebase"
 )
 
-var refBranchRegexp = regexp.MustCompile(`^ref:\s*refs/heads/(.+)$`)
+var (
+	refBranchRegexp  = regexp.MustCompile(`^ref:\s*refs/heads/(.+)$`)
+	cmdParentCommits = []string{"git", "show", "--no-patch", `--format="%P"`}
+)
+
+var (
+	state            State
+	stateInitialized bool
+)
+
+func ResetState() {
+	stateInitialized = false
+}
 
 func (r *Repository) State() State {
+	if stateInitialized {
+		return state
+	}
+
+	stateInitialized = true
 	branch := r.Branch()
 	if r.inMergeState() {
-		return State{
+		state = State{
 			Branch: branch,
-			Step:   MergeStep,
+			State:  Merge,
 		}
+		return state
 	}
 	if r.inRebaseState() {
-		return State{
+		state = State{
 			Branch: branch,
-			Step:   RebaseStep,
+			State:  Rebase,
 		}
+		return state
 	}
-	return State{
+	if r.inMergeCommitState() {
+		state = State{
+			Branch: branch,
+			State:  MergeCommit,
+		}
+		return state
+	}
+
+	state = State{
 		Branch: branch,
-		Step:   NilStep,
+		State:  Nil,
 	}
+	return state
 }
 
 func (r *Repository) Branch() string {
@@ -81,3 +111,12 @@ func (r *Repository) inRebaseState() bool {
 
 	return true
 }
+
+func (r *Repository) inMergeCommitState() bool {
+	parents, err := r.Git.Cmd(cmdParentCommits)
+	if err != nil {
+		return false
+	}
+
+	return strings.Contains(parents, " ")
+}