From ffab5b6ac94e565303fd1176bce0b7fa10862fd7 Mon Sep 17 00:00:00 2001 From: phanium <91544758+phanen@users.noreply.github.com> Date: Sat, 25 Jul 2026 21:44:07 +0800 Subject: [PATCH] Support multi-select for ignore/exclude file binding The `i` keybinding in the files panel now accepts a range selection of nodes: every selected file is unstaged, removed from the index if it was tracked, and appended to `.gitignore` (or `.git/info/exclude` on the other menu entry) on its own line. Plumbing switched from a single node to a slice of nodes so the tracked /untracked split unstage-and-rm each path before writing the list. The single-file path keeps the existing `.gitignore`-self-ignore guard. --- pkg/gui/controllers/files_controller.go | 83 ++++++++++++------- .../tests/file/gitignore_range_select.go | 65 +++++++++++++++ pkg/integration/tests/test_list.go | 1 + 3 files changed, 117 insertions(+), 32 deletions(-) create mode 100644 pkg/integration/tests/file/gitignore_range_select.go diff --git a/pkg/gui/controllers/files_controller.go b/pkg/gui/controllers/files_controller.go index a133dac72..94c0a8132 100644 --- a/pkg/gui/controllers/files_controller.go +++ b/pkg/gui/controllers/files_controller.go @@ -105,8 +105,8 @@ func (self *FilesController) GetKeybindings(opts types.KeybindingsOpts) []*types }, { Keys: opts.GetKeys(opts.Config.Files.IgnoreFile), - Handler: self.withItem(self.ignoreOrExcludeMenu), - GetDisabledReason: self.require(self.singleItemSelected()), + Handler: self.withItems(self.ignoreOrExcludeMenu), + GetDisabledReason: self.require(self.itemsSelected()), Description: self.c.Tr.Actions.IgnoreExcludeFile, OpensMenu: true, }, @@ -971,18 +971,24 @@ func (self *FilesController) unstageFiles(node *filetree.FileNode) error { }) } -func (self *FilesController) ignoreOrExcludeTracked(node *filetree.FileNode, trAction string, f func(string) error) error { +func (self *FilesController) ignoreOrExcludeTracked(nodes []*filetree.FileNode, trAction string, f func([]string) error) error { self.c.LogAction(trAction) - // not 100% sure if this is necessary but I'll assume it is - if err := self.unstageFiles(node); err != nil { - return err + + paths := make([]string, 0, len(nodes)) + for _, node := range nodes { + // not 100% sure if this is necessary but I'll assume it is + if err := self.unstageFiles(node); err != nil { + return err + } + + if err := self.c.Git().WorkingTree.RemoveTrackedFiles(node.GetPath()); err != nil { + return err + } + + paths = append(paths, node.GetPath()) } - if err := self.c.Git().WorkingTree.RemoveTrackedFiles(node.GetPath()); err != nil { - return err - } - - if err := f(node.GetPath()); err != nil { + if err := f(paths); err != nil { return err } @@ -990,10 +996,15 @@ func (self *FilesController) ignoreOrExcludeTracked(node *filetree.FileNode, trA return nil } -func (self *FilesController) ignoreOrExcludeUntracked(node *filetree.FileNode, trAction string, f func(string) error) error { +func (self *FilesController) ignoreOrExcludeUntracked(nodes []*filetree.FileNode, trAction string, f func([]string) error) error { self.c.LogAction(trAction) - if err := f(node.GetPath()); err != nil { + paths := make([]string, 0, len(nodes)) + for _, node := range nodes { + paths = append(paths, node.GetPath()) + } + + if err := f(paths); err != nil { return err } @@ -1001,48 +1012,56 @@ func (self *FilesController) ignoreOrExcludeUntracked(node *filetree.FileNode, t return nil } -func (self *FilesController) ignoreOrExcludeFile(node *filetree.FileNode, trText string, trPrompt string, trAction string, f func(string) error) error { - if node.GetIsTracked() { +func (self *FilesController) ignoreOrExcludeFiles(nodes []*filetree.FileNode, trText string, trPrompt string, trAction string, f func([]string) error) error { + hasTracked := false + for _, node := range nodes { + if node.GetIsTracked() { + hasTracked = true + break + } + } + + if hasTracked { self.c.Confirm(types.ConfirmOpts{ Title: trText, Prompt: trPrompt, HandleConfirm: func() error { - return self.ignoreOrExcludeTracked(node, trAction, f) + return self.ignoreOrExcludeTracked(nodes, trAction, f) }, }) return nil } - return self.ignoreOrExcludeUntracked(node, trAction, f) + return self.ignoreOrExcludeUntracked(nodes, trAction, f) } -func (self *FilesController) ignore(node *filetree.FileNode) error { - if node.GetPath() == ".gitignore" { - return errors.New(self.c.Tr.Actions.IgnoreFileErr) +func (self *FilesController) ignore(nodes []*filetree.FileNode) error { + for _, node := range nodes { + if node.GetPath() == ".gitignore" { + return errors.New(self.c.Tr.Actions.IgnoreFileErr) + } } - return self.ignoreOrExcludeFile(node, self.c.Tr.IgnoreTracked, self.c.Tr.IgnoreTrackedPrompt, self.c.Tr.Actions.IgnoreExcludeFile, func(name string) error { - return self.c.Git().WorkingTree.Ignore([]string{name}) - }) + return self.ignoreOrExcludeFiles(nodes, self.c.Tr.IgnoreTracked, self.c.Tr.IgnoreTrackedPrompt, self.c.Tr.Actions.IgnoreExcludeFile, self.c.Git().WorkingTree.Ignore) } -func (self *FilesController) exclude(node *filetree.FileNode) error { - if node.GetPath() == ".gitignore" { - return errors.New(self.c.Tr.Actions.ExcludeGitIgnoreErr) +func (self *FilesController) exclude(nodes []*filetree.FileNode) error { + for _, node := range nodes { + if node.GetPath() == ".gitignore" { + return errors.New(self.c.Tr.Actions.ExcludeGitIgnoreErr) + } } - return self.ignoreOrExcludeFile(node, self.c.Tr.ExcludeTracked, self.c.Tr.ExcludeTrackedPrompt, self.c.Tr.Actions.ExcludeFile, func(name string) error { - return self.c.Git().WorkingTree.Exclude([]string{name}) - }) + return self.ignoreOrExcludeFiles(nodes, self.c.Tr.ExcludeTracked, self.c.Tr.ExcludeTrackedPrompt, self.c.Tr.Actions.ExcludeFile, self.c.Git().WorkingTree.Exclude) } -func (self *FilesController) ignoreOrExcludeMenu(node *filetree.FileNode) error { +func (self *FilesController) ignoreOrExcludeMenu(nodes []*filetree.FileNode) error { return self.c.Menu(types.CreateMenuOptions{ Title: self.c.Tr.Actions.IgnoreExcludeFile, Items: []*types.MenuItem{ { LabelColumns: []string{self.c.Tr.IgnoreFile}, OnPress: func() error { - if err := self.ignore(node); err != nil { + if err := self.ignore(nodes); err != nil { return err } return nil @@ -1052,7 +1071,7 @@ func (self *FilesController) ignoreOrExcludeMenu(node *filetree.FileNode) error { LabelColumns: []string{self.c.Tr.ExcludeFile}, OnPress: func() error { - if err := self.exclude(node); err != nil { + if err := self.exclude(nodes); err != nil { return err } return nil diff --git a/pkg/integration/tests/file/gitignore_range_select.go b/pkg/integration/tests/file/gitignore_range_select.go new file mode 100644 index 000000000..4d41a6760 --- /dev/null +++ b/pkg/integration/tests/file/gitignore_range_select.go @@ -0,0 +1,65 @@ +package file + +import ( + "github.com/jesseduffield/lazygit/pkg/config" + . "github.com/jesseduffield/lazygit/pkg/integration/components" +) + +var GitignoreRangeSelect = NewIntegrationTest(NewIntegrationTestArgs{ + Description: "Ignore and exclude multiple files at once via range select", + ExtraCmdArgs: []string{}, + Skip: false, + SetupConfig: func(config *config.AppConfig) { + }, + SetupRepo: func(shell *Shell) { + shell.CreateFile(".gitignore", "") + shell.CreateFile("toIgnore1", "") + shell.CreateFile("toIgnore2", "") + shell.CreateFile("toIgnore3", "") + shell.CreateFile("toExclude1", "") + shell.CreateFile("toExclude2", "") + shell.CreateFile("toExclude3", "") + }, + Run: func(t *TestDriver, keys config.KeybindingConfig) { + t.Views().Files(). + IsFocused(). + Lines( + Equals("▼ /").IsSelected(), + Equals(" ?? .gitignore"), + Equals(" ?? toExclude1"), + Equals(" ?? toExclude2"), + Equals(" ?? toExclude3"), + Equals(" ?? toIgnore1"), + Equals(" ?? toIgnore2"), + Equals(" ?? toIgnore3"), + ). + // Select range from toIgnore1 to toIgnore3 + NavigateToLine(Contains("toIgnore1")). + Press(keys.Universal.ToggleRangeSelect). + NavigateToLine(Contains("toIgnore3")). + Press(keys.Files.IgnoreFile). + // Ignore all selected files + Tap(func() { + t.ExpectPopup().Menu().Title(Equals("Ignore or exclude file")). + Select(Contains("Add to .gitignore")). + Confirm() + + t.FileSystem().FileContent(".gitignore", Equals("/toIgnore1\n/toIgnore2\n/toIgnore3\n")) + }). + // Dismiss the range select mode for the next set of steps + Press(keys.Universal.ToggleRangeSelect). + // Select range from toExclude1 to toExclude3 + NavigateToLine(Contains("toExclude1")). + Press(keys.Universal.ToggleRangeSelect). + NavigateToLine(Contains("toExclude3")). + Press(keys.Files.IgnoreFile). + // Exclude all selected files + Tap(func() { + t.ExpectPopup().Menu().Title(Equals("Ignore or exclude file")). + Select(Contains("Add to .git/info/exclude")). + Confirm() + + t.FileSystem().FileContent(".git/info/exclude", Contains("/toExclude1\n/toExclude2\n/toExclude3\n")) + }) + }, +}) diff --git a/pkg/integration/tests/test_list.go b/pkg/integration/tests/test_list.go index 1bb06741f..a6e9771e0 100644 --- a/pkg/integration/tests/test_list.go +++ b/pkg/integration/tests/test_list.go @@ -240,6 +240,7 @@ var tests = []*components.IntegrationTest{ file.DiscardVariousChangesRangeSelect, file.ExcludeWithoutInfoDir, file.Gitignore, + file.GitignoreRangeSelect, file.GitignoreSpecialCharacters, file.RememberCommitMessageAfterFail, file.RenameSimilarityThresholdChange,