trim down gitcommand struct some more

pkg/commands/custom.go

@@ -0,0 +1,29 @@
+package commands
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type CustomCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewCustomCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *CustomCommands {
+	return &CustomCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+// Only to be used for the sake of running custom commands specified by the user.
+// If you want to run a new command, try finding a place for it in one of the neighbouring
+// files, or creating a new BlahCommands struct to hold it.
+func (self *CustomCommands) RunWithOutput(cmdStr string) (string, error) {
+	return self.cmd.New(cmdStr).RunWithOutput()
+}

pkg/commands/git.go

@@ -22,8 +22,6 @@ import (
 type GitCommand struct {
 	Loaders Loaders
 
-	Cmd oscommands.ICmdObjBuilder
-
 	Submodule   *SubmoduleCommands
 	Tag         *TagCommands
 	WorkingTree *WorkingTreeCommands
@@ -38,6 +36,7 @@ type GitCommand struct {
 	Remote      *RemoteCommands
 	Sync        *SyncCommands
 	Flow        *FlowCommands
+	Custom      *CustomCommands
 }
 
 type Loaders struct {
@@ -101,6 +100,7 @@ func NewGitCommandAux(
 	syncCommands := NewSyncCommands(cmn, cmd)
 	tagCommands := NewTagCommands(cmn, cmd)
 	commitCommands := NewCommitCommands(cmn, cmd)
+	customCommands := NewCustomCommands(cmn, cmd)
 	fileCommands := NewFileCommands(cmn, cmd, configCommands, osCommand)
 	submoduleCommands := NewSubmoduleCommands(cmn, cmd, dotGitDir)
 	workingTreeCommands := NewWorkingTreeCommands(cmn, cmd, submoduleCommands, osCommand, fileLoader)
@@ -119,8 +119,6 @@ func NewGitCommandAux(
 	patchCommands := NewPatchCommands(cmn, cmd, rebaseCommands, commitCommands, configCommands, statusCommands, patchManager)
 
 	return &GitCommand{
-		Cmd: cmd,
-
 		Submodule:   submoduleCommands,
 		Tag:         tagCommands,
 		WorkingTree: workingTreeCommands,
@@ -135,6 +133,7 @@ func NewGitCommandAux(
 		Remote:      remoteCommands,
 		Sync:        syncCommands,
 		Flow:        flowCommands,
+		Custom:      customCommands,
 		Loaders: Loaders{
 			Commits:       loaders.NewCommitLoader(cmn, cmd, dotGitDir, branchCommands.CurrentBranchName, statusCommands.RebaseMode),
 			Branches:      loaders.NewBranchLoader(cmn, branchCommands.GetRawBranches, branchCommands.CurrentBranchName),

pkg/commands/rebasing.go

@@ -225,9 +225,11 @@ func (self *RebaseCommands) MoveTodoDown(index int) error {
 // SquashAllAboveFixupCommits squashes all fixup! commits above the given one
 func (self *RebaseCommands) SquashAllAboveFixupCommits(sha string) error {
 	return self.runSkipEditorCommand(
-		fmt.Sprintf(
-			"git rebase --interactive --autostash --autosquash %s^",
-			sha,
+		self.cmd.New(
+			fmt.Sprintf(
+				"git rebase --interactive --autostash --autosquash %s^",
+				sha,
+			),
 		),
 	)
 }
@@ -269,16 +271,14 @@ func (self *RebaseCommands) RebaseBranch(branchName string) error {
 	return cmdObj.Run()
 }
 
+func (self *RebaseCommands) GenericMergeOrRebaseActionCmdObj(commandType string, command string) oscommands.ICmdObj {
+	return self.cmd.New("git " + commandType + " --" + command)
+}
+
 // GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
 // By default we skip the editor in the case where a commit will be made
 func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, command string) error {
-	err := self.runSkipEditorCommand(
-		fmt.Sprintf(
-			"git %s --%s",
-			commandType,
-			command,
-		),
-	)
+	err := self.runSkipEditorCommand(self.GenericMergeOrRebaseActionCmdObj(commandType, command))
 	if err != nil {
 		if !strings.Contains(err.Error(), "no rebase in progress") {
 			return err
@@ -300,8 +300,7 @@ func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, comma
 	return nil
 }
 
-func (self *RebaseCommands) runSkipEditorCommand(command string) error {
-	cmdObj := self.cmd.New(command)
+func (self *RebaseCommands) runSkipEditorCommand(cmdObj oscommands.ICmdObj) error {
 	lazyGitPath := oscommands.GetLazygitPath()
 	return cmdObj.
 		AddEnvVars(

pkg/gui/custom_commands.go

@@ -203,7 +203,7 @@ func (gui *Gui) menuPromptFromCommand(prompt config.CustomCommandPrompt, promptR
 	}
 
 	// Run and save output
-	message, err := gui.GitCommand.Cmd.New(cmdStr).RunWithOutput()
+	message, err := gui.GitCommand.Custom.RunWithOutput(cmdStr)
 	if err != nil {
 		return gui.surfaceError(err)
 	}

pkg/gui/git_flow.go

@@ -6,16 +6,6 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-func (gui *Gui) gitFlowFinishBranch(branchName string) error {
-	cmdObj, err := gui.GitCommand.Flow.FinishCmdObj(branchName)
-	if err != nil {
-		return gui.surfaceError(err)
-	}
-
-	gui.logAction(gui.Tr.Actions.GitFlowFinish)
-	return gui.runSubprocessWithSuspenseAndRefresh(cmdObj)
-}
-
 func (gui *Gui) handleCreateGitFlowMenu() error {
 	branch := gui.getSelectedBranch()
 	if branch == nil {
@@ -70,3 +60,13 @@ func (gui *Gui) handleCreateGitFlowMenu() error {
 
 	return gui.createMenu("git flow", menuItems, createMenuOptions{})
 }
+
+func (gui *Gui) gitFlowFinishBranch(branchName string) error {
+	cmdObj, err := gui.GitCommand.Flow.FinishCmdObj(branchName)
+	if err != nil {
+		return gui.surfaceError(err)
+	}
+
+	gui.logAction(gui.Tr.Actions.GitFlowFinish)
+	return gui.runSubprocessWithSuspenseAndRefresh(cmdObj)
+}

pkg/gui/rebase_options_panel.go

@@ -65,11 +65,10 @@ func (gui *Gui) genericMergeCommand(command string) error {
 
 	// it's impossible for a rebase to require a commit so we'll use a subprocess only if it's a merge
 	if status == enums.REBASE_MODE_MERGING && command != REBASE_OPTION_ABORT && gui.UserConfig.Git.Merging.ManualCommit {
-		sub := gui.GitCommand.Cmd.New("git " + commandType + " --" + command)
-		if sub != nil {
-			return gui.runSubprocessWithSuspenseAndRefresh(sub)
-		}
-		return nil
+		// TODO: see if we should be calling more of the code from gui.GitCommand.Rebase.GenericMergeOrRebaseAction
+		return gui.runSubprocessWithSuspenseAndRefresh(
+			gui.GitCommand.Rebase.GenericMergeOrRebaseActionCmdObj(commandType, command),
+		)
 	}
 	result := gui.GitCommand.Rebase.GenericMergeOrRebaseAction(commandType, command)
 	if err := gui.handleGenericMergeCommandResult(result); err != nil {