go/lazygit
1
0
Fork 0
mirror of https://github.com/jesseduffield/lazygit.git synced 2025-02-09 13:47:11 +02:00
Code Issues Releases Activity

standardise controller helper methods

Browse Source
This commit is contained in:
Jesse Duffield 2023-03-23 13:04:57 +11:00
parent fc91ef6a59
commit 711674f6cd
34 changed files with 262 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
pkg/gui/controllers.go
View File

@ -13,8 +13,6 @@ import (
func (gui *Gui) resetControllers() {
helperCommon := gui.c
osCommand := gui.os
model := gui.State.Model
refsHelper := helpers.NewRefsHelper(helperCommon)
rebaseHelper := helpers.NewMergeAndRebaseHelper(helperCommon, refsHelper)
@ -68,16 +66,7 @@ func (gui *Gui) resetControllers() {
gui.helpers,
)
common := controllers.NewControllerCommon(
helperCommon,
osCommand,
gui.git,
gui.helpers,
model,
gui.State.Contexts,
gui.State.Modes,
&gui.Mutexes,
)
common := controllers.NewControllerCommon(helperCommon, gui.helpers)
syncController := controllers.NewSyncController(
common,
@ -140,8 +129,8 @@ func (gui *Gui) resetControllers() {
stagingSecondaryController := controllers.NewStagingController(common, gui.State.Contexts.StagingSecondary, gui.State.Contexts.Staging, true)
patchBuildingController := controllers.NewPatchBuildingController(common)
snakeController := controllers.NewSnakeController(common)
reflogCommitsController := controllers.NewReflogCommitsController(common, gui.State.Contexts.ReflogCommits)
subCommitsController := controllers.NewSubCommitsController(common, gui.State.Contexts.SubCommits)
reflogCommitsController := controllers.NewReflogCommitsController(common)
subCommitsController := controllers.NewSubCommitsController(common)
statusController := controllers.NewStatusController(common)
commandLogController := controllers.NewCommandLogController(common)
confirmationController := controllers.NewConfirmationController(common)

18
pkg/gui/controllers/basic_commits_controller.go
View File

@ -141,7 +141,7 @@ func (self *BasicCommitsController) copyCommitAttribute(commit *models.Commit) e
func (self *BasicCommitsController) copyCommitSHAToClipboard(commit *models.Commit) error {
self.c.LogAction(self.c.Tr.Actions.CopyCommitSHAToClipboard)
if err := self.os.CopyToClipboard(commit.Sha); err != nil {
if err := self.c.OS().CopyToClipboard(commit.Sha); err != nil {
return self.c.Error(err)
}
@ -156,7 +156,7 @@ func (self *BasicCommitsController) copyCommitURLToClipboard(commit *models.Comm
}
self.c.LogAction(self.c.Tr.Actions.CopyCommitURLToClipboard)
if err := self.os.CopyToClipboard(url); err != nil {
if err := self.c.OS().CopyToClipboard(url); err != nil {
return self.c.Error(err)
}
@ -165,13 +165,13 @@ func (self *BasicCommitsController) copyCommitURLToClipboard(commit *models.Comm
}
func (self *BasicCommitsController) copyCommitDiffToClipboard(commit *models.Commit) error {
diff, err := self.git.Commit.GetCommitDiff(commit.Sha)
diff, err := self.c.Git().Commit.GetCommitDiff(commit.Sha)
if err != nil {
return self.c.Error(err)
}
self.c.LogAction(self.c.Tr.Actions.CopyCommitDiffToClipboard)
if err := self.os.CopyToClipboard(diff); err != nil {
if err := self.c.OS().CopyToClipboard(diff); err != nil {
return self.c.Error(err)
}
@ -180,7 +180,7 @@ func (self *BasicCommitsController) copyCommitDiffToClipboard(commit *models.Com
}
func (self *BasicCommitsController) copyAuthorToClipboard(commit *models.Commit) error {
author, err := self.git.Commit.GetCommitAuthor(commit.Sha)
author, err := self.c.Git().Commit.GetCommitAuthor(commit.Sha)
if err != nil {
return self.c.Error(err)
}
@ -188,7 +188,7 @@ func (self *BasicCommitsController) copyAuthorToClipboard(commit *models.Commit)
formattedAuthor := fmt.Sprintf("%s <%s>", author.Name, author.Email)
self.c.LogAction(self.c.Tr.Actions.CopyCommitAuthorToClipboard)
if err := self.os.CopyToClipboard(formattedAuthor); err != nil {
if err := self.c.OS().CopyToClipboard(formattedAuthor); err != nil {
return self.c.Error(err)
}
@ -197,13 +197,13 @@ func (self *BasicCommitsController) copyAuthorToClipboard(commit *models.Commit)
}
func (self *BasicCommitsController) copyCommitMessageToClipboard(commit *models.Commit) error {
message, err := self.git.Commit.GetCommitMessage(commit.Sha)
message, err := self.c.Git().Commit.GetCommitMessage(commit.Sha)
if err != nil {
return self.c.Error(err)
}
self.c.LogAction(self.c.Tr.Actions.CopyCommitMessageToClipboard)
if err := self.os.CopyToClipboard(message); err != nil {
if err := self.c.OS().CopyToClipboard(message); err != nil {
return self.c.Error(err)
}
@ -218,7 +218,7 @@ func (self *BasicCommitsController) openInBrowser(commit *models.Commit) error {
}
self.c.LogAction(self.c.Tr.Actions.OpenCommitInBrowser)
if err := self.os.OpenLink(url); err != nil {
if err := self.c.OS().OpenLink(url); err != nil {
return self.c.Error(err)
}

30
pkg/gui/controllers/bisect_controller.go
View File

@ -42,7 +42,7 @@ func (self *BisectController) GetKeybindings(opts types.KeybindingsOpts) []*type
func (self *BisectController) openMenu(commit *models.Commit) error {
// no shame in getting this directly rather than using the cached value
// given how cheap it is to obtain
info := self.git.Bisect.GetInfo()
info := self.c.Git().Bisect.GetInfo()
if info.Started() {
return self.openMidBisectMenu(info, commit)
} else {
@ -63,14 +63,14 @@ func (self *BisectController) openMidBisectMenu(info *git_commands.BisectInfo, c
selectCurrentAfter := info.GetCurrentSha() == "" || info.GetCurrentSha() == commit.Sha
// we need to wait to reselect if our bisect commits aren't ancestors of our 'start'
// ref, because we'll be reloading our commits in that case.
waitToReselect := selectCurrentAfter && !self.git.Bisect.ReachableFromStart(info)
waitToReselect := selectCurrentAfter && !self.c.Git().Bisect.ReachableFromStart(info)
menuItems := []*types.MenuItem{
{
Label: fmt.Sprintf(self.c.Tr.Bisect.Mark, commit.ShortSha(), info.NewTerm()),
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectMark)
if err := self.git.Bisect.Mark(commit.Sha, info.NewTerm()); err != nil {
if err := self.c.Git().Bisect.Mark(commit.Sha, info.NewTerm()); err != nil {
return self.c.Error(err)
}
@ -82,7 +82,7 @@ func (self *BisectController) openMidBisectMenu(info *git_commands.BisectInfo, c
Label: fmt.Sprintf(self.c.Tr.Bisect.Mark, commit.ShortSha(), info.OldTerm()),
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectMark)
if err := self.git.Bisect.Mark(commit.Sha, info.OldTerm()); err != nil {
if err := self.c.Git().Bisect.Mark(commit.Sha, info.OldTerm()); err != nil {
return self.c.Error(err)
}
@ -94,7 +94,7 @@ func (self *BisectController) openMidBisectMenu(info *git_commands.BisectInfo, c
Label: fmt.Sprintf(self.c.Tr.Bisect.Skip, commit.ShortSha()),
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectSkip)
if err := self.git.Bisect.Skip(commit.Sha); err != nil {
if err := self.c.Git().Bisect.Skip(commit.Sha); err != nil {
return self.c.Error(err)
}
@ -125,11 +125,11 @@ func (self *BisectController) openStartBisectMenu(info *git_commands.BisectInfo,
Label: fmt.Sprintf(self.c.Tr.Bisect.MarkStart, commit.ShortSha(), info.NewTerm()),
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.StartBisect)
if err := self.git.Bisect.Start(); err != nil {
if err := self.c.Git().Bisect.Start(); err != nil {
return self.c.Error(err)
}
if err := self.git.Bisect.Mark(commit.Sha, info.NewTerm()); err != nil {
if err := self.c.Git().Bisect.Mark(commit.Sha, info.NewTerm()); err != nil {
return self.c.Error(err)
}
@ -141,11 +141,11 @@ func (self *BisectController) openStartBisectMenu(info *git_commands.BisectInfo,
Label: fmt.Sprintf(self.c.Tr.Bisect.MarkStart, commit.ShortSha(), info.OldTerm()),
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.StartBisect)
if err := self.git.Bisect.Start(); err != nil {
if err := self.c.Git().Bisect.Start(); err != nil {
return self.c.Error(err)
}
if err := self.git.Bisect.Mark(commit.Sha, info.OldTerm()); err != nil {
if err := self.c.Git().Bisect.Mark(commit.Sha, info.OldTerm()); err != nil {
return self.c.Error(err)
}
@ -163,7 +163,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
prompt = self.c.Tr.Bisect.CompletePromptIndeterminate
}
formattedCommits, err := self.git.Commit.GetCommitsOneline(candidateShas)
formattedCommits, err := self.c.Git().Commit.GetCommitsOneline(candidateShas)
if err != nil {
return self.c.Error(err)
}
@ -173,7 +173,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
Prompt: fmt.Sprintf(prompt, strings.TrimSpace(formattedCommits)),
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.ResetBisect)
if err := self.git.Bisect.Reset(); err != nil {
if err := self.c.Git().Bisect.Reset(); err != nil {
return self.c.Error(err)
}
@ -183,7 +183,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
}
func (self *BisectController) afterMark(selectCurrent bool, waitToReselect bool) error {
done, candidateShas, err := self.git.Bisect.IsDone()
done, candidateShas, err := self.c.Git().Bisect.IsDone()
if err != nil {
return self.c.Error(err)
}
@ -216,10 +216,10 @@ func (self *BisectController) afterBisectMarkRefresh(selectCurrent bool, waitToR
}
func (self *BisectController) selectCurrentBisectCommit() {
info := self.git.Bisect.GetInfo()
info := self.c.Git().Bisect.GetInfo()
if info.GetCurrentSha() != "" {
// find index of commit with that sha, move cursor to that.
for i, commit := range self.model.Commits {
for i, commit := range self.c.Model().Commits {
if commit.Sha == info.GetCurrentSha() {
self.context().SetSelectedLineIdx(i)
_ = self.context().HandleFocus(types.OnFocusOpts{})
@ -245,5 +245,5 @@ func (self *BisectController) Context() types.Context {
}
func (self *BisectController) context() *context.LocalCommitsContext {
return self.contexts.LocalCommits
return self.c.Contexts().LocalCommits
}

26
pkg/gui/controllers/branches_controller.go
View File

@ -142,7 +142,7 @@ func (self *BranchesController) setUpstream(selectedBranch *models.Branch) error
{
LabelColumns: []string{self.c.Tr.LcUnsetUpstream},
OnPress: func() error {
if err := self.git.Branch.UnsetUpstream(selectedBranch.Name); err != nil {
if err := self.c.Git().Branch.UnsetUpstream(selectedBranch.Name); err != nil {
return self.c.Error(err)
}
if err := self.c.Refresh(types.RefreshOptions{
@ -167,7 +167,7 @@ func (self *BranchesController) setUpstream(selectedBranch *models.Branch) error
return self.c.Error(err)
}
if err := self.git.Branch.SetUpstream(upstreamRemote, upstreamBranch, selectedBranch.Name); err != nil {
if err := self.c.Git().Branch.SetUpstream(upstreamRemote, upstreamBranch, selectedBranch.Name); err != nil {
return self.c.Error(err)
}
if err := self.c.Refresh(types.RefreshOptions{
@ -193,7 +193,7 @@ func (self *BranchesController) Context() types.Context {
}
func (self *BranchesController) context() *context.BranchesContext {
return self.contexts.Branches
return self.c.Contexts().Branches
}
func (self *BranchesController) press(selectedBranch *models.Branch) error {
@ -218,7 +218,7 @@ func (self *BranchesController) handleCreatePullRequestMenu(selectedBranch *mode
func (self *BranchesController) copyPullRequestURL() error {
branch := self.context().GetSelected()
branchExistsOnRemote := self.git.Remote.CheckRemoteBranchExists(branch.Name)
branchExistsOnRemote := self.c.Git().Remote.CheckRemoteBranchExists(branch.Name)
if !branchExistsOnRemote {
return self.c.Error(errors.New(self.c.Tr.NoBranchOnRemote))
@ -229,7 +229,7 @@ func (self *BranchesController) copyPullRequestURL() error {
return self.c.Error(err)
}
self.c.LogAction(self.c.Tr.Actions.CopyPullRequestURL)
if err := self.os.CopyToClipboard(url); err != nil {
if err := self.c.OS().CopyToClipboard(url); err != nil {
return self.c.Error(err)
}
@ -248,7 +248,7 @@ func (self *BranchesController) forceCheckout() error {
Prompt: message,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.ForceCheckoutBranch)
if err := self.git.Branch.Checkout(branch.Name, git_commands.CheckoutOptions{Force: true}); err != nil {
if err := self.c.Git().Branch.Checkout(branch.Name, git_commands.CheckoutOptions{Force: true}); err != nil {
_ = self.c.Error(err)
}
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
@ -284,7 +284,7 @@ func (self *BranchesController) createNewBranchWithName(newBranchName string) er
return nil
}
if err := self.git.Branch.New(newBranchName, branch.FullRefName()); err != nil {
if err := self.c.Git().Branch.New(newBranchName, branch.FullRefName()); err != nil {
return self.c.Error(err)
}
@ -320,7 +320,7 @@ func (self *BranchesController) deleteWithForce(selectedBranch *models.Branch, f
Prompt: message,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteBranch)
if err := self.git.Branch.Delete(selectedBranch.Name, force); err != nil {
if err := self.c.Git().Branch.Delete(selectedBranch.Name, force); err != nil {
errMessage := err.Error()
if !force && strings.Contains(errMessage, "git branch -D ") {
return self.deleteWithForce(selectedBranch, true)
@ -367,7 +367,7 @@ func (self *BranchesController) fastForward(branch *models.Branch) error {
if branch == self.helpers.Refs.GetCheckedOutRef() {
self.c.LogAction(action)
err := self.git.Sync.Pull(
err := self.c.Git().Sync.Pull(
git_commands.PullOptions{
RemoteName: branch.UpstreamRemote,
BranchName: branch.UpstreamBranch,
@ -381,7 +381,7 @@ func (self *BranchesController) fastForward(branch *models.Branch) error {
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
} else {
self.c.LogAction(action)
err := self.git.Sync.FastForward(branch.Name, branch.UpstreamRemote, branch.UpstreamBranch)
err := self.c.Git().Sync.FastForward(branch.Name, branch.UpstreamRemote, branch.UpstreamBranch)
if err != nil {
_ = self.c.Error(err)
}
@ -407,7 +407,7 @@ func (self *BranchesController) rename(branch *models.Branch) error {
InitialContent: branch.Name,
HandleConfirm: func(newBranchName string) error {
self.c.LogAction(self.c.Tr.Actions.RenameBranch)
if err := self.git.Branch.Rename(branch.Name, newBranchName); err != nil {
if err := self.c.Git().Branch.Rename(branch.Name, newBranchName); err != nil {
return self.c.Error(err)
}
@ -415,7 +415,7 @@ func (self *BranchesController) rename(branch *models.Branch) error {
_ = self.c.Refresh(types.RefreshOptions{Mode: types.SYNC, Scope: []types.RefreshableView{types.BRANCHES}})
// now that we've got our stuff again we need to find that branch and reselect it.
for i, newBranch := range self.model.Branches {
for i, newBranch := range self.c.Model().Branches {
if newBranch.Name == newBranchName {
self.context().SetSelectedLineIdx(i)
if err := self.context().HandleRender(); err != nil {
@ -502,7 +502,7 @@ func (self *BranchesController) createPullRequest(from string, to string) error
self.c.LogAction(self.c.Tr.Actions.OpenPullRequest)
if err := self.os.OpenLink(url); err != nil {
if err := self.c.OS().OpenLink(url); err != nil {
return self.c.Error(err)
}

2
pkg/gui/controllers/command_log_controller.go
View File

@ -38,5 +38,5 @@ func (self *CommandLogController) Context() types.Context {
}
func (self *CommandLogController) context() types.Context {
return self.contexts.CommandLog
return self.c.Contexts().CommandLog
}

4
pkg/gui/controllers/commit_message_controller.go
View File

@ -65,7 +65,7 @@ func (self *CommitMessageController) Context() types.Context {
// this method is pointless in this context but I'm keeping it consistent
// with other contexts so that when generics arrive it's easier to refactor
func (self *CommitMessageController) context() *context.CommitMessageContext {
return self.contexts.CommitMessage
return self.c.Contexts().CommitMessage
}
func (self *CommitMessageController) confirm() error {
@ -76,7 +76,7 @@ func (self *CommitMessageController) confirm() error {
return self.c.ErrorMsg(self.c.Tr.CommitWithoutMessageErr)
}
cmdObj := self.git.Commit.CommitCmdObj(message)
cmdObj := self.c.Git().Commit.CommitCmdObj(message)
self.c.LogAction(self.c.Tr.Actions.Commit)
_ = self.c.PopContext()

34
pkg/gui/controllers/commits_files_controller.go
View File

@ -99,7 +99,7 @@ func (self *CommitFilesController) Context() types.Context {
}
func (self *CommitFilesController) context() *context.CommitFilesContext {
return self.contexts.CommitFiles
return self.c.Contexts().CommitFiles
}
func (self *CommitFilesController) onClickMain(opts gocui.ViewMouseBindingOpts) error {
@ -112,7 +112,7 @@ func (self *CommitFilesController) onClickMain(opts gocui.ViewMouseBindingOpts)
func (self *CommitFilesController) checkout(node *filetree.CommitFileNode) error {
self.c.LogAction(self.c.Tr.Actions.CheckoutFile)
if err := self.git.WorkingTree.CheckoutFile(self.context().GetRef().RefName(), node.GetPath()); err != nil {
if err := self.c.Git().WorkingTree.CheckoutFile(self.context().GetRef().RefName(), node.GetPath()); err != nil {
return self.c.Error(err)
}
@ -130,7 +130,7 @@ func (self *CommitFilesController) discard(node *filetree.CommitFileNode) error
HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.RebasingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardOldFileChange)
if err := self.git.Rebase.DiscardOldFileChanges(self.model.Commits, self.contexts.LocalCommits.GetSelectedLineIdx(), node.GetPath()); err != nil {
if err := self.c.Git().Rebase.DiscardOldFileChanges(self.c.Model().Commits, self.c.Contexts().LocalCommits.GetSelectedLineIdx(), node.GetPath()); err != nil {
if err := self.helpers.MergeAndRebase.CheckMergeOrRebase(err); err != nil {
return err
}
@ -157,7 +157,7 @@ func (self *CommitFilesController) edit(node *filetree.CommitFileNode) error {
func (self *CommitFilesController) toggleForPatch(node *filetree.CommitFileNode) error {
toggle := func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingPatch, func() error {
if !self.git.Patch.PatchBuilder.Active() {
if !self.c.Git().Patch.PatchBuilder.Active() {
if err := self.startPatchBuilder(); err != nil {
return err
}
@ -166,34 +166,34 @@ func (self *CommitFilesController) toggleForPatch(node *filetree.CommitFileNode)
// if there is any file that hasn't been fully added we'll fully add everything,
// otherwise we'll remove everything
adding := node.SomeFile(func(file *models.CommitFile) bool {
return self.git.Patch.PatchBuilder.GetFileStatus(file.Name, self.context().GetRef().RefName()) != patch.WHOLE
return self.c.Git().Patch.PatchBuilder.GetFileStatus(file.Name, self.context().GetRef().RefName()) != patch.WHOLE
})
err := node.ForEachFile(func(file *models.CommitFile) error {
if adding {
return self.git.Patch.PatchBuilder.AddFileWhole(file.Name)
return self.c.Git().Patch.PatchBuilder.AddFileWhole(file.Name)
} else {
return self.git.Patch.PatchBuilder.RemoveFile(file.Name)
return self.c.Git().Patch.PatchBuilder.RemoveFile(file.Name)
}
})
if err != nil {
return self.c.Error(err)
}
if self.git.Patch.PatchBuilder.IsEmpty() {
self.git.Patch.PatchBuilder.Reset()
if self.c.Git().Patch.PatchBuilder.IsEmpty() {
self.c.Git().Patch.PatchBuilder.Reset()
}
return self.c.PostRefreshUpdate(self.context())
})
}
if self.git.Patch.PatchBuilder.Active() && self.git.Patch.PatchBuilder.To != self.context().GetRef().RefName() {
if self.c.Git().Patch.PatchBuilder.Active() && self.c.Git().Patch.PatchBuilder.To != self.context().GetRef().RefName() {
return self.c.Confirm(types.ConfirmOpts{
Title: self.c.Tr.DiscardPatch,
Prompt: self.c.Tr.DiscardPatchConfirm,
HandleConfirm: func() error {
self.git.Patch.PatchBuilder.Reset()
self.c.Git().Patch.PatchBuilder.Reset()
return toggle()
},
})
@ -213,9 +213,9 @@ func (self *CommitFilesController) startPatchBuilder() error {
canRebase := commitFilesContext.GetCanRebase()
ref := commitFilesContext.GetRef()
to := ref.RefName()
from, reverse := self.modes.Diffing.GetFromAndReverseArgsForDiff(ref.ParentRefName())
from, reverse := self.c.Modes().Diffing.GetFromAndReverseArgsForDiff(ref.ParentRefName())
self.git.Patch.PatchBuilder.Start(from, to, reverse, canRebase)
self.c.Git().Patch.PatchBuilder.Start(from, to, reverse, canRebase)
return nil
}
@ -229,21 +229,21 @@ func (self *CommitFilesController) enterCommitFile(node *filetree.CommitFileNode
}
enterTheFile := func() error {
if !self.git.Patch.PatchBuilder.Active() {
if !self.c.Git().Patch.PatchBuilder.Active() {
if err := self.startPatchBuilder(); err != nil {
return err
}
}
return self.c.PushContext(self.contexts.CustomPatchBuilder, opts)
return self.c.PushContext(self.c.Contexts().CustomPatchBuilder, opts)
}
if self.git.Patch.PatchBuilder.Active() && self.git.Patch.PatchBuilder.To != self.context().GetRef().RefName() {
if self.c.Git().Patch.PatchBuilder.Active() && self.c.Git().Patch.PatchBuilder.To != self.context().GetRef().RefName() {
return self.c.Confirm(types.ConfirmOpts{
Title: self.c.Tr.DiscardPatch,
Prompt: self.c.Tr.DiscardPatchConfirm,
HandleConfirm: func() error {
self.git.Patch.PatchBuilder.Reset()
self.c.Git().Patch.PatchBuilder.Reset()
return enterTheFile()
},
})

36
pkg/gui/controllers/common.go
View File

@ -1,48 +1,20 @@
package controllers
import (
"github.com/jesseduffield/lazygit/pkg/commands"
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
"github.com/jesseduffield/lazygit/pkg/gui/context"
"github.com/jesseduffield/lazygit/pkg/gui/controllers/helpers"
"github.com/jesseduffield/lazygit/pkg/gui/types"
)
type controllerCommon struct {
c *helpers.HelperCommon
helpers *helpers.Helpers
contexts *context.ContextTree
// TODO: use helperCommon's .OS() method instead of this
os *oscommands.OSCommand
// TODO: use helperCommon's .Git() method instead of this
git *commands.GitCommand
// TODO: use helperCommon's .Model() method instead of this
model *types.Model
// TODO: use helperCommon's .Modes() method instead of this
modes *types.Modes
// TODO: use helperCommon's .Mutexes() method instead of this
mutexes *types.Mutexes
c *helpers.HelperCommon
helpers *helpers.Helpers
}
func NewControllerCommon(
c *helpers.HelperCommon,
os *oscommands.OSCommand,
git *commands.GitCommand,
helpers *helpers.Helpers,
model *types.Model,
contexts *context.ContextTree,
modes *types.Modes,
mutexes *types.Mutexes,
) *controllerCommon {
return &controllerCommon{
c: c,
os: os,
git: git,
helpers: helpers,
model: model,
contexts: contexts,
modes: modes,
mutexes: mutexes,
c: c,
helpers: helpers,
}
}

6
pkg/gui/controllers/confirmation_controller.go
View File

@ -38,8 +38,8 @@ func (self *ConfirmationController) GetKeybindings(opts types.KeybindingsOpts) [
{
Key: opts.GetKey(opts.Config.Universal.TogglePanel),
Handler: func() error {
if len(self.contexts.Suggestions.State.Suggestions) > 0 {
return self.c.ReplaceContext(self.contexts.Suggestions)
if len(self.c.Contexts().Suggestions.State.Suggestions) > 0 {
return self.c.ReplaceContext(self.c.Contexts().Suggestions)
}
return nil
},
@ -61,5 +61,5 @@ func (self *ConfirmationController) Context() types.Context {
}
func (self *ConfirmationController) context() *context.ConfirmationContext {
return self.contexts.Confirmation
return self.c.Contexts().Confirmation
}

2
pkg/gui/controllers/context_lines_controller.go
View File

@ -101,7 +101,7 @@ func (self *ContextLinesController) applyChange() error {
}
func (self *ContextLinesController) checkCanChangeContext() error {
if self.git.Patch.PatchBuilder.Active() {
if self.c.Git().Patch.PatchBuilder.Active() {
return errors.New(self.c.Tr.CantChangeContextSizeError)
}

64
pkg/gui/controllers/files_controller.go
View File

@ -208,7 +208,7 @@ func (self *FilesController) GetOnRenderToMain() func() error {
split := self.c.UserConfig.Gui.SplitDiff == "always" || (node.GetHasUnstagedChanges() && node.GetHasStagedChanges())
mainShowsStaged := !split && node.GetHasStagedChanges()
cmdObj := self.git.WorkingTree.WorktreeFileDiffCmdObj(node, false, mainShowsStaged, self.c.State().GetIgnoreWhitespaceInDiffView())
cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, false, mainShowsStaged, self.c.State().GetIgnoreWhitespaceInDiffView())
title := self.c.Tr.UnstagedChanges
if mainShowsStaged {
title = self.c.Tr.StagedChanges
@ -222,7 +222,7 @@ func (self *FilesController) GetOnRenderToMain() func() error {
}
if split {
cmdObj := self.git.WorkingTree.WorktreeFileDiffCmdObj(node, false, true, self.c.State().GetIgnoreWhitespaceInDiffView())
cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(node, false, true, self.c.State().GetIgnoreWhitespaceInDiffView())
title := self.c.Tr.StagedChanges
if mainShowsStaged {
@ -295,7 +295,7 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
rerender := false
err := node.ForEachFile(func(f *models.File) error {
// can't act on the file itself: we need to update the original model file
for _, modelFile := range self.model.Files {
for _, modelFile := range self.c.Model().Files {
if modelFile.Name == f.Name {
if optimisticChangeFn(modelFile) {
rerender = true
@ -310,7 +310,7 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
return err
}
if rerender {
if err := self.c.PostRefreshUpdate(self.contexts.Files); err != nil {
if err := self.c.PostRefreshUpdate(self.c.Contexts().Files); err != nil {
return err
}
}
@ -321,8 +321,8 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
// Obtaining this lock because optimistic rendering requires us to mutate
// the files in our model.
self.mutexes.RefreshingFilesMutex.Lock()
defer self.mutexes.RefreshingFilesMutex.Unlock()
self.c.Mutexes().RefreshingFilesMutex.Lock()
defer self.c.Mutexes().RefreshingFilesMutex.Unlock()
if node.IsFile() {
file := node.File
@ -334,7 +334,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err
}
if err := self.git.WorkingTree.StageFile(file.Name); err != nil {
if err := self.c.Git().WorkingTree.StageFile(file.Name); err != nil {
return self.c.Error(err)
}
} else {
@ -344,7 +344,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err
}
if err := self.git.WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
if err := self.c.Git().WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
return self.c.Error(err)
}
}
@ -362,7 +362,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err
}
if err := self.git.WorkingTree.StageFile(node.Path); err != nil {
if err := self.c.Git().WorkingTree.StageFile(node.Path); err != nil {
return self.c.Error(err)
}
} else {
@ -373,7 +373,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
}
// pretty sure it doesn't matter that we're always passing true here
if err := self.git.WorkingTree.UnStageFile([]string{node.Path}, true); err != nil {
if err := self.c.Git().WorkingTree.UnStageFile([]string{node.Path}, true); err != nil {
return self.c.Error(err)
}
}
@ -414,7 +414,7 @@ func (self *FilesController) Context() types.Context {
}
func (self *FilesController) context() *context.WorkingTreeContext {
return self.contexts.Files
return self.c.Contexts().Files
}
func (self *FilesController) getSelectedFile() *models.File {
@ -441,7 +441,7 @@ func (self *FilesController) EnterFile(opts types.OnFocusOpts) error {
file := node.File
submoduleConfigs := self.model.Submodules
submoduleConfigs := self.c.Model().Submodules
if file.IsSubmodule(submoduleConfigs) {
submoduleConfig := file.SubmoduleConfig(submoduleConfigs)
return self.helpers.Repos.EnterSubmodule(submoduleConfig)
@ -454,7 +454,7 @@ func (self *FilesController) EnterFile(opts types.OnFocusOpts) error {
return self.c.ErrorMsg(self.c.Tr.FileStagingRequirements)
}
return self.c.PushContext(self.contexts.Staging, opts)
return self.c.PushContext(self.c.Contexts().Staging, opts)
}
func (self *FilesController) toggleStagedAll() error {
@ -470,8 +470,8 @@ func (self *FilesController) toggleStagedAll() error {
}
func (self *FilesController) toggleStagedAllWithLock() error {
self.mutexes.RefreshingFilesMutex.Lock()
defer self.mutexes.RefreshingFilesMutex.Unlock()
self.c.Mutexes().RefreshingFilesMutex.Lock()
defer self.c.Mutexes().RefreshingFilesMutex.Unlock()
root := self.context().FileTreeViewModel.GetRoot()
@ -488,7 +488,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
return err
}
if err := self.git.WorkingTree.StageAll(); err != nil {
if err := self.c.Git().WorkingTree.StageAll(); err != nil {
return self.c.Error(err)
}
} else {
@ -498,7 +498,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
return err
}
if err := self.git.WorkingTree.UnstageAll(); err != nil {
if err := self.c.Git().WorkingTree.UnstageAll(); err != nil {
return self.c.Error(err)
}
}
@ -509,7 +509,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
func (self *FilesController) unstageFiles(node *filetree.FileNode) error {
return node.ForEachFile(func(file *models.File) error {
if file.HasStagedChanges {
if err := self.git.WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
if err := self.c.Git().WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
return err
}
}
@ -525,7 +525,7 @@ func (self *FilesController) ignoreOrExcludeTracked(node *filetree.FileNode, trA
return err
}
if err := self.git.WorkingTree.RemoveTrackedFiles(node.GetPath()); err != nil {
if err := self.c.Git().WorkingTree.RemoveTrackedFiles(node.GetPath()); err != nil {
return err
}
@ -563,7 +563,7 @@ func (self *FilesController) ignore(node *filetree.FileNode) error {
if node.GetPath() == ".gitignore" {
return self.c.ErrorMsg(self.c.Tr.Actions.IgnoreFileErr)
}
err := self.ignoreOrExcludeFile(node, self.c.Tr.IgnoreTracked, self.c.Tr.IgnoreTrackedPrompt, self.c.Tr.Actions.LcIgnoreExcludeFile, self.git.WorkingTree.Ignore)
err := self.ignoreOrExcludeFile(node, self.c.Tr.IgnoreTracked, self.c.Tr.IgnoreTrackedPrompt, self.c.Tr.Actions.LcIgnoreExcludeFile, self.c.Git().WorkingTree.Ignore)
if err != nil {
return err
}
@ -580,7 +580,7 @@ func (self *FilesController) exclude(node *filetree.FileNode) error {
return self.c.ErrorMsg(self.c.Tr.Actions.ExcludeGitIgnoreErr)
}
err := self.ignoreOrExcludeFile(node, self.c.Tr.ExcludeTracked, self.c.Tr.ExcludeTrackedPrompt, self.c.Tr.Actions.ExcludeFile, self.git.WorkingTree.Exclude)
err := self.ignoreOrExcludeFile(node, self.c.Tr.ExcludeTracked, self.c.Tr.ExcludeTrackedPrompt, self.c.Tr.Actions.ExcludeFile, self.c.Git().WorkingTree.Exclude)
if err != nil {
return err
}
@ -620,7 +620,7 @@ func (self *FilesController) refresh() error {
}
func (self *FilesController) handleAmendCommitPress() error {
if len(self.model.Files) == 0 {
if len(self.c.Model().Files) == 0 {
return self.c.ErrorMsg(self.c.Tr.NoFilesStagedTitle)
}
@ -628,7 +628,7 @@ func (self *FilesController) handleAmendCommitPress() error {
return self.helpers.WorkingTree.PromptToStageAllAndRetry(self.handleAmendCommitPress)
}
if len(self.model.Commits) == 0 {
if len(self.c.Model().Commits) == 0 {
return self.c.ErrorMsg(self.c.Tr.NoCommitToAmend)
}
@ -702,7 +702,7 @@ func (self *FilesController) createStashMenu() error {
if !self.helpers.WorkingTree.IsWorkingTreeDirty() {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash)
}
return self.handleStashSave(self.git.Stash.Save, self.c.Tr.Actions.StashAllChanges)
return self.handleStashSave(self.c.Git().Stash.Save, self.c.Tr.Actions.StashAllChanges)
},
Key: 'a',
},
@ -713,14 +713,14 @@ func (self *FilesController) createStashMenu() error {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash)
}
// if there are no staged files it behaves the same as Stash.Save
return self.handleStashSave(self.git.Stash.StashAndKeepIndex, self.c.Tr.Actions.StashAllChangesKeepIndex)
return self.handleStashSave(self.c.Git().Stash.StashAndKeepIndex, self.c.Tr.Actions.StashAllChangesKeepIndex)
},
Key: 'i',
},
{
Label: self.c.Tr.LcStashIncludeUntrackedChanges,
OnPress: func() error {
return self.handleStashSave(self.git.Stash.StashIncludeUntrackedChanges, self.c.Tr.Actions.StashIncludeUntrackedChanges)
return self.handleStashSave(self.c.Git().Stash.StashIncludeUntrackedChanges, self.c.Tr.Actions.StashIncludeUntrackedChanges)
},
Key: 'U',
},
@ -731,7 +731,7 @@ func (self *FilesController) createStashMenu() error {
if !self.helpers.WorkingTree.AnyStagedFiles() {
return self.c.ErrorMsg(self.c.Tr.NoTrackedStagedFilesStash)
}
return self.handleStashSave(self.git.Stash.SaveStagedChanges, self.c.Tr.Actions.StashStagedChanges)
return self.handleStashSave(self.c.Git().Stash.SaveStagedChanges, self.c.Tr.Actions.StashStagedChanges)
},
Key: 's',
},
@ -742,10 +742,10 @@ func (self *FilesController) createStashMenu() error {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash)
}
if self.helpers.WorkingTree.AnyStagedFiles() {
return self.handleStashSave(self.git.Stash.StashUnstagedChanges, self.c.Tr.Actions.StashUnstagedChanges)
return self.handleStashSave(self.c.Git().Stash.StashUnstagedChanges, self.c.Tr.Actions.StashUnstagedChanges)
}
// ordinary stash
return self.handleStashSave(self.git.Stash.Save, self.c.Tr.Actions.StashUnstagedChanges)
return self.handleStashSave(self.c.Git().Stash.Save, self.c.Tr.Actions.StashUnstagedChanges)
},
Key: 'u',
},
@ -754,7 +754,7 @@ func (self *FilesController) createStashMenu() error {
}
func (self *FilesController) stash() error {
return self.handleStashSave(self.git.Stash.Save, self.c.Tr.Actions.StashAllChanges)
return self.handleStashSave(self.c.Git().Stash.Save, self.c.Tr.Actions.StashAllChanges)
}
func (self *FilesController) createResetToUpstreamMenu() error {
@ -769,7 +769,7 @@ func (self *FilesController) handleToggleDirCollapsed() error {
self.context().FileTreeViewModel.ToggleCollapsed(node.GetPath())
if err := self.c.PostRefreshUpdate(self.contexts.Files); err != nil {
if err := self.c.PostRefreshUpdate(self.c.Contexts().Files); err != nil {
self.c.Log.Error(err)
}
@ -815,7 +815,7 @@ func (self *FilesController) fetch() error {
func (self *FilesController) fetchAux() (err error) {
self.c.LogAction("Fetch")
err = self.git.Sync.Fetch(git_commands.FetchOptions{})
err = self.c.Git().Sync.Fetch(git_commands.FetchOptions{})
if err != nil && strings.Contains(err.Error(), "exit status 128") {
_ = self.c.ErrorMsg(self.c.Tr.PassUnameWrong)

18
pkg/gui/controllers/files_remove_controller.go
View File

@ -47,7 +47,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
Label: self.c.Tr.LcDiscardAllChanges,
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllChangesInDirectory)
if err := self.git.WorkingTree.DiscardAllDirChanges(node); err != nil {
if err := self.c.Git().WorkingTree.DiscardAllDirChanges(node); err != nil {
return self.c.Error(err)
}
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.FILES}})
@ -67,7 +67,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
Label: self.c.Tr.LcDiscardUnstagedChanges,
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardUnstagedChangesInDirectory)
if err := self.git.WorkingTree.DiscardUnstagedDirChanges(node); err != nil {
if err := self.c.Git().WorkingTree.DiscardUnstagedDirChanges(node); err != nil {
return self.c.Error(err)
}
@ -85,7 +85,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
} else {
file := node.File
submodules := self.model.Submodules
submodules := self.c.Model().Submodules
if file.IsSubmodule(submodules) {
submodule := file.SubmoduleConfig(submodules)
@ -103,7 +103,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
Label: self.c.Tr.LcDiscardAllChanges,
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllChangesInFile)
if err := self.git.WorkingTree.DiscardAllFileChanges(file); err != nil {
if err := self.c.Git().WorkingTree.DiscardAllFileChanges(file); err != nil {
return self.c.Error(err)
}
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.FILES}})
@ -123,7 +123,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
Label: self.c.Tr.LcDiscardUnstagedChanges,
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllUnstagedChangesInFile)
if err := self.git.WorkingTree.DiscardUnstagedFileChanges(file); err != nil {
if err := self.c.Git().WorkingTree.DiscardUnstagedFileChanges(file); err != nil {
return self.c.Error(err)
}
@ -150,15 +150,15 @@ func (self *FilesRemoveController) ResetSubmodule(submodule *models.SubmoduleCon
file := self.helpers.WorkingTree.FileForSubmodule(submodule)
if file != nil {
if err := self.git.WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
if err := self.c.Git().WorkingTree.UnStageFile(file.Names(), file.Tracked); err != nil {
return self.c.Error(err)
}
}
if err := self.git.Submodule.Stash(submodule); err != nil {
if err := self.c.Git().Submodule.Stash(submodule); err != nil {
return self.c.Error(err)
}
if err := self.git.Submodule.Reset(submodule); err != nil {
if err := self.c.Git().Submodule.Reset(submodule); err != nil {
return self.c.Error(err)
}
@ -182,5 +182,5 @@ func (self *FilesRemoveController) Context() types.Context {
}
func (self *FilesRemoveController) context() *context.WorkingTreeContext {
return self.contexts.Files
return self.c.Contexts().Files
}

8
pkg/gui/controllers/git_flow_controller.go
View File

@ -39,7 +39,7 @@ func (self *GitFlowController) GetKeybindings(opts types.KeybindingsOpts) []*typ
}
func (self *GitFlowController) handleCreateGitFlowMenu(branch *models.Branch) error {
if !self.git.Flow.GitFlowEnabled() {
if !self.c.Git().Flow.GitFlowEnabled() {
return self.c.ErrorMsg("You need to install git-flow and enable it in this repo to use git-flow features")
}
@ -52,7 +52,7 @@ func (self *GitFlowController) handleCreateGitFlowMenu(branch *models.Branch) er
HandleConfirm: func(name string) error {
self.c.LogAction(self.c.Tr.Actions.GitFlowStart)
return self.c.RunSubprocessAndRefresh(
self.git.Flow.StartCmdObj(branchType, name),
self.c.Git().Flow.StartCmdObj(branchType, name),
)
},
})
@ -94,7 +94,7 @@ func (self *GitFlowController) handleCreateGitFlowMenu(branch *models.Branch) er
}
func (self *GitFlowController) gitFlowFinishBranch(branchName string) error {
cmdObj, err := self.git.Flow.FinishCmdObj(branchName)
cmdObj, err := self.c.Git().Flow.FinishCmdObj(branchName)
if err != nil {
return self.c.Error(err)
}
@ -119,5 +119,5 @@ func (self *GitFlowController) Context() types.Context {
}
func (self *GitFlowController) context() *context.BranchesContext {
return self.contexts.Branches
return self.c.Contexts().Branches
}

2
pkg/gui/controllers/global_controller.go
View File

@ -53,7 +53,7 @@ func (self *GlobalController) customCommand() error {
self.c.LogAction(self.c.Tr.Actions.CustomCommand)
return self.c.RunSubprocessAndRefresh(
self.os.Cmd.NewShell(command),
self.c.OS().Cmd.NewShell(command),
)
},
})

58
pkg/gui/controllers/local_commits_controller.go
View File

@ -199,7 +199,7 @@ func secondaryPatchPanelUpdateOpts(c *helpers.HelperCommon) *types.ViewUpdateOpt
}
func (self *LocalCommitsController) squashDown(commit *models.Commit) error {
if self.context().GetSelectedLineIdx() >= len(self.model.Commits)-1 {
if self.context().GetSelectedLineIdx() >= len(self.c.Model().Commits)-1 {
return self.c.ErrorMsg(self.c.Tr.CannotSquashOrFixupFirstCommit)
}
@ -224,7 +224,7 @@ func (self *LocalCommitsController) squashDown(commit *models.Commit) error {
}
func (self *LocalCommitsController) fixup(commit *models.Commit) error {
if self.context().GetSelectedLineIdx() >= len(self.model.Commits)-1 {
if self.context().GetSelectedLineIdx() >= len(self.c.Model().Commits)-1 {
return self.c.ErrorMsg(self.c.Tr.CannotSquashOrFixupFirstCommit)
}
@ -257,7 +257,7 @@ func (self *LocalCommitsController) reword(commit *models.Commit) error {
return nil
}
message, err := self.git.Commit.GetCommitMessage(commit.Sha)
message, err := self.c.Git().Commit.GetCommitMessage(commit.Sha)
if err != nil {
return self.c.Error(err)
}
@ -268,7 +268,7 @@ func (self *LocalCommitsController) reword(commit *models.Commit) error {
InitialContent: message,
HandleConfirm: func(response string) error {
self.c.LogAction(self.c.Tr.Actions.RewordCommit)
if err := self.git.Rebase.RewordCommit(self.model.Commits, self.context().GetSelectedLineIdx(), response); err != nil {
if err := self.c.Git().Rebase.RewordCommit(self.c.Model().Commits, self.context().GetSelectedLineIdx(), response); err != nil {
return self.c.Error(err)
}
@ -281,11 +281,11 @@ func (self *LocalCommitsController) doRewordEditor() error {
self.c.LogAction(self.c.Tr.Actions.RewordCommit)
if self.isHeadCommit() {
return self.c.RunSubprocessAndRefresh(self.os.Cmd.New("git commit --allow-empty --amend --only"))
return self.c.RunSubprocessAndRefresh(self.c.OS().Cmd.New("git commit --allow-empty --amend --only"))
}
subProcess, err := self.git.Rebase.RewordCommitInEditor(
self.model.Commits, self.context().GetSelectedLineIdx(),
subProcess, err := self.c.Git().Rebase.RewordCommitInEditor(
self.c.Model().Commits, self.context().GetSelectedLineIdx(),
)
if err != nil {
return self.c.Error(err)
@ -349,7 +349,7 @@ func (self *LocalCommitsController) edit(commit *models.Commit) error {
return self.c.WithWaitingStatus(self.c.Tr.RebasingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.EditCommit)
err := self.git.Rebase.InteractiveRebaseBreakAfter(self.model.Commits, self.context().GetSelectedLineIdx())
err := self.c.Git().Rebase.InteractiveRebaseBreakAfter(self.c.Model().Commits, self.context().GetSelectedLineIdx())
return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
})
}
@ -369,7 +369,7 @@ func (self *LocalCommitsController) pick(commit *models.Commit) error {
}
func (self *LocalCommitsController) interactiveRebase(action string) error {
err := self.git.Rebase.InteractiveRebase(self.model.Commits, self.context().GetSelectedLineIdx(), action)
err := self.c.Git().Rebase.InteractiveRebase(self.c.Model().Commits, self.context().GetSelectedLineIdx(), action)
return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
}
@ -378,7 +378,7 @@ func (self *LocalCommitsController) interactiveRebase(action string) error {
// begin a rebase. It then updates the todo file with that action
func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoCommand, commit *models.Commit) (bool, error) {
if !commit.IsTODO() {
if self.git.Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
// If we are in a rebase, the only action that is allowed for
// non-todo commits is rewording the current head commit
if !(action == todo.Reword && self.isHeadCommit()) {
@ -407,7 +407,7 @@ func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoComma
false,
)
if err := self.git.Rebase.EditRebaseTodo(commit, action); err != nil {
if err := self.c.Git().Rebase.EditRebaseTodo(commit, action); err != nil {
return false, self.c.Error(err)
}
@ -418,7 +418,7 @@ func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoComma
func (self *LocalCommitsController) moveDown(commit *models.Commit) error {
index := self.context().GetSelectedLineIdx()
commits := self.model.Commits
commits := self.c.Model().Commits
// can't move past the initial commit
if index >= len(commits)-1 {
@ -435,7 +435,7 @@ func (self *LocalCommitsController) moveDown(commit *models.Commit) error {
self.c.LogAction(self.c.Tr.Actions.MoveCommitDown)
self.c.LogCommand(fmt.Sprintf("Moving commit %s down", commit.ShortSha()), false)
if err := self.git.Rebase.MoveTodoDown(commit); err != nil {
if err := self.c.Git().Rebase.MoveTodoDown(commit); err != nil {
return self.c.Error(err)
}
self.context().MoveSelectedLine(1)
@ -444,13 +444,13 @@ func (self *LocalCommitsController) moveDown(commit *models.Commit) error {
})
}
if self.git.Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
return self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
}
return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.MoveCommitDown)
err := self.git.Rebase.MoveCommitDown(self.model.Commits, index)
err := self.c.Git().Rebase.MoveCommitDown(self.c.Model().Commits, index)
if err == nil {
self.context().MoveSelectedLine(1)
}
@ -473,7 +473,7 @@ func (self *LocalCommitsController) moveUp(commit *models.Commit) error {
false,
)
if err := self.git.Rebase.MoveTodoUp(self.model.Commits[index]); err != nil {
if err := self.c.Git().Rebase.MoveTodoUp(self.c.Model().Commits[index]); err != nil {
return self.c.Error(err)
}
self.context().MoveSelectedLine(-1)
@ -482,13 +482,13 @@ func (self *LocalCommitsController) moveUp(commit *models.Commit) error {
})
}
if self.git.Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
return self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
}
return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.MoveCommitUp)
err := self.git.Rebase.MoveCommitDown(self.model.Commits, index-1)
err := self.c.Git().Rebase.MoveCommitDown(self.c.Model().Commits, index-1)
if err == nil {
self.context().MoveSelectedLine(-1)
}
@ -504,7 +504,7 @@ func (self *LocalCommitsController) amendTo(commit *models.Commit) error {
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
}
if self.git.Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
return self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
}
@ -514,7 +514,7 @@ func (self *LocalCommitsController) amendTo(commit *models.Commit) error {
HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.AmendCommit)
err := self.git.Rebase.AmendTo(commit)
err := self.c.Git().Rebase.AmendTo(commit)
return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
})
},
@ -548,7 +548,7 @@ func (self *LocalCommitsController) amendAttribute(commit *models.Commit) error
func (self *LocalCommitsController) resetAuthor() error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.ResetCommitAuthor)
if err := self.git.Rebase.ResetCommitAuthor(self.model.Commits, self.context().GetSelectedLineIdx()); err != nil {
if err := self.c.Git().Rebase.ResetCommitAuthor(self.c.Model().Commits, self.context().GetSelectedLineIdx()); err != nil {
return self.c.Error(err)
}
@ -563,7 +563,7 @@ func (self *LocalCommitsController) setAuthor() error {
HandleConfirm: func(value string) error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.SetCommitAuthor)
if err := self.git.Rebase.SetCommitAuthor(self.model.Commits, self.context().GetSelectedLineIdx(), value); err != nil {
if err := self.c.Git().Rebase.SetCommitAuthor(self.c.Model().Commits, self.context().GetSelectedLineIdx(), value); err != nil {
return self.c.Error(err)
}
@ -586,7 +586,7 @@ func (self *LocalCommitsController) revert(commit *models.Commit) error {
}),
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RevertCommit)
if err := self.git.Commit.Revert(commit.Sha); err != nil {
if err := self.c.Git().Commit.Revert(commit.Sha); err != nil {
return self.c.Error(err)
}
return self.afterRevertCommit()
@ -599,7 +599,7 @@ func (self *LocalCommitsController) createRevertMergeCommitMenu(commit *models.C
menuItems := make([]*types.MenuItem, len(commit.Parents))
for i, parentSha := range commit.Parents {
i := i
message, err := self.git.Commit.GetCommitMessageFirstLine(parentSha)
message, err := self.c.Git().Commit.GetCommitMessageFirstLine(parentSha)
if err != nil {
return self.c.Error(err)
}
@ -609,7 +609,7 @@ func (self *LocalCommitsController) createRevertMergeCommitMenu(commit *models.C
OnPress: func() error {
parentNumber := i + 1
self.c.LogAction(self.c.Tr.Actions.RevertCommit)
if err := self.git.Commit.RevertMerge(commit.Sha, parentNumber); err != nil {
if err := self.c.Git().Commit.RevertMerge(commit.Sha, parentNumber); err != nil {
return self.c.Error(err)
}
return self.afterRevertCommit()
@ -640,7 +640,7 @@ func (self *LocalCommitsController) createFixupCommit(commit *models.Commit) err
Prompt: prompt,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.CreateFixupCommit)
if err := self.git.Commit.CreateFixupCommit(commit.Sha); err != nil {
if err := self.c.Git().Commit.CreateFixupCommit(commit.Sha); err != nil {
return self.c.Error(err)
}
@ -661,7 +661,7 @@ func (self *LocalCommitsController) squashAllAboveFixupCommits(commit *models.Co
HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.SquashingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.SquashAllAboveFixupCommits)
err := self.git.Rebase.SquashAllAboveFixupCommits(commit)
err := self.c.Git().Rebase.SquashAllAboveFixupCommits(commit)
return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
})
},
@ -822,7 +822,7 @@ func (self *LocalCommitsController) Context() types.Context {
}
func (self *LocalCommitsController) context() *context.LocalCommitsContext {
return self.contexts.LocalCommits
return self.c.Contexts().LocalCommits
}
func (self *LocalCommitsController) paste() error {
@ -830,7 +830,7 @@ func (self *LocalCommitsController) paste() error {
}
func (self *LocalCommitsController) isHeadCommit() bool {
return models.IsHeadCommit(self.model.Commits, self.context().GetSelectedLineIdx())
return models.IsHeadCommit(self.c.Model().Commits, self.context().GetSelectedLineIdx())
}
func isChangeOfRebaseTodoAllowed(action todo.TodoCommand) bool {

2
pkg/gui/controllers/menu_controller.go
View File

@ -69,5 +69,5 @@ func (self *MenuController) Context() types.Context {
}
func (self *MenuController) context() *context.MenuContext {
return self.contexts.Menu
return self.c.Contexts().Menu
}

2
pkg/gui/controllers/merge_conflicts_controller.go
View File

@ -178,7 +178,7 @@ func (self *MergeConflictsController) Context() types.Context {
}
func (self *MergeConflictsController) context() *context.MergeConflictsContext {
return self.contexts.MergeConflicts
return self.c.Contexts().MergeConflicts
}
func (self *MergeConflictsController) Escape() error {

20
pkg/gui/controllers/patch_building_controller.go
View File

@ -48,11 +48,11 @@ func (self *PatchBuildingController) GetKeybindings(opts types.KeybindingsOpts)
}
func (self *PatchBuildingController) Context() types.Context {
return self.contexts.CustomPatchBuilder
return self.c.Contexts().CustomPatchBuilder
}
func (self *PatchBuildingController) context() types.IPatchExplorerContext {
return self.contexts.CustomPatchBuilder
return self.c.Contexts().CustomPatchBuilder
}
func (self *PatchBuildingController) GetMouseKeybindings(opts types.KeybindingsOpts) []*gocui.ViewMouseBinding {
@ -72,8 +72,8 @@ func (self *PatchBuildingController) GetOnFocusLost() func(types.OnFocusLostOpts
return func(opts types.OnFocusLostOpts) error {
self.c.Views().PatchBuilding.Wrap = true
if self.git.Patch.PatchBuilder.IsEmpty() {
self.git.Patch.PatchBuilder.Reset()
if self.c.Git().Patch.PatchBuilder.IsEmpty() {
self.c.Git().Patch.PatchBuilder.Reset()
}
return nil
@ -84,7 +84,7 @@ func (self *PatchBuildingController) OpenFile() error {
self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock()
path := self.contexts.CommitFiles.GetSelectedPath()
path := self.c.Contexts().CommitFiles.GetSelectedPath()
if path == "" {
return nil
@ -97,7 +97,7 @@ func (self *PatchBuildingController) EditFile() error {
self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock()
path := self.contexts.CommitFiles.GetSelectedPath()
path := self.c.Contexts().CommitFiles.GetSelectedPath()
if path == "" {
return nil
@ -121,21 +121,21 @@ func (self *PatchBuildingController) toggleSelection() error {
self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock()
toggleFunc := self.git.Patch.PatchBuilder.AddFileLineRange
filename := self.contexts.CommitFiles.GetSelectedPath()
toggleFunc := self.c.Git().Patch.PatchBuilder.AddFileLineRange
filename := self.c.Contexts().CommitFiles.GetSelectedPath()
if filename == "" {
return nil
}
state := self.context().GetState()
includedLineIndices, err := self.git.Patch.PatchBuilder.GetFileIncLineIndices(filename)
includedLineIndices, err := self.c.Git().Patch.PatchBuilder.GetFileIncLineIndices(filename)
if err != nil {
return err
}
currentLineIsStaged := lo.Contains(includedLineIndices, state.GetSelectedLineIdx())
if currentLineIsStaged {
toggleFunc = self.git.Patch.PatchBuilder.RemoveFileLineRange
toggleFunc = self.c.Git().Patch.PatchBuilder.RemoveFileLineRange
}
// add range of lines to those set for the file

2
pkg/gui/controllers/patch_explorer_controller.go
View File

@ -254,7 +254,7 @@ func (self *PatchExplorerController) CopySelectedToClipboard() error {
selected := self.context.GetState().PlainRenderSelected()
self.c.LogAction(self.c.Tr.Actions.CopySelectedTextToClipboard)
if err := self.os.CopyToClipboard(selected); err != nil {
if err := self.c.OS().CopyToClipboard(selected); err != nil {
return self.c.Error(err)
}

11
pkg/gui/controllers/reflog_commits_controller.go
View File

@ -8,30 +8,31 @@ import (
type ReflogCommitsController struct {
baseController
*controllerCommon
context *context.ReflogCommitsContext
}
var _ types.IController = &ReflogCommitsController{}
func NewReflogCommitsController(
common *controllerCommon,
context *context.ReflogCommitsContext,
) *ReflogCommitsController {
return &ReflogCommitsController{
baseController: baseController{},
controllerCommon: common,
context: context,
}
}
func (self *ReflogCommitsController) Context() types.Context {
return self.context
return self.context()
}
func (self *ReflogCommitsController) context() *context.ReflogCommitsContext {
return self.c.Contexts().ReflogCommits
}
func (self *ReflogCommitsController) GetOnRenderToMain() func() error {
return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error {
commit := self.context.GetSelected()
commit := self.context().GetSelected()
var task types.UpdateTask
if commit == nil {
task = types.NewRenderStringTask("No reflog history")

10
pkg/gui/controllers/remote_branches_controller.go
View File

@ -81,7 +81,7 @@ func (self *RemoteBranchesController) GetOnRenderToMain() func() error {
if remoteBranch == nil {
task = types.NewRenderStringTask("No branches for this remote")
} else {
cmdObj := self.git.Branch.GetGraphCmdObj(remoteBranch.FullRefName())
cmdObj := self.c.Git().Branch.GetGraphCmdObj(remoteBranch.FullRefName())
task = types.NewRunCommandTask(cmdObj.GetCmd())
}
@ -101,7 +101,7 @@ func (self *RemoteBranchesController) Context() types.Context {
}
func (self *RemoteBranchesController) context() *context.RemoteBranchesContext {
return self.contexts.RemoteBranches
return self.c.Contexts().RemoteBranches
}
func (self *RemoteBranchesController) checkSelected(callback func(*models.RemoteBranch) error) func() error {
@ -116,7 +116,7 @@ func (self *RemoteBranchesController) checkSelected(callback func(*models.Remote
}
func (self *RemoteBranchesController) escape() error {
return self.c.PushContext(self.contexts.Remotes)
return self.c.PushContext(self.c.Contexts().Remotes)
}
func (self *RemoteBranchesController) delete(selectedBranch *models.RemoteBranch) error {
@ -128,7 +128,7 @@ func (self *RemoteBranchesController) delete(selectedBranch *models.RemoteBranch
HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.DeletingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteRemoteBranch)
err := self.git.Remote.DeleteRemoteBranch(selectedBranch.RemoteName, selectedBranch.Name)
err := self.c.Git().Remote.DeleteRemoteBranch(selectedBranch.RemoteName, selectedBranch.Name)
if err != nil {
_ = self.c.Error(err)
}
@ -167,7 +167,7 @@ func (self *RemoteBranchesController) setAsUpstream(selectedBranch *models.Remot
Prompt: message,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.SetBranchUpstream)
if err := self.git.Branch.SetUpstream(selectedBranch.RemoteName, selectedBranch.Name, checkedOutBranch.Name); err != nil {
if err := self.c.Git().Branch.SetUpstream(selectedBranch.RemoteName, selectedBranch.Name, checkedOutBranch.Name); err != nil {
return self.c.Error(err)
}

36
pkg/gui/controllers/remotes_controller.go
View File

@ -14,7 +14,6 @@ import (
type RemotesController struct {
baseController
*controllerCommon
context *context.RemotesContext
setRemoteBranches func([]*models.RemoteBranch)
}
@ -28,7 +27,6 @@ func NewRemotesController(
return &RemotesController{
baseController: baseController{},
controllerCommon: common,
context: common.contexts.Remotes,
setRemoteBranches: setRemoteBranches,
}
}
@ -64,11 +62,19 @@ func (self *RemotesController) GetKeybindings(opts types.KeybindingsOpts) []*typ
return bindings
}
func (self *RemotesController) Context() types.Context {
return self.context()
}
func (self *RemotesController) context() *context.RemotesContext {
return self.c.Contexts().Remotes
}
func (self *RemotesController) GetOnRenderToMain() func() error {
return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error {
var task types.UpdateTask
remote := self.context.GetSelected()
remote := self.context().GetSelected()
if remote == nil {
task = types.NewRenderStringTask("No remotes")
} else {
@ -98,14 +104,14 @@ func (self *RemotesController) enter(remote *models.Remote) error {
if len(remote.Branches) == 0 {
newSelectedLine = -1
}
self.contexts.RemoteBranches.SetSelectedLineIdx(newSelectedLine)
self.contexts.RemoteBranches.SetTitleRef(remote.Name)
self.c.Contexts().RemoteBranches.SetSelectedLineIdx(newSelectedLine)
self.c.Contexts().RemoteBranches.SetTitleRef(remote.Name)
if err := self.c.PostRefreshUpdate(self.contexts.RemoteBranches); err != nil {
if err := self.c.PostRefreshUpdate(self.c.Contexts().RemoteBranches); err != nil {
return err
}
return self.c.PushContext(self.contexts.RemoteBranches)
return self.c.PushContext(self.c.Contexts().RemoteBranches)
}
func (self *RemotesController) add() error {
@ -116,7 +122,7 @@ func (self *RemotesController) add() error {
Title: self.c.Tr.LcNewRemoteUrl,
HandleConfirm: func(remoteUrl string) error {
self.c.LogAction(self.c.Tr.Actions.AddRemote)
if err := self.git.Remote.AddRemote(remoteName, remoteUrl); err != nil {
if err := self.c.Git().Remote.AddRemote(remoteName, remoteUrl); err != nil {
return err
}
return self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.REMOTES}})
@ -132,7 +138,7 @@ func (self *RemotesController) remove(remote *models.Remote) error {
Prompt: self.c.Tr.LcRemoveRemotePrompt + " '" + remote.Name + "'?",
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveRemote)
if err := self.git.Remote.RemoveRemote(remote.Name); err != nil {
if err := self.c.Git().Remote.RemoveRemote(remote.Name); err != nil {
return self.c.Error(err)
}
@ -155,7 +161,7 @@ func (self *RemotesController) edit(remote *models.Remote) error {
HandleConfirm: func(updatedRemoteName string) error {
if updatedRemoteName != remote.Name {
self.c.LogAction(self.c.Tr.Actions.UpdateRemote)
if err := self.git.Remote.RenameRemote(remote.Name, updatedRemoteName); err != nil {
if err := self.c.Git().Remote.RenameRemote(remote.Name, updatedRemoteName); err != nil {
return self.c.Error(err)
}
}
@ -178,7 +184,7 @@ func (self *RemotesController) edit(remote *models.Remote) error {
InitialContent: url,
HandleConfirm: func(updatedRemoteUrl string) error {
self.c.LogAction(self.c.Tr.Actions.UpdateRemote)
if err := self.git.Remote.UpdateRemoteUrl(updatedRemoteName, updatedRemoteUrl); err != nil {
if err := self.c.Git().Remote.UpdateRemoteUrl(updatedRemoteName, updatedRemoteUrl); err != nil {
return self.c.Error(err)
}
return self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.BRANCHES, types.REMOTES}})
@ -190,7 +196,7 @@ func (self *RemotesController) edit(remote *models.Remote) error {
func (self *RemotesController) fetch(remote *models.Remote) error {
return self.c.WithWaitingStatus(self.c.Tr.FetchingRemoteStatus, func() error {
err := self.git.Sync.FetchRemote(remote.Name)
err := self.c.Git().Sync.FetchRemote(remote.Name)
if err != nil {
_ = self.c.Error(err)
}
@ -201,7 +207,7 @@ func (self *RemotesController) fetch(remote *models.Remote) error {
func (self *RemotesController) checkSelected(callback func(*models.Remote) error) func() error {
return func() error {
file := self.context.GetSelected()
file := self.context().GetSelected()
if file == nil {
return nil
}
@ -209,7 +215,3 @@ func (self *RemotesController) checkSelected(callback func(*models.Remote) error
return callback(file)
}
}
func (self *RemotesController) Context() types.Context {
return self.context
}

6
pkg/gui/controllers/snake_controller.go
View File

@ -49,7 +49,7 @@ func (self *SnakeController) GetKeybindings(opts types.KeybindingsOpts) []*types
}
func (self *SnakeController) Context() types.Context {
return self.contexts.Snake
return self.c.Contexts().Snake
}
func (self *SnakeController) GetOnFocus() func(types.OnFocusOpts) error {
@ -62,7 +62,7 @@ func (self *SnakeController) GetOnFocus() func(types.OnFocusOpts) error {
func (self *SnakeController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
return func(types.OnFocusLostOpts) error {
self.helpers.Snake.ExitGame()
self.helpers.Window.MoveToTopOfWindow(self.contexts.Submodules)
self.helpers.Window.MoveToTopOfWindow(self.c.Contexts().Submodules)
return nil
}
}
@ -75,5 +75,5 @@ func (self *SnakeController) SetDirection(direction snake.Direction) func() erro
}
func (self *SnakeController) Escape() error {
return self.c.PushContext(self.contexts.Submodules)
return self.c.PushContext(self.c.Contexts().Submodules)
}

14
pkg/gui/controllers/staging_controller.go
View File

@ -115,8 +115,8 @@ func (self *StagingController) GetOnFocusLost() func(types.OnFocusLostOpts) erro
if opts.NewContextKey != self.otherContext.GetKey() {
self.c.Views().Staging.Wrap = true
self.c.Views().StagingSecondary.Wrap = true
_ = self.contexts.Staging.Render(false)
_ = self.contexts.StagingSecondary.Render(false)
_ = self.c.Contexts().Staging.Render(false)
_ = self.c.Contexts().StagingSecondary.Render(false)
}
return nil
}
@ -221,7 +221,7 @@ func (self *StagingController) applySelection(reverse bool) error {
applyFlags = append(applyFlags, "cached")
}
self.c.LogAction(self.c.Tr.Actions.ApplyPatch)
err := self.git.WorkingTree.ApplyPatch(patchToApply, applyFlags...)
err := self.c.Git().WorkingTree.ApplyPatch(patchToApply, applyFlags...)
if err != nil {
return self.c.Error(err)
}
@ -262,7 +262,7 @@ func (self *StagingController) editHunk() error {
}).
FormatPlain()
patchFilepath, err := self.git.WorkingTree.SaveTemporaryPatch(patchText)
patchFilepath, err := self.c.Git().WorkingTree.SaveTemporaryPatch(patchText)
if err != nil {
return err
}
@ -273,7 +273,7 @@ func (self *StagingController) editHunk() error {
return err
}
editedPatchText, err := self.git.File.Cat(patchFilepath)
editedPatchText, err := self.c.Git().File.Cat(patchFilepath)
if err != nil {
return err
}
@ -293,7 +293,7 @@ func (self *StagingController) editHunk() error {
if self.staged {
applyFlags = append(applyFlags, "reverse")
}
if err := self.git.WorkingTree.ApplyPatch(newPatchText, applyFlags...); err != nil {
if err := self.c.Git().WorkingTree.ApplyPatch(newPatchText, applyFlags...); err != nil {
return self.c.Error(err)
}
@ -301,5 +301,5 @@ func (self *StagingController) editHunk() error {
}
func (self *StagingController) FilePath() string {
return self.contexts.Files.GetSelectedPath()
return self.c.Contexts().Files.GetSelectedPath()
}

12
pkg/gui/controllers/stash_controller.go
View File

@ -63,7 +63,7 @@ func (self *StashController) GetOnRenderToMain() func() error {
if stashEntry == nil {
task = types.NewRenderStringTask(self.c.Tr.NoStashEntries)
} else {
task = types.NewRunPtyTask(self.git.Stash.ShowStashEntryCmdObj(stashEntry.Index).GetCmd())
task = types.NewRunPtyTask(self.c.Git().Stash.ShowStashEntryCmdObj(stashEntry.Index).GetCmd())
}
return self.c.RenderToMainViews(types.RefreshMainOpts{
@ -93,13 +93,13 @@ func (self *StashController) Context() types.Context {
}
func (self *StashController) context() *context.StashContext {
return self.contexts.Stash
return self.c.Contexts().Stash
}
func (self *StashController) handleStashApply(stashEntry *models.StashEntry) error {
apply := func() error {
self.c.LogAction(self.c.Tr.Actions.Stash)
err := self.git.Stash.Apply(stashEntry.Index)
err := self.c.Git().Stash.Apply(stashEntry.Index)
_ = self.postStashRefresh()
if err != nil {
return self.c.Error(err)
@ -123,7 +123,7 @@ func (self *StashController) handleStashApply(stashEntry *models.StashEntry) err
func (self *StashController) handleStashPop(stashEntry *models.StashEntry) error {
pop := func() error {
self.c.LogAction(self.c.Tr.Actions.Stash)
err := self.git.Stash.Pop(stashEntry.Index)
err := self.c.Git().Stash.Pop(stashEntry.Index)
_ = self.postStashRefresh()
if err != nil {
return self.c.Error(err)
@ -150,7 +150,7 @@ func (self *StashController) handleStashDrop(stashEntry *models.StashEntry) erro
Prompt: self.c.Tr.SureDropStashEntry,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.Stash)
err := self.git.Stash.Drop(stashEntry.Index)
err := self.c.Git().Stash.Drop(stashEntry.Index)
_ = self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STASH}})
if err != nil {
return self.c.Error(err)
@ -181,7 +181,7 @@ func (self *StashController) handleRenameStashEntry(stashEntry *models.StashEntr
InitialContent: stashEntry.Name,
HandleConfirm: func(response string) error {
self.c.LogAction(self.c.Tr.Actions.RenameStash)
err := self.git.Stash.Rename(stashEntry.Index, response)
err := self.c.Git().Stash.Rename(stashEntry.Index, response)
_ = self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STASH}})
if err != nil {
return err

6
pkg/gui/controllers/status_controller.go
View File

@ -91,7 +91,7 @@ func (self *StatusController) GetOnClick() func() error {
}
func (self *StatusController) Context() types.Context {
return self.contexts.Status
return self.c.Contexts().Status
}
func (self *StatusController) onClick() error {
@ -109,7 +109,7 @@ func (self *StatusController) onClick() error {
cx, _ := self.c.Views().Status.Cursor()
upstreamStatus := presentation.BranchStatus(currentBranch, self.c.Tr)
repoName := utils.GetCurrentRepoName()
workingTreeState := self.git.Status.WorkingTreeState()
workingTreeState := self.c.Git().Status.WorkingTreeState()
switch workingTreeState {
case enums.REBASE_MODE_REBASING, enums.REBASE_MODE_MERGING:
workingTreeStatus := fmt.Sprintf("(%s)", presentation.FormatWorkingTreeState(workingTreeState))
@ -181,7 +181,7 @@ func (self *StatusController) editConfig() error {
}
func (self *StatusController) showAllBranchLogs() error {
cmdObj := self.git.Branch.AllBranchesLogCmdObj()
cmdObj := self.c.Git().Branch.AllBranchesLogCmdObj()
task := types.NewRunPtyTask(cmdObj.GetCmd())
return self.c.RenderToMainViews(types.RefreshMainOpts{

15
pkg/gui/controllers/sub_commits_controller.go
View File

@ -9,35 +9,36 @@ import (
type SubCommitsController struct {
baseController
*controllerCommon
context *context.SubCommitsContext
}
var _ types.IController = &SubCommitsController{}
func NewSubCommitsController(
common *controllerCommon,
context *context.SubCommitsContext,
) *SubCommitsController {
return &SubCommitsController{
baseController: baseController{},
controllerCommon: common,
context: context,
}
}
func (self *SubCommitsController) Context() types.Context {
return self.context
return self.context()
}
func (self *SubCommitsController) context() *context.SubCommitsContext {
return self.c.Contexts().SubCommits
}
func (self *SubCommitsController) GetOnRenderToMain() func() error {
return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error {
commit := self.context.GetSelected()
commit := self.context().GetSelected()
var task types.UpdateTask
if commit == nil {
task = types.NewRenderStringTask("No commits")
} else {
cmdObj := self.git.Commit.ShowCmdObj(commit.Sha, self.modes.Filtering.GetPath(), self.c.State().GetIgnoreWhitespaceInDiffView())
cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Sha, self.c.Modes().Filtering.GetPath(), self.c.State().GetIgnoreWhitespaceInDiffView())
task = types.NewRunPtyTask(cmdObj.GetCmd())
}
@ -55,7 +56,7 @@ func (self *SubCommitsController) GetOnRenderToMain() func() error {
func (self *SubCommitsController) GetOnFocus() func(types.OnFocusOpts) error {
return func(types.OnFocusOpts) error {
context := self.context
context := self.context()
if context.GetSelectedLineIdx() > COMMIT_THRESHOLD && context.GetLimitCommits() {
context.SetLimitCommits(false)
go utils.Safe(func() {

28
pkg/gui/controllers/submodules_controller.go
View File

@ -96,7 +96,7 @@ func (self *SubmodulesController) GetOnRenderToMain() func() error {
if file == nil {
task = types.NewRenderStringTask(prefix)
} else {
cmdObj := self.git.WorkingTree.WorktreeFileDiffCmdObj(file, false, !file.HasUnstagedChanges && file.HasStagedChanges, self.c.State().GetIgnoreWhitespaceInDiffView())
cmdObj := self.c.Git().WorkingTree.WorktreeFileDiffCmdObj(file, false, !file.HasUnstagedChanges && file.HasStagedChanges, self.c.State().GetIgnoreWhitespaceInDiffView())
task = types.NewRunCommandTaskWithPrefix(cmdObj.GetCmd(), prefix)
}
}
@ -132,7 +132,7 @@ func (self *SubmodulesController) add() error {
HandleConfirm: func(submodulePath string) error {
return self.c.WithWaitingStatus(self.c.Tr.LcAddingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.AddSubmodule)
err := self.git.Submodule.Add(submoduleName, submodulePath, submoduleUrl)
err := self.c.Git().Submodule.Add(submoduleName, submodulePath, submoduleUrl)
if err != nil {
_ = self.c.Error(err)
}
@ -154,7 +154,7 @@ func (self *SubmodulesController) editURL(submodule *models.SubmoduleConfig) err
HandleConfirm: func(newUrl string) error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleUrlStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.UpdateSubmoduleUrl)
err := self.git.Submodule.UpdateUrl(submodule.Name, submodule.Path, newUrl)
err := self.c.Git().Submodule.UpdateUrl(submodule.Name, submodule.Path, newUrl)
if err != nil {
_ = self.c.Error(err)
}
@ -168,7 +168,7 @@ func (self *SubmodulesController) editURL(submodule *models.SubmoduleConfig) err
func (self *SubmodulesController) init(submodule *models.SubmoduleConfig) error {
return self.c.WithWaitingStatus(self.c.Tr.LcInitializingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.InitialiseSubmodule)
err := self.git.Submodule.Init(submodule.Path)
err := self.c.Git().Submodule.Init(submodule.Path)
if err != nil {
_ = self.c.Error(err)
}
@ -182,11 +182,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Title: self.c.Tr.LcBulkSubmoduleOptions,
Items: []*types.MenuItem{
{
LabelColumns: []string{self.c.Tr.LcBulkInitSubmodules, style.FgGreen.Sprint(self.git.Submodule.BulkInitCmdObj().ToString())},
LabelColumns: []string{self.c.Tr.LcBulkInitSubmodules, style.FgGreen.Sprint(self.c.Git().Submodule.BulkInitCmdObj().ToString())},
OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkInitialiseSubmodules)
err := self.git.Submodule.BulkInitCmdObj().Run()
err := self.c.Git().Submodule.BulkInitCmdObj().Run()
if err != nil {
return self.c.Error(err)
}
@ -197,11 +197,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Key: 'i',
},
{
LabelColumns: []string{self.c.Tr.LcBulkUpdateSubmodules, style.FgYellow.Sprint(self.git.Submodule.BulkUpdateCmdObj().ToString())},
LabelColumns: []string{self.c.Tr.LcBulkUpdateSubmodules, style.FgYellow.Sprint(self.c.Git().Submodule.BulkUpdateCmdObj().ToString())},
OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkUpdateSubmodules)
if err := self.git.Submodule.BulkUpdateCmdObj().Run(); err != nil {
if err := self.c.Git().Submodule.BulkUpdateCmdObj().Run(); err != nil {
return self.c.Error(err)
}
@ -211,11 +211,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Key: 'u',
},
{
LabelColumns: []string{self.c.Tr.LcBulkDeinitSubmodules, style.FgRed.Sprint(self.git.Submodule.BulkDeinitCmdObj().ToString())},
LabelColumns: []string{self.c.Tr.LcBulkDeinitSubmodules, style.FgRed.Sprint(self.c.Git().Submodule.BulkDeinitCmdObj().ToString())},
OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkDeinitialiseSubmodules)
if err := self.git.Submodule.BulkDeinitCmdObj().Run(); err != nil {
if err := self.c.Git().Submodule.BulkDeinitCmdObj().Run(); err != nil {
return self.c.Error(err)
}
@ -231,7 +231,7 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
func (self *SubmodulesController) update(submodule *models.SubmoduleConfig) error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.UpdateSubmodule)
err := self.git.Submodule.Update(submodule.Path)
err := self.c.Git().Submodule.Update(submodule.Path)
if err != nil {
_ = self.c.Error(err)
}
@ -246,7 +246,7 @@ func (self *SubmodulesController) remove(submodule *models.SubmoduleConfig) erro
Prompt: fmt.Sprintf(self.c.Tr.RemoveSubmodulePrompt, submodule.Name),
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveSubmodule)
if err := self.git.Submodule.Delete(submodule); err != nil {
if err := self.c.Git().Submodule.Delete(submodule); err != nil {
return self.c.Error(err)
}
@ -256,7 +256,7 @@ func (self *SubmodulesController) remove(submodule *models.SubmoduleConfig) erro
}
func (self *SubmodulesController) easterEgg() error {
return self.c.PushContext(self.contexts.Snake)
return self.c.PushContext(self.c.Contexts().Snake)
}
func (self *SubmodulesController) checkSelected(callback func(*models.SubmoduleConfig) error) func() error {
@ -275,5 +275,5 @@ func (self *SubmodulesController) Context() types.Context {
}
func (self *SubmodulesController) context() *context.SubmodulesContext {
return self.contexts.Submodules
return self.c.Contexts().Submodules
}

4
pkg/gui/controllers/suggestions_controller.go
View File

@ -33,7 +33,7 @@ func (self *SuggestionsController) GetKeybindings(opts types.KeybindingsOpts) []
},
{
Key: opts.GetKey(opts.Config.Universal.TogglePanel),
Handler: func() error { return self.c.ReplaceContext(self.contexts.Confirmation) },
Handler: func() error { return self.c.ReplaceContext(self.c.Contexts().Confirmation) },
},
}
@ -52,5 +52,5 @@ func (self *SuggestionsController) Context() types.Context {
}
func (self *SuggestionsController) context() *context.SuggestionsContext {
return self.contexts.Suggestions
return self.c.Contexts().Suggestions
}

20
pkg/gui/controllers/switch_to_sub_commits_controller.go
View File

@ -57,10 +57,10 @@ func (self *SwitchToSubCommitsController) viewCommits() error {
}
// need to populate my sub commits
commits, err := self.git.Loaders.CommitLoader.GetCommits(
commits, err := self.c.Git().Loaders.CommitLoader.GetCommits(
git_commands.GetCommitsOptions{
Limit: true,
FilterPath: self.modes.Filtering.GetPath(),
FilterPath: self.c.Modes().Filtering.GetPath(),
IncludeRebaseCommits: false,
RefName: ref.FullRefName(),
},
@ -71,19 +71,19 @@ func (self *SwitchToSubCommitsController) viewCommits() error {
self.setSubCommits(commits)
self.contexts.SubCommits.SetSelectedLineIdx(0)
self.contexts.SubCommits.SetParentContext(self.context)
self.contexts.SubCommits.SetWindowName(self.context.GetWindowName())
self.contexts.SubCommits.SetTitleRef(ref.Description())
self.contexts.SubCommits.SetRef(ref)
self.contexts.SubCommits.SetLimitCommits(true)
self.c.Contexts().SubCommits.SetSelectedLineIdx(0)
self.c.Contexts().SubCommits.SetParentContext(self.context)
self.c.Contexts().SubCommits.SetWindowName(self.context.GetWindowName())
self.c.Contexts().SubCommits.SetTitleRef(ref.Description())
self.c.Contexts().SubCommits.SetRef(ref)
self.c.Contexts().SubCommits.SetLimitCommits(true)
err = self.c.PostRefreshUpdate(self.contexts.SubCommits)
err = self.c.PostRefreshUpdate(self.c.Contexts().SubCommits)
if err != nil {
return err
}
return self.c.PushContext(self.contexts.SubCommits)
return self.c.PushContext(self.c.Contexts().SubCommits)
}
func (self *SwitchToSubCommitsController) Context() types.Context {

8
pkg/gui/controllers/sync_controller.go
View File

@ -76,7 +76,7 @@ func (self *SyncController) push(currentBranch *models.Branch) error {
return self.pushAux(opts)
}
} else {
if self.git.Config.GetPushToCurrent() {
if self.c.Git().Config.GetPushToCurrent() {
return self.pushAux(pushOpts{setUpstream: true})
} else {
return self.helpers.Upstream.PromptForUpstreamWithInitialContent(currentBranch, func(upstream string) error {
@ -118,7 +118,7 @@ func (self *SyncController) setCurrentBranchUpstream(upstream string) error {
return err
}
if err := self.git.Branch.SetCurrentBranchUpstream(upstreamRemote, upstreamBranch); err != nil {
if err := self.c.Git().Branch.SetCurrentBranchUpstream(upstreamRemote, upstreamBranch); err != nil {
if strings.Contains(err.Error(), "does not exist") {
return fmt.Errorf(
"upstream branch %s/%s not found.\nIf you expect it to exist, you should fetch (with 'f').\nOtherwise, you should push (with 'shift+P')",
@ -146,7 +146,7 @@ func (self *SyncController) PullAux(opts PullFilesOptions) error {
func (self *SyncController) pullWithLock(opts PullFilesOptions) error {
self.c.LogAction(opts.Action)
err := self.git.Sync.Pull(
err := self.c.Git().Sync.Pull(
git_commands.PullOptions{
RemoteName: opts.UpstreamRemote,
BranchName: opts.UpstreamBranch,
@ -167,7 +167,7 @@ type pushOpts struct {
func (self *SyncController) pushAux(opts pushOpts) error {
return self.c.WithLoaderPanel(self.c.Tr.PushWait, func() error {
self.c.LogAction(self.c.Tr.Actions.Push)
err := self.git.Sync.Push(git_commands.PushOpts{
err := self.c.Git().Sync.Push(git_commands.PushOpts{
Force: opts.force,
UpstreamRemote: opts.upstreamRemote,
UpstreamBranch: opts.upstreamBranch,

10
pkg/gui/controllers/tags_controller.go
View File

@ -64,7 +64,7 @@ func (self *TagsController) GetOnRenderToMain() func() error {
if tag == nil {
task = types.NewRenderStringTask("No tags")
} else {
cmdObj := self.git.Branch.GetGraphCmdObj(tag.FullRefName())
cmdObj := self.c.Git().Branch.GetGraphCmdObj(tag.FullRefName())
task = types.NewRunCommandTask(cmdObj.GetCmd())
}
@ -84,7 +84,7 @@ func (self *TagsController) checkout(tag *models.Tag) error {
if err := self.helpers.Refs.CheckoutRef(tag.Name, types.CheckoutRefOptions{}); err != nil {
return err
}
return self.c.PushContext(self.contexts.Branches)
return self.c.PushContext(self.c.Contexts().Branches)
}
func (self *TagsController) delete(tag *models.Tag) error {
@ -100,7 +100,7 @@ func (self *TagsController) delete(tag *models.Tag) error {
Prompt: prompt,
HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteTag)
if err := self.git.Tag.Delete(tag.Name); err != nil {
if err := self.c.Git().Tag.Delete(tag.Name); err != nil {
return self.c.Error(err)
}
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.COMMITS, types.TAGS}})
@ -123,7 +123,7 @@ func (self *TagsController) push(tag *models.Tag) error {
HandleConfirm: func(response string) error {
return self.c.WithWaitingStatus(self.c.Tr.PushingTagStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.PushTag)
err := self.git.Tag.Push(response, tag.Name)
err := self.c.Git().Tag.Push(response, tag.Name)
if err != nil {
_ = self.c.Error(err)
}
@ -159,5 +159,5 @@ func (self *TagsController) Context() types.Context {
}
func (self *TagsController) context() *context.TagsContext {
return self.contexts.Tags
return self.c.Contexts().Tags
}

10
pkg/gui/controllers/undo_controller.go
View File

@ -76,7 +76,7 @@ func (self *UndoController) reflogUndo() error {
undoEnvVars := []string{"GIT_REFLOG_ACTION=[lazygit undo]"}
undoingStatus := self.c.Tr.UndoingStatus
if self.git.Status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
if self.c.Git().Status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
return self.c.ErrorMsg(self.c.Tr.LcCantUndoWhileRebasing)
}
@ -124,7 +124,7 @@ func (self *UndoController) reflogRedo() error {
redoEnvVars := []string{"GIT_REFLOG_ACTION=[lazygit redo]"}
redoingStatus := self.c.Tr.RedoingStatus
if self.git.Status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
if self.c.Git().Status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
return self.c.ErrorMsg(self.c.Tr.LcCantRedoWhileRebasing)
}
@ -179,7 +179,7 @@ func (self *UndoController) reflogRedo() error {
// Though we might support this later, hence the use of the CURRENT_REBASE action kind.
func (self *UndoController) parseReflogForActions(onUserAction func(counter int, action reflogAction) (bool, error)) error {
counter := 0
reflogCommits := self.model.FilteredReflogCommits
reflogCommits := self.c.Model().FilteredReflogCommits
rebaseFinishCommitSha := ""
var action *reflogAction
for reflogCommitIdx, reflogCommit := range reflogCommits {
@ -248,14 +248,14 @@ func (self *UndoController) hardResetWithAutoStash(commitSha string, options har
Prompt: self.c.Tr.AutoStashPrompt,
HandleConfirm: func() error {
return self.c.WithWaitingStatus(options.WaitingStatus, func() error {
if err := self.git.Stash.Save(self.c.Tr.StashPrefix + commitSha); err != nil {
if err := self.c.Git().Stash.Save(self.c.Tr.StashPrefix + commitSha); err != nil {
return self.c.Error(err)
}
if err := reset(); err != nil {
return err
}
err := self.git.Stash.Pop(0)
err := self.c.Git().Stash.Pop(0)
if err := self.c.Refresh(types.RefreshOptions{}); err != nil {
return err
}

18
pkg/gui/controllers/workspace_reset_controller.go
View File

@ -13,7 +13,7 @@ func (self *FilesController) createResetMenu() error {
red := style.FgRed
nukeStr := "git reset --hard HEAD && git clean -fd"
if len(self.model.Submodules) > 0 {
if len(self.c.Model().Submodules) > 0 {
nukeStr = fmt.Sprintf("%s (%s)", nukeStr, self.c.Tr.LcAndResetSubmodules)
}
@ -25,7 +25,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.NukeWorkingTree)
if err := self.git.WorkingTree.ResetAndClean(); err != nil {
if err := self.c.Git().WorkingTree.ResetAndClean(); err != nil {
return self.c.Error(err)
}
@ -41,7 +41,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardUnstagedFileChanges)
if err := self.git.WorkingTree.DiscardAnyUnstagedFileChanges(); err != nil {
if err := self.c.Git().WorkingTree.DiscardAnyUnstagedFileChanges(); err != nil {
return self.c.Error(err)
}
@ -56,7 +56,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveUntrackedFiles)
if err := self.git.WorkingTree.RemoveUntrackedFiles(); err != nil {
if err := self.c.Git().WorkingTree.RemoveUntrackedFiles(); err != nil {
return self.c.Error(err)
}
@ -75,10 +75,10 @@ func (self *FilesController) createResetMenu() error {
if !self.helpers.WorkingTree.IsWorkingTreeDirty() {
return self.c.ErrorMsg(self.c.Tr.NoTrackedStagedFilesStash)
}
if err := self.git.Stash.SaveStagedChanges("[lazygit] tmp stash"); err != nil {
if err := self.c.Git().Stash.SaveStagedChanges("[lazygit] tmp stash"); err != nil {
return self.c.Error(err)
}
if err := self.git.Stash.DropNewest(); err != nil {
if err := self.c.Git().Stash.DropNewest(); err != nil {
return self.c.Error(err)
}
@ -93,7 +93,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.SoftReset)
if err := self.git.WorkingTree.ResetSoft("HEAD"); err != nil {
if err := self.c.Git().WorkingTree.ResetSoft("HEAD"); err != nil {
return self.c.Error(err)
}
@ -108,7 +108,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.MixedReset)
if err := self.git.WorkingTree.ResetMixed("HEAD"); err != nil {
if err := self.c.Git().WorkingTree.ResetMixed("HEAD"); err != nil {
return self.c.Error(err)
}
@ -123,7 +123,7 @@ func (self *FilesController) createResetMenu() error {
},
OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.HardReset)
if err := self.git.WorkingTree.ResetHard("HEAD"); err != nil {
if err := self.c.Git().WorkingTree.ResetHard("HEAD"); err != nil {
return self.c.Error(err)
}