Improve resolving non-textual and submodule merge conflicts

AGENTS.md

@@ -252,6 +252,30 @@ keep the call site fluent.
 Prefer `assert.Equal` (and friends) over hand-rolled `if` checks. The failure
 messages are more useful and the intent is clearer at a glance.
 
+## Translatable strings use Go templates, not `%s`
+
+Never put `fmt.Sprintf`-style placeholders (`%s`, `%d`, …) in translatable
+strings — the fields of `TranslationSet` and `Actions` in
+`pkg/i18n/english.go`. Use named Go-template placeholders and fill them in with
+`utils.ResolvePlaceholderString`:
+
+```go
+// in english.go
+DeleteBranchTitle: "Delete branch '{{.selectedBranchName}}'?",
+
+// at the call site
+utils.ResolvePlaceholderString(
+    self.c.Tr.DeleteBranchTitle,
+    map[string]string{"selectedBranchName": branchName},
+)
+```
+
+Named placeholders tell localizers what each value is (a bare `%s` says
+nothing, and translators can't safely reorder positional verbs across
+languages), and the map form extends cleanly when a string later needs more
+than one placeholder. This holds for every user-facing string, including short
+ones like disabled-action reasons and toasts.
+
 ## Code comments are for future readers, not development history
 
 Comments in source code explain *why this code is shaped the way it is*. They

pkg/commands/git_commands/submodule.go

@@ -111,6 +111,72 @@ func (self *SubmoduleCommands) AnyHaveStageableChanges(paths []string) (bool, er
 	}), nil
 }
 
+// GetConflictCommits returns the three gitlink commits of a conflicted submodule
+// from the index: the merge base, our (current) commit, and their (incoming)
+// commit. Any of them can be empty if that stage is absent (e.g. a submodule
+// that was added on only one side). The path is relative to the repo root.
+func (self *SubmoduleCommands) GetConflictCommits(path string) (base string, ours string, theirs string, err error) {
+	cmdArgs := NewGitCmd("ls-files").Arg("-u", "-z", "--", path).ToArgv()
+	output, err := self.cmd.New(cmdArgs).DontLog().RunWithOutput()
+	if err != nil {
+		return "", "", "", err
+	}
+
+	// Each NUL-terminated entry looks like "<mode> <sha> <stage>\t<path>".
+	for _, entry := range strings.Split(output, "\x00") {
+		// fields are split on the tab and the spaces, so the leading three are
+		// always mode, sha, stage regardless of what the path contains.
+		fields := strings.Fields(entry)
+		if len(fields) < 3 {
+			continue
+		}
+		switch fields[2] {
+		case "1":
+			base = fields[1]
+		case "2":
+			ours = fields[1]
+		case "3":
+			theirs = fields[1]
+		}
+	}
+
+	return base, ours, theirs, nil
+}
+
+// GetCommitSummary returns "<short-sha> <subject>" for a commit inside the
+// submodule at the given path, for display in the conflict menu.
+func (self *SubmoduleCommands) GetCommitSummary(path string, sha string) (string, error) {
+	cmdArgs := NewGitCmd("log").
+		Dir(path).
+		Arg("--format=%h %s", "--max-count=1", sha).
+		Config("log.showsignature=false").
+		ToArgv()
+
+	summary, err := self.cmd.New(cmdArgs).DontLog().RunWithOutput()
+	return strings.TrimSpace(summary), err
+}
+
+// CheckoutConflictCommit resolves a submodule conflict by checking the submodule
+// out at the given commit. `git checkout --ours/--theirs` is a no-op on
+// gitlinks, so we check out the chosen commit in the submodule itself; the
+// caller then stages the submodule to record the resolution.
+func (self *SubmoduleCommands) CheckoutConflictCommit(path string, sha string) error {
+	cmdArgs := NewGitCmd("checkout").Dir(path).Arg(sha).ToArgv()
+	return self.cmd.New(cmdArgs).Run()
+}
+
+// ConflictSideLog returns a oneline log, run inside the submodule, of the commits
+// that `side` has but `otherSide` does not (i.e. `otherSide..side`) — the commits
+// unique to one side of a commit conflict, relative to their common ancestor. It
+// is empty if `side` is an ancestor of `otherSide` (e.g. that side was rewound).
+func (self *SubmoduleCommands) ConflictSideLog(path string, side string, otherSide string) (string, error) {
+	cmdArgs := NewGitCmd("log").Dir(path).
+		Arg("--oneline", "--color=always", otherSide+".."+side).
+		ToArgv()
+
+	return self.cmd.New(cmdArgs).DontLog().RunWithOutput()
+}
+
 func (self *SubmoduleCommands) Stash(submodule *models.SubmoduleConfig) error {
 	// if the path does not exist then it hasn't yet been initialized so we'll swallow the error
 	// because the intention here is to have no dirty worktree state

pkg/commands/git_commands/submodule_test.go

@@ -0,0 +1,92 @@
+package git_commands
+
+import (
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSubmoduleGetConflictCommits(t *testing.T) {
+	type scenario struct {
+		testName       string
+		output         string
+		expectedBase   string
+		expectedOurs   string
+		expectedTheirs string
+	}
+
+	scenarios := []scenario{
+		{
+			testName:       "all three stages present (both modified)",
+			output:         "160000 aaaaaaa 1\tmysub\x00160000 bbbbbbb 2\tmysub\x00160000 ccccccc 3\tmysub\x00",
+			expectedBase:   "aaaaaaa",
+			expectedOurs:   "bbbbbbb",
+			expectedTheirs: "ccccccc",
+		},
+		{
+			testName:       "only our and their stages (added on both sides)",
+			output:         "160000 bbbbbbb 2\tmysub\x00160000 ccccccc 3\tmysub\x00",
+			expectedBase:   "",
+			expectedOurs:   "bbbbbbb",
+			expectedTheirs: "ccccccc",
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			runner := oscommands.NewFakeRunner(t).
+				ExpectGitArgs([]string{"ls-files", "-u", "-z", "--", "mysub"}, s.output, nil)
+			instance := buildSubmoduleCommands(commonDeps{runner: runner})
+
+			base, ours, theirs, err := instance.GetConflictCommits("mysub")
+			assert.NoError(t, err)
+			assert.Equal(t, s.expectedBase, base)
+			assert.Equal(t, s.expectedOurs, ours)
+			assert.Equal(t, s.expectedTheirs, theirs)
+			runner.CheckForMissingCalls()
+		})
+	}
+}
+
+func TestSubmoduleGetConflictCommitsError(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"ls-files", "-u", "-z", "--", "mysub"}, "", errors.New("error"))
+	instance := buildSubmoduleCommands(commonDeps{runner: runner})
+
+	_, _, _, err := instance.GetConflictCommits("mysub")
+	assert.Error(t, err)
+	runner.CheckForMissingCalls()
+}
+
+func TestSubmoduleGetCommitSummary(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"-c", "log.showsignature=false", "-C", "mysub", "log", "--format=%h %s", "--max-count=1", "bbbbbbb"}, "bbbbbbb the subject\n", nil)
+	instance := buildSubmoduleCommands(commonDeps{runner: runner})
+
+	summary, err := instance.GetCommitSummary("mysub", "bbbbbbb")
+	assert.NoError(t, err)
+	assert.Equal(t, "bbbbbbb the subject", summary)
+	runner.CheckForMissingCalls()
+}
+
+func TestSubmoduleCheckoutConflictCommit(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"-C", "mysub", "checkout", "bbbbbbb"}, "", nil)
+	instance := buildSubmoduleCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.CheckoutConflictCommit("mysub", "bbbbbbb"))
+	runner.CheckForMissingCalls()
+}
+
+func TestSubmoduleConflictSideLog(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"-C", "mysub", "log", "--oneline", "--color=always", "ccccccc..bbbbbbb"}, "bbbbbbb left\n", nil)
+	instance := buildSubmoduleCommands(commonDeps{runner: runner})
+
+	output, err := instance.ConflictSideLog("mysub", "bbbbbbb", "ccccccc")
+	assert.NoError(t, err)
+	assert.Equal(t, "bbbbbbb left\n", output)
+	runner.CheckForMissingCalls()
+}