Add key binding for switching from the commit message panel to an editor

This is useful for when you begin to type the message in lazygit's commit panel,
and then realize that you'd rather use your editor's more powerful editing
capabilities. Pressing <c-o> will take you right there.

pkg/gui/controllers/commit_description_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )
 
@@ -34,6 +35,10 @@ func (self *CommitDescriptionController) GetKeybindings(opts types.KeybindingsOp
 			Key:     opts.GetKey(opts.Config.Universal.ConfirmInEditor),
 			Handler: self.confirm,
 		},
+		{
+			Key:     opts.GetKey(opts.Config.CommitMessage.SwitchToEditor),
+			Handler: self.switchToEditor,
+		},
 	}
 
 	return bindings
@@ -43,7 +48,7 @@ func (self *CommitDescriptionController) Context() types.Context {
 	return self.context()
 }
 
-func (self *CommitDescriptionController) context() types.Context {
+func (self *CommitDescriptionController) context() *context.CommitMessageContext {
 	return self.c.Contexts().CommitMessage
 }
 
@@ -58,3 +63,7 @@ func (self *CommitDescriptionController) close() error {
 func (self *CommitDescriptionController) confirm() error {
 	return self.c.Helpers().Commits.HandleCommitConfirm()
 }
+
+func (self *CommitDescriptionController) switchToEditor() error {
+	return self.c.Helpers().Commits.SwitchToEditor()
+}

pkg/gui/controllers/commit_message_controller.go

@@ -46,6 +46,10 @@ func (self *CommitMessageController) GetKeybindings(opts types.KeybindingsOpts)
 			Key:     opts.GetKey(opts.Config.Universal.TogglePanel),
 			Handler: self.switchToCommitDescription,
 		},
+		{
+			Key:     opts.GetKey(opts.Config.CommitMessage.SwitchToEditor),
+			Handler: self.switchToEditor,
+		},
 	}
 
 	return bindings
@@ -84,6 +88,10 @@ func (self *CommitMessageController) switchToCommitDescription() error {
 	return nil
 }
 
+func (self *CommitMessageController) switchToEditor() error {
+	return self.c.Helpers().Commits.SwitchToEditor()
+}
+
 func (self *CommitMessageController) handleCommitIndexChange(value int) error {
 	currentIndex := self.context().GetSelectedIndex()
 	newIndex := currentIndex + value

pkg/gui/controllers/helpers/commits_helper.go

@@ -1,9 +1,12 @@
 package helpers
 
 import (
+	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/samber/lo"
 )
 
 type ICommitsHelper interface {
@@ -62,6 +65,28 @@ func (self *CommitsHelper) JoinCommitMessageAndDescription() string {
 	return self.getCommitSummary() + "\n" + self.getCommitDescription()
 }
 
+func (self *CommitsHelper) SwitchToEditor() error {
+	if !self.c.Contexts().CommitMessage.CanSwitchToEditor() {
+		return nil
+	}
+
+	message := lo.Ternary(len(self.getCommitDescription()) == 0,
+		self.getCommitSummary(),
+		self.getCommitSummary()+"\n\n"+self.getCommitDescription())
+	filepath := filepath.Join(self.c.OS().GetTempDir(), self.c.Git().RepoPaths.RepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".msg")
+	err := self.c.OS().CreateFileWithContent(filepath, message)
+	if err != nil {
+		return err
+	}
+
+	err = self.CloseCommitMessagePanel()
+	if err != nil {
+		return err
+	}
+
+	return self.c.Contexts().CommitMessage.SwitchToEditor(filepath)
+}
+
 func (self *CommitsHelper) UpdateCommitPanelView(message string) {
 	if message != "" {
 		self.SetMessageAndDescriptionInView(message)
@@ -83,6 +108,7 @@ type OpenCommitMessagePanelOpts struct {
 	DescriptionTitle string
 	PreserveMessage  bool
 	OnConfirm        func(summary string, description string) error
+	OnSwitchToEditor func(string) error
 	InitialMessage   string
 }
 
@@ -101,6 +127,7 @@ func (self *CommitsHelper) OpenCommitMessagePanel(opts *OpenCommitMessagePanelOp
 		opts.DescriptionTitle,
 		opts.PreserveMessage,
 		onConfirm,
+		opts.OnSwitchToEditor,
 	)
 
 	self.UpdateCommitPanelView(opts.InitialMessage)

pkg/gui/controllers/helpers/working_tree_helper.go

@@ -104,6 +104,7 @@ func (self *WorkingTreeHelper) HandleCommitPressWithMessage(initialMessage strin
 			DescriptionTitle: self.c.Tr.CommitDescriptionTitle,
 			PreserveMessage:  true,
 			OnConfirm:        self.handleCommit,
+			OnSwitchToEditor: self.switchFromCommitMessagePanelToEditor,
 		},
 	)
 }
@@ -117,6 +118,21 @@ func (self *WorkingTreeHelper) handleCommit(summary string, description string)
 	})
 }
 
+func (self *WorkingTreeHelper) switchFromCommitMessagePanelToEditor(filepath string) error {
+	// We won't be able to tell whether the commit was successful, because
+	// RunSubprocessAndRefresh doesn't return the error (it opens an error alert
+	// itself and returns nil on error). But even if we could, we wouldn't have
+	// access to the last message that the user typed, and it might be very
+	// different from what was last in the commit panel. So the best we can do
+	// here is to always clear the remembered commit message.
+	self.commitsHelper.OnCommitSuccess()
+
+	self.c.LogAction(self.c.Tr.Actions.Commit)
+	return self.c.RunSubprocessAndRefresh(
+		self.c.Git().Commit.CommitInEditorWithMessageFileCmdObj(filepath),
+	)
+}
+
 // HandleCommitEditorPress - handle when the user wants to commit changes via
 // their editor rather than via the popup panel
 func (self *WorkingTreeHelper) HandleCommitEditorPress() error {

pkg/gui/controllers/local_commits_controller.go

@@ -279,10 +279,37 @@ func (self *LocalCommitsController) reword(commit *models.Commit) error {
 			DescriptionTitle: self.c.Tr.CommitDescriptionTitle,
 			PreserveMessage:  false,
 			OnConfirm:        self.handleReword,
+			OnSwitchToEditor: self.switchFromCommitMessagePanelToEditor,
 		},
 	)
 }
 
+func (self *LocalCommitsController) switchFromCommitMessagePanelToEditor(filepath string) error {
+	if self.isHeadCommit() {
+		return self.c.RunSubprocessAndRefresh(
+			self.c.Git().Commit.RewordLastCommitInEditorWithMessageFileCmdObj(filepath))
+	}
+
+	err := self.c.Git().Rebase.BeginInteractiveRebaseForCommit(self.c.Model().Commits, self.context().GetSelectedLineIdx(), false)
+	if err != nil {
+		return err
+	}
+
+	// now the selected commit should be our head so we'll amend it with the new message
+	err = self.c.RunSubprocessAndRefresh(
+		self.c.Git().Commit.RewordLastCommitInEditorWithMessageFileCmdObj(filepath))
+	if err != nil {
+		return err
+	}
+
+	err = self.c.Git().Rebase.ContinueRebase()
+	if err != nil {
+		return err
+	}
+
+	return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
+}
+
 func (self *LocalCommitsController) handleReword(summary string, description string) error {
 	err := self.c.Git().Rebase.RewordCommit(self.c.Model().Commits, self.c.Contexts().LocalCommits.GetSelectedLineIdx(), summary, description)
 	if err != nil {