sysutils/lazygit
1
0
Fork 0
mirror of https://github.com/jesseduffield/lazygit.git synced 2025-07-30 03:23:08 +03:00
Code 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
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() { func (gui *Gui) resetControllers() {
helperCommon := gui.c helperCommon := gui.c
osCommand := gui.os
model := gui.State.Model
refsHelper := helpers.NewRefsHelper(helperCommon) refsHelper := helpers.NewRefsHelper(helperCommon)
rebaseHelper := helpers.NewMergeAndRebaseHelper(helperCommon, refsHelper) rebaseHelper := helpers.NewMergeAndRebaseHelper(helperCommon, refsHelper)
@ -68,16 +66,7 @@ func (gui *Gui) resetControllers() {
gui.helpers, gui.helpers,
) )
common := controllers.NewControllerCommon( common := controllers.NewControllerCommon(helperCommon, gui.helpers)
helperCommon,
osCommand,
gui.git,
gui.helpers,
model,
gui.State.Contexts,
gui.State.Modes,
&gui.Mutexes,
)
syncController := controllers.NewSyncController( syncController := controllers.NewSyncController(
common, common,
@ -140,8 +129,8 @@ func (gui *Gui) resetControllers() {
stagingSecondaryController := controllers.NewStagingController(common, gui.State.Contexts.StagingSecondary, gui.State.Contexts.Staging, true) stagingSecondaryController := controllers.NewStagingController(common, gui.State.Contexts.StagingSecondary, gui.State.Contexts.Staging, true)
patchBuildingController := controllers.NewPatchBuildingController(common) patchBuildingController := controllers.NewPatchBuildingController(common)
snakeController := controllers.NewSnakeController(common) snakeController := controllers.NewSnakeController(common)
reflogCommitsController := controllers.NewReflogCommitsController(common, gui.State.Contexts.ReflogCommits) reflogCommitsController := controllers.NewReflogCommitsController(common)
subCommitsController := controllers.NewSubCommitsController(common, gui.State.Contexts.SubCommits) subCommitsController := controllers.NewSubCommitsController(common)
statusController := controllers.NewStatusController(common) statusController := controllers.NewStatusController(common)
commandLogController := controllers.NewCommandLogController(common) commandLogController := controllers.NewCommandLogController(common)
confirmationController := controllers.NewConfirmationController(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 { func (self *BasicCommitsController) copyCommitSHAToClipboard(commit *models.Commit) error {
self.c.LogAction(self.c.Tr.Actions.CopyCommitSHAToClipboard) 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) return self.c.Error(err)
} }
@ -156,7 +156,7 @@ func (self *BasicCommitsController) copyCommitURLToClipboard(commit *models.Comm
} }
self.c.LogAction(self.c.Tr.Actions.CopyCommitURLToClipboard) 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) return self.c.Error(err)
} }
@ -165,13 +165,13 @@ func (self *BasicCommitsController) copyCommitURLToClipboard(commit *models.Comm
} }
func (self *BasicCommitsController) copyCommitDiffToClipboard(commit *models.Commit) error { 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 { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
self.c.LogAction(self.c.Tr.Actions.CopyCommitDiffToClipboard) 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) return self.c.Error(err)
} }
@ -180,7 +180,7 @@ func (self *BasicCommitsController) copyCommitDiffToClipboard(commit *models.Com
} }
func (self *BasicCommitsController) copyAuthorToClipboard(commit *models.Commit) error { 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 { if err != nil {
return self.c.Error(err) 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) formattedAuthor := fmt.Sprintf("%s <%s>", author.Name, author.Email)
self.c.LogAction(self.c.Tr.Actions.CopyCommitAuthorToClipboard) 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) return self.c.Error(err)
} }
@ -197,13 +197,13 @@ func (self *BasicCommitsController) copyAuthorToClipboard(commit *models.Commit)
} }
func (self *BasicCommitsController) copyCommitMessageToClipboard(commit *models.Commit) error { 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 { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
self.c.LogAction(self.c.Tr.Actions.CopyCommitMessageToClipboard) 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) 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) 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) 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 { func (self *BisectController) openMenu(commit *models.Commit) error {
// no shame in getting this directly rather than using the cached value // no shame in getting this directly rather than using the cached value
// given how cheap it is to obtain // given how cheap it is to obtain
info := self.git.Bisect.GetInfo() info := self.c.Git().Bisect.GetInfo()
if info.Started() { if info.Started() {
return self.openMidBisectMenu(info, commit) return self.openMidBisectMenu(info, commit)
} else { } else {
@ -63,14 +63,14 @@ func (self *BisectController) openMidBisectMenu(info *git_commands.BisectInfo, c
selectCurrentAfter := info.GetCurrentSha() == "" || info.GetCurrentSha() == commit.Sha selectCurrentAfter := info.GetCurrentSha() == "" || info.GetCurrentSha() == commit.Sha
// we need to wait to reselect if our bisect commits aren't ancestors of our 'start' // 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. // 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{ menuItems := []*types.MenuItem{
{ {
Label: fmt.Sprintf(self.c.Tr.Bisect.Mark, commit.ShortSha(), info.NewTerm()), Label: fmt.Sprintf(self.c.Tr.Bisect.Mark, commit.ShortSha(), info.NewTerm()),
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectMark) 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) 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()), Label: fmt.Sprintf(self.c.Tr.Bisect.Mark, commit.ShortSha(), info.OldTerm()),
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectMark) 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) 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()), Label: fmt.Sprintf(self.c.Tr.Bisect.Skip, commit.ShortSha()),
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.BisectSkip) 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) 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()), Label: fmt.Sprintf(self.c.Tr.Bisect.MarkStart, commit.ShortSha(), info.NewTerm()),
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.StartBisect) 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) 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) 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()), Label: fmt.Sprintf(self.c.Tr.Bisect.MarkStart, commit.ShortSha(), info.OldTerm()),
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.StartBisect) 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) 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) return self.c.Error(err)
} }
@ -163,7 +163,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
prompt = self.c.Tr.Bisect.CompletePromptIndeterminate prompt = self.c.Tr.Bisect.CompletePromptIndeterminate
} }
formattedCommits, err := self.git.Commit.GetCommitsOneline(candidateShas) formattedCommits, err := self.c.Git().Commit.GetCommitsOneline(candidateShas)
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -173,7 +173,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
Prompt: fmt.Sprintf(prompt, strings.TrimSpace(formattedCommits)), Prompt: fmt.Sprintf(prompt, strings.TrimSpace(formattedCommits)),
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.ResetBisect) 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) return self.c.Error(err)
} }
@ -183,7 +183,7 @@ func (self *BisectController) showBisectCompleteMessage(candidateShas []string)
} }
func (self *BisectController) afterMark(selectCurrent bool, waitToReselect bool) error { 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 { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -216,10 +216,10 @@ func (self *BisectController) afterBisectMarkRefresh(selectCurrent bool, waitToR
} }
func (self *BisectController) selectCurrentBisectCommit() { func (self *BisectController) selectCurrentBisectCommit() {
info := self.git.Bisect.GetInfo() info := self.c.Git().Bisect.GetInfo()
if info.GetCurrentSha() != "" { if info.GetCurrentSha() != "" {
// find index of commit with that sha, move cursor to that. // 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() { if commit.Sha == info.GetCurrentSha() {
self.context().SetSelectedLineIdx(i) self.context().SetSelectedLineIdx(i)
_ = self.context().HandleFocus(types.OnFocusOpts{}) _ = self.context().HandleFocus(types.OnFocusOpts{})
@ -245,5 +245,5 @@ func (self *BisectController) Context() types.Context {
} }
func (self *BisectController) context() *context.LocalCommitsContext { 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}, LabelColumns: []string{self.c.Tr.LcUnsetUpstream},
OnPress: func() error { 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) return self.c.Error(err)
} }
if err := self.c.Refresh(types.RefreshOptions{ if err := self.c.Refresh(types.RefreshOptions{
@ -167,7 +167,7 @@ func (self *BranchesController) setUpstream(selectedBranch *models.Branch) error
return self.c.Error(err) 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) return self.c.Error(err)
} }
if err := self.c.Refresh(types.RefreshOptions{ if err := self.c.Refresh(types.RefreshOptions{
@ -193,7 +193,7 @@ func (self *BranchesController) Context() types.Context {
} }
func (self *BranchesController) context() *context.BranchesContext { func (self *BranchesController) context() *context.BranchesContext {
return self.contexts.Branches return self.c.Contexts().Branches
} }
func (self *BranchesController) press(selectedBranch *models.Branch) error { func (self *BranchesController) press(selectedBranch *models.Branch) error {
@ -218,7 +218,7 @@ func (self *BranchesController) handleCreatePullRequestMenu(selectedBranch *mode
func (self *BranchesController) copyPullRequestURL() error { func (self *BranchesController) copyPullRequestURL() error {
branch := self.context().GetSelected() branch := self.context().GetSelected()
branchExistsOnRemote := self.git.Remote.CheckRemoteBranchExists(branch.Name) branchExistsOnRemote := self.c.Git().Remote.CheckRemoteBranchExists(branch.Name)
if !branchExistsOnRemote { if !branchExistsOnRemote {
return self.c.Error(errors.New(self.c.Tr.NoBranchOnRemote)) return self.c.Error(errors.New(self.c.Tr.NoBranchOnRemote))
@ -229,7 +229,7 @@ func (self *BranchesController) copyPullRequestURL() error {
return self.c.Error(err) return self.c.Error(err)
} }
self.c.LogAction(self.c.Tr.Actions.CopyPullRequestURL) 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) return self.c.Error(err)
} }
@ -248,7 +248,7 @@ func (self *BranchesController) forceCheckout() error {
Prompt: message, Prompt: message,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.ForceCheckoutBranch) 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) _ = self.c.Error(err)
} }
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC}) return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
@ -284,7 +284,7 @@ func (self *BranchesController) createNewBranchWithName(newBranchName string) er
return nil 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) return self.c.Error(err)
} }
@ -320,7 +320,7 @@ func (self *BranchesController) deleteWithForce(selectedBranch *models.Branch, f
Prompt: message, Prompt: message,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteBranch) 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() errMessage := err.Error()
if !force && strings.Contains(errMessage, "git branch -D ") { if !force && strings.Contains(errMessage, "git branch -D ") {
return self.deleteWithForce(selectedBranch, true) return self.deleteWithForce(selectedBranch, true)
@ -367,7 +367,7 @@ func (self *BranchesController) fastForward(branch *models.Branch) error {
if branch == self.helpers.Refs.GetCheckedOutRef() { if branch == self.helpers.Refs.GetCheckedOutRef() {
self.c.LogAction(action) self.c.LogAction(action)
err := self.git.Sync.Pull( err := self.c.Git().Sync.Pull(
git_commands.PullOptions{ git_commands.PullOptions{
RemoteName: branch.UpstreamRemote, RemoteName: branch.UpstreamRemote,
BranchName: branch.UpstreamBranch, BranchName: branch.UpstreamBranch,
@ -381,7 +381,7 @@ func (self *BranchesController) fastForward(branch *models.Branch) error {
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC}) return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC})
} else { } else {
self.c.LogAction(action) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -407,7 +407,7 @@ func (self *BranchesController) rename(branch *models.Branch) error {
InitialContent: branch.Name, InitialContent: branch.Name,
HandleConfirm: func(newBranchName string) error { HandleConfirm: func(newBranchName string) error {
self.c.LogAction(self.c.Tr.Actions.RenameBranch) 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) 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}}) _ = 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. // 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 { if newBranch.Name == newBranchName {
self.context().SetSelectedLineIdx(i) self.context().SetSelectedLineIdx(i)
if err := self.context().HandleRender(); err != nil { 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) 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) 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 { 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 // 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 // with other contexts so that when generics arrive it's easier to refactor
func (self *CommitMessageController) context() *context.CommitMessageContext { func (self *CommitMessageController) context() *context.CommitMessageContext {
return self.contexts.CommitMessage return self.c.Contexts().CommitMessage
} }
func (self *CommitMessageController) confirm() error { func (self *CommitMessageController) confirm() error {
@ -76,7 +76,7 @@ func (self *CommitMessageController) confirm() error {
return self.c.ErrorMsg(self.c.Tr.CommitWithoutMessageErr) 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.LogAction(self.c.Tr.Actions.Commit)
_ = self.c.PopContext() _ = 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 { func (self *CommitFilesController) context() *context.CommitFilesContext {
return self.contexts.CommitFiles return self.c.Contexts().CommitFiles
} }
func (self *CommitFilesController) onClickMain(opts gocui.ViewMouseBindingOpts) error { 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 { func (self *CommitFilesController) checkout(node *filetree.CommitFileNode) error {
self.c.LogAction(self.c.Tr.Actions.CheckoutFile) 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) return self.c.Error(err)
} }
@ -130,7 +130,7 @@ func (self *CommitFilesController) discard(node *filetree.CommitFileNode) error
HandleConfirm: func() error { HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.RebasingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.RebasingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardOldFileChange) 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 { if err := self.helpers.MergeAndRebase.CheckMergeOrRebase(err); err != nil {
return err return err
} }
@ -157,7 +157,7 @@ func (self *CommitFilesController) edit(node *filetree.CommitFileNode) error {
func (self *CommitFilesController) toggleForPatch(node *filetree.CommitFileNode) error { func (self *CommitFilesController) toggleForPatch(node *filetree.CommitFileNode) error {
toggle := func() error { toggle := func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingPatch, 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 { if err := self.startPatchBuilder(); err != nil {
return err 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, // if there is any file that hasn't been fully added we'll fully add everything,
// otherwise we'll remove everything // otherwise we'll remove everything
adding := node.SomeFile(func(file *models.CommitFile) bool { 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 { err := node.ForEachFile(func(file *models.CommitFile) error {
if adding { if adding {
return self.git.Patch.PatchBuilder.AddFileWhole(file.Name) return self.c.Git().Patch.PatchBuilder.AddFileWhole(file.Name)
} else { } else {
return self.git.Patch.PatchBuilder.RemoveFile(file.Name) return self.c.Git().Patch.PatchBuilder.RemoveFile(file.Name)
} }
}) })
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
if self.git.Patch.PatchBuilder.IsEmpty() { if self.c.Git().Patch.PatchBuilder.IsEmpty() {
self.git.Patch.PatchBuilder.Reset() self.c.Git().Patch.PatchBuilder.Reset()
} }
return self.c.PostRefreshUpdate(self.context()) 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{ return self.c.Confirm(types.ConfirmOpts{
Title: self.c.Tr.DiscardPatch, Title: self.c.Tr.DiscardPatch,
Prompt: self.c.Tr.DiscardPatchConfirm, Prompt: self.c.Tr.DiscardPatchConfirm,
HandleConfirm: func() error { HandleConfirm: func() error {
self.git.Patch.PatchBuilder.Reset() self.c.Git().Patch.PatchBuilder.Reset()
return toggle() return toggle()
}, },
}) })
@ -213,9 +213,9 @@ func (self *CommitFilesController) startPatchBuilder() error {
canRebase := commitFilesContext.GetCanRebase() canRebase := commitFilesContext.GetCanRebase()
ref := commitFilesContext.GetRef() ref := commitFilesContext.GetRef()
to := ref.RefName() 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 return nil
} }
@ -229,21 +229,21 @@ func (self *CommitFilesController) enterCommitFile(node *filetree.CommitFileNode
} }
enterTheFile := func() error { enterTheFile := func() error {
if !self.git.Patch.PatchBuilder.Active() { if !self.c.Git().Patch.PatchBuilder.Active() {
if err := self.startPatchBuilder(); err != nil { if err := self.startPatchBuilder(); err != nil {
return err 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{ return self.c.Confirm(types.ConfirmOpts{
Title: self.c.Tr.DiscardPatch, Title: self.c.Tr.DiscardPatch,
Prompt: self.c.Tr.DiscardPatchConfirm, Prompt: self.c.Tr.DiscardPatchConfirm,
HandleConfirm: func() error { HandleConfirm: func() error {
self.git.Patch.PatchBuilder.Reset() self.c.Git().Patch.PatchBuilder.Reset()
return enterTheFile() return enterTheFile()
}, },
}) })

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

@ -1,48 +1,20 @@
package controllers package controllers
import ( 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/controllers/helpers"
"github.com/jesseduffield/lazygit/pkg/gui/types"
) )
type controllerCommon struct { type controllerCommon struct {
c *helpers.HelperCommon c *helpers.HelperCommon
helpers *helpers.Helpers 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
} }
func NewControllerCommon( func NewControllerCommon(
c *helpers.HelperCommon, c *helpers.HelperCommon,
os *oscommands.OSCommand,
git *commands.GitCommand,
helpers *helpers.Helpers, helpers *helpers.Helpers,
model *types.Model,
contexts *context.ContextTree,
modes *types.Modes,
mutexes *types.Mutexes,
) *controllerCommon { ) *controllerCommon {
return &controllerCommon{ return &controllerCommon{
c: c, c: c,
os: os, helpers: helpers,
git: git,
helpers: helpers,
model: model,
contexts: contexts,
modes: modes,
mutexes: mutexes,
} }
} }

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), Key: opts.GetKey(opts.Config.Universal.TogglePanel),
Handler: func() error { Handler: func() error {
if len(self.contexts.Suggestions.State.Suggestions) > 0 { if len(self.c.Contexts().Suggestions.State.Suggestions) > 0 {
return self.c.ReplaceContext(self.contexts.Suggestions) return self.c.ReplaceContext(self.c.Contexts().Suggestions)
} }
return nil return nil
}, },
@ -61,5 +61,5 @@ func (self *ConfirmationController) Context() types.Context {
} }
func (self *ConfirmationController) context() *context.ConfirmationContext { 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 { 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) 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()) split := self.c.UserConfig.Gui.SplitDiff == "always" || (node.GetHasUnstagedChanges() && node.GetHasStagedChanges())
mainShowsStaged := !split && 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 title := self.c.Tr.UnstagedChanges
if mainShowsStaged { if mainShowsStaged {
title = self.c.Tr.StagedChanges title = self.c.Tr.StagedChanges
@ -222,7 +222,7 @@ func (self *FilesController) GetOnRenderToMain() func() error {
} }
if split { 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 title := self.c.Tr.StagedChanges
if mainShowsStaged { if mainShowsStaged {
@ -295,7 +295,7 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
rerender := false rerender := false
err := node.ForEachFile(func(f *models.File) error { err := node.ForEachFile(func(f *models.File) error {
// can't act on the file itself: we need to update the original model file // 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 modelFile.Name == f.Name {
if optimisticChangeFn(modelFile) { if optimisticChangeFn(modelFile) {
rerender = true rerender = true
@ -310,7 +310,7 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
return err return err
} }
if rerender { 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 return err
} }
} }
@ -321,8 +321,8 @@ func (self *FilesController) optimisticChange(node *filetree.FileNode, optimisti
func (self *FilesController) pressWithLock(node *filetree.FileNode) error { func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
// Obtaining this lock because optimistic rendering requires us to mutate // Obtaining this lock because optimistic rendering requires us to mutate
// the files in our model. // the files in our model.
self.mutexes.RefreshingFilesMutex.Lock() self.c.Mutexes().RefreshingFilesMutex.Lock()
defer self.mutexes.RefreshingFilesMutex.Unlock() defer self.c.Mutexes().RefreshingFilesMutex.Unlock()
if node.IsFile() { if node.IsFile() {
file := node.File file := node.File
@ -334,7 +334,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err 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) return self.c.Error(err)
} }
} else { } else {
@ -344,7 +344,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err 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) return self.c.Error(err)
} }
} }
@ -362,7 +362,7 @@ func (self *FilesController) pressWithLock(node *filetree.FileNode) error {
return err 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) return self.c.Error(err)
} }
} else { } 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 // 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) return self.c.Error(err)
} }
} }
@ -414,7 +414,7 @@ func (self *FilesController) Context() types.Context {
} }
func (self *FilesController) context() *context.WorkingTreeContext { func (self *FilesController) context() *context.WorkingTreeContext {
return self.contexts.Files return self.c.Contexts().Files
} }
func (self *FilesController) getSelectedFile() *models.File { func (self *FilesController) getSelectedFile() *models.File {
@ -441,7 +441,7 @@ func (self *FilesController) EnterFile(opts types.OnFocusOpts) error {
file := node.File file := node.File
submoduleConfigs := self.model.Submodules submoduleConfigs := self.c.Model().Submodules
if file.IsSubmodule(submoduleConfigs) { if file.IsSubmodule(submoduleConfigs) {
submoduleConfig := file.SubmoduleConfig(submoduleConfigs) submoduleConfig := file.SubmoduleConfig(submoduleConfigs)
return self.helpers.Repos.EnterSubmodule(submoduleConfig) 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.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 { func (self *FilesController) toggleStagedAll() error {
@ -470,8 +470,8 @@ func (self *FilesController) toggleStagedAll() error {
} }
func (self *FilesController) toggleStagedAllWithLock() error { func (self *FilesController) toggleStagedAllWithLock() error {
self.mutexes.RefreshingFilesMutex.Lock() self.c.Mutexes().RefreshingFilesMutex.Lock()
defer self.mutexes.RefreshingFilesMutex.Unlock() defer self.c.Mutexes().RefreshingFilesMutex.Unlock()
root := self.context().FileTreeViewModel.GetRoot() root := self.context().FileTreeViewModel.GetRoot()
@ -488,7 +488,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
return err return err
} }
if err := self.git.WorkingTree.StageAll(); err != nil { if err := self.c.Git().WorkingTree.StageAll(); err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
} else { } else {
@ -498,7 +498,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
return err return err
} }
if err := self.git.WorkingTree.UnstageAll(); err != nil { if err := self.c.Git().WorkingTree.UnstageAll(); err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
} }
@ -509,7 +509,7 @@ func (self *FilesController) toggleStagedAllWithLock() error {
func (self *FilesController) unstageFiles(node *filetree.FileNode) error { func (self *FilesController) unstageFiles(node *filetree.FileNode) error {
return node.ForEachFile(func(file *models.File) error { return node.ForEachFile(func(file *models.File) error {
if file.HasStagedChanges { 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 return err
} }
} }
@ -525,7 +525,7 @@ func (self *FilesController) ignoreOrExcludeTracked(node *filetree.FileNode, trA
return err 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 return err
} }
@ -563,7 +563,7 @@ func (self *FilesController) ignore(node *filetree.FileNode) error {
if node.GetPath() == ".gitignore" { if node.GetPath() == ".gitignore" {
return self.c.ErrorMsg(self.c.Tr.Actions.IgnoreFileErr) 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 { if err != nil {
return err return err
} }
@ -580,7 +580,7 @@ func (self *FilesController) exclude(node *filetree.FileNode) error {
return self.c.ErrorMsg(self.c.Tr.Actions.ExcludeGitIgnoreErr) 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 { if err != nil {
return err return err
} }
@ -620,7 +620,7 @@ func (self *FilesController) refresh() error {
} }
func (self *FilesController) handleAmendCommitPress() 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) return self.c.ErrorMsg(self.c.Tr.NoFilesStagedTitle)
} }
@ -628,7 +628,7 @@ func (self *FilesController) handleAmendCommitPress() error {
return self.helpers.WorkingTree.PromptToStageAllAndRetry(self.handleAmendCommitPress) 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) return self.c.ErrorMsg(self.c.Tr.NoCommitToAmend)
} }
@ -702,7 +702,7 @@ func (self *FilesController) createStashMenu() error {
if !self.helpers.WorkingTree.IsWorkingTreeDirty() { if !self.helpers.WorkingTree.IsWorkingTreeDirty() {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash) 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', Key: 'a',
}, },
@ -713,14 +713,14 @@ func (self *FilesController) createStashMenu() error {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash) return self.c.ErrorMsg(self.c.Tr.NoFilesToStash)
} }
// if there are no staged files it behaves the same as Stash.Save // 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', Key: 'i',
}, },
{ {
Label: self.c.Tr.LcStashIncludeUntrackedChanges, Label: self.c.Tr.LcStashIncludeUntrackedChanges,
OnPress: func() error { 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', Key: 'U',
}, },
@ -731,7 +731,7 @@ func (self *FilesController) createStashMenu() error {
if !self.helpers.WorkingTree.AnyStagedFiles() { if !self.helpers.WorkingTree.AnyStagedFiles() {
return self.c.ErrorMsg(self.c.Tr.NoTrackedStagedFilesStash) 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', Key: 's',
}, },
@ -742,10 +742,10 @@ func (self *FilesController) createStashMenu() error {
return self.c.ErrorMsg(self.c.Tr.NoFilesToStash) return self.c.ErrorMsg(self.c.Tr.NoFilesToStash)
} }
if self.helpers.WorkingTree.AnyStagedFiles() { 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 // 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', Key: 'u',
}, },
@ -754,7 +754,7 @@ func (self *FilesController) createStashMenu() error {
} }
func (self *FilesController) stash() 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 { func (self *FilesController) createResetToUpstreamMenu() error {
@ -769,7 +769,7 @@ func (self *FilesController) handleToggleDirCollapsed() error {
self.context().FileTreeViewModel.ToggleCollapsed(node.GetPath()) 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) self.c.Log.Error(err)
} }
@ -815,7 +815,7 @@ func (self *FilesController) fetch() error {
func (self *FilesController) fetchAux() (err error) { func (self *FilesController) fetchAux() (err error) {
self.c.LogAction("Fetch") 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") { if err != nil && strings.Contains(err.Error(), "exit status 128") {
_ = self.c.ErrorMsg(self.c.Tr.PassUnameWrong) _ = 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, Label: self.c.Tr.LcDiscardAllChanges,
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllChangesInDirectory) 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.Error(err)
} }
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.FILES}}) 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, Label: self.c.Tr.LcDiscardUnstagedChanges,
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardUnstagedChangesInDirectory) 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) return self.c.Error(err)
} }
@ -85,7 +85,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
} else { } else {
file := node.File file := node.File
submodules := self.model.Submodules submodules := self.c.Model().Submodules
if file.IsSubmodule(submodules) { if file.IsSubmodule(submodules) {
submodule := file.SubmoduleConfig(submodules) submodule := file.SubmoduleConfig(submodules)
@ -103,7 +103,7 @@ func (self *FilesRemoveController) remove(node *filetree.FileNode) error {
Label: self.c.Tr.LcDiscardAllChanges, Label: self.c.Tr.LcDiscardAllChanges,
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllChangesInFile) 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.Error(err)
} }
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.FILES}}) 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, Label: self.c.Tr.LcDiscardUnstagedChanges,
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardAllUnstagedChangesInFile) 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) return self.c.Error(err)
} }
@ -150,15 +150,15 @@ func (self *FilesRemoveController) ResetSubmodule(submodule *models.SubmoduleCon
file := self.helpers.WorkingTree.FileForSubmodule(submodule) file := self.helpers.WorkingTree.FileForSubmodule(submodule)
if file != nil { 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) 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) 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) return self.c.Error(err)
} }
@ -182,5 +182,5 @@ func (self *FilesRemoveController) Context() types.Context {
} }
func (self *FilesRemoveController) context() *context.WorkingTreeContext { 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 { 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") 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 { HandleConfirm: func(name string) error {
self.c.LogAction(self.c.Tr.Actions.GitFlowStart) self.c.LogAction(self.c.Tr.Actions.GitFlowStart)
return self.c.RunSubprocessAndRefresh( 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 { 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 { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -119,5 +119,5 @@ func (self *GitFlowController) Context() types.Context {
} }
func (self *GitFlowController) context() *context.BranchesContext { 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) self.c.LogAction(self.c.Tr.Actions.CustomCommand)
return self.c.RunSubprocessAndRefresh( 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 { 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) 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 { 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) return self.c.ErrorMsg(self.c.Tr.CannotSquashOrFixupFirstCommit)
} }
@ -257,7 +257,7 @@ func (self *LocalCommitsController) reword(commit *models.Commit) error {
return nil return nil
} }
message, err := self.git.Commit.GetCommitMessage(commit.Sha) message, err := self.c.Git().Commit.GetCommitMessage(commit.Sha)
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -268,7 +268,7 @@ func (self *LocalCommitsController) reword(commit *models.Commit) error {
InitialContent: message, InitialContent: message,
HandleConfirm: func(response string) error { HandleConfirm: func(response string) error {
self.c.LogAction(self.c.Tr.Actions.RewordCommit) 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) return self.c.Error(err)
} }
@ -281,11 +281,11 @@ func (self *LocalCommitsController) doRewordEditor() error {
self.c.LogAction(self.c.Tr.Actions.RewordCommit) self.c.LogAction(self.c.Tr.Actions.RewordCommit)
if self.isHeadCommit() { 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( subProcess, err := self.c.Git().Rebase.RewordCommitInEditor(
self.model.Commits, self.context().GetSelectedLineIdx(), self.c.Model().Commits, self.context().GetSelectedLineIdx(),
) )
if err != nil { if err != nil {
return self.c.Error(err) 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 { return self.c.WithWaitingStatus(self.c.Tr.RebasingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.EditCommit) 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) 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 { 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) 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 // begin a rebase. It then updates the todo file with that action
func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoCommand, commit *models.Commit) (bool, error) { func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoCommand, commit *models.Commit) (bool, error) {
if !commit.IsTODO() { 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 // If we are in a rebase, the only action that is allowed for
// non-todo commits is rewording the current head commit // non-todo commits is rewording the current head commit
if !(action == todo.Reword && self.isHeadCommit()) { if !(action == todo.Reword && self.isHeadCommit()) {
@ -407,7 +407,7 @@ func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoComma
false, 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) 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 { func (self *LocalCommitsController) moveDown(commit *models.Commit) error {
index := self.context().GetSelectedLineIdx() index := self.context().GetSelectedLineIdx()
commits := self.model.Commits commits := self.c.Model().Commits
// can't move past the initial commit // can't move past the initial commit
if index >= len(commits)-1 { 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.LogAction(self.c.Tr.Actions.MoveCommitDown)
self.c.LogCommand(fmt.Sprintf("Moving commit %s down", commit.ShortSha()), false) 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) return self.c.Error(err)
} }
self.context().MoveSelectedLine(1) 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.ErrorMsg(self.c.Tr.AlreadyRebasing)
} }
return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.MoveCommitDown) 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 { if err == nil {
self.context().MoveSelectedLine(1) self.context().MoveSelectedLine(1)
} }
@ -473,7 +473,7 @@ func (self *LocalCommitsController) moveUp(commit *models.Commit) error {
false, 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) return self.c.Error(err)
} }
self.context().MoveSelectedLine(-1) 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.ErrorMsg(self.c.Tr.AlreadyRebasing)
} }
return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.MovingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.MoveCommitUp) 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 { if err == nil {
self.context().MoveSelectedLine(-1) 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}) 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) return self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
} }
@ -514,7 +514,7 @@ func (self *LocalCommitsController) amendTo(commit *models.Commit) error {
HandleConfirm: func() error { HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.AmendCommit) 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) return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
}) })
}, },
@ -548,7 +548,7 @@ func (self *LocalCommitsController) amendAttribute(commit *models.Commit) error
func (self *LocalCommitsController) resetAuthor() error { func (self *LocalCommitsController) resetAuthor() error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.ResetCommitAuthor) 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) return self.c.Error(err)
} }
@ -563,7 +563,7 @@ func (self *LocalCommitsController) setAuthor() error {
HandleConfirm: func(value string) error { HandleConfirm: func(value string) error {
return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.AmendingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.SetCommitAuthor) 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) return self.c.Error(err)
} }
@ -586,7 +586,7 @@ func (self *LocalCommitsController) revert(commit *models.Commit) error {
}), }),
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RevertCommit) 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.c.Error(err)
} }
return self.afterRevertCommit() return self.afterRevertCommit()
@ -599,7 +599,7 @@ func (self *LocalCommitsController) createRevertMergeCommitMenu(commit *models.C
menuItems := make([]*types.MenuItem, len(commit.Parents)) menuItems := make([]*types.MenuItem, len(commit.Parents))
for i, parentSha := range commit.Parents { for i, parentSha := range commit.Parents {
i := i i := i
message, err := self.git.Commit.GetCommitMessageFirstLine(parentSha) message, err := self.c.Git().Commit.GetCommitMessageFirstLine(parentSha)
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -609,7 +609,7 @@ func (self *LocalCommitsController) createRevertMergeCommitMenu(commit *models.C
OnPress: func() error { OnPress: func() error {
parentNumber := i + 1 parentNumber := i + 1
self.c.LogAction(self.c.Tr.Actions.RevertCommit) 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.c.Error(err)
} }
return self.afterRevertCommit() return self.afterRevertCommit()
@ -640,7 +640,7 @@ func (self *LocalCommitsController) createFixupCommit(commit *models.Commit) err
Prompt: prompt, Prompt: prompt,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.CreateFixupCommit) 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) return self.c.Error(err)
} }
@ -661,7 +661,7 @@ func (self *LocalCommitsController) squashAllAboveFixupCommits(commit *models.Co
HandleConfirm: func() error { HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.SquashingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.SquashingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.SquashAllAboveFixupCommits) 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) return self.helpers.MergeAndRebase.CheckMergeOrRebase(err)
}) })
}, },
@ -822,7 +822,7 @@ func (self *LocalCommitsController) Context() types.Context {
} }
func (self *LocalCommitsController) context() *context.LocalCommitsContext { func (self *LocalCommitsController) context() *context.LocalCommitsContext {
return self.contexts.LocalCommits return self.c.Contexts().LocalCommits
} }
func (self *LocalCommitsController) paste() error { func (self *LocalCommitsController) paste() error {
@ -830,7 +830,7 @@ func (self *LocalCommitsController) paste() error {
} }
func (self *LocalCommitsController) isHeadCommit() bool { 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 { 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 { 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 { func (self *MergeConflictsController) context() *context.MergeConflictsContext {
return self.contexts.MergeConflicts return self.c.Contexts().MergeConflicts
} }
func (self *MergeConflictsController) Escape() error { 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 { func (self *PatchBuildingController) Context() types.Context {
return self.contexts.CustomPatchBuilder return self.c.Contexts().CustomPatchBuilder
} }
func (self *PatchBuildingController) context() types.IPatchExplorerContext { func (self *PatchBuildingController) context() types.IPatchExplorerContext {
return self.contexts.CustomPatchBuilder return self.c.Contexts().CustomPatchBuilder
} }
func (self *PatchBuildingController) GetMouseKeybindings(opts types.KeybindingsOpts) []*gocui.ViewMouseBinding { 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 { return func(opts types.OnFocusLostOpts) error {
self.c.Views().PatchBuilding.Wrap = true self.c.Views().PatchBuilding.Wrap = true
if self.git.Patch.PatchBuilder.IsEmpty() { if self.c.Git().Patch.PatchBuilder.IsEmpty() {
self.git.Patch.PatchBuilder.Reset() self.c.Git().Patch.PatchBuilder.Reset()
} }
return nil return nil
@ -84,7 +84,7 @@ func (self *PatchBuildingController) OpenFile() error {
self.context().GetMutex().Lock() self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock() defer self.context().GetMutex().Unlock()
path := self.contexts.CommitFiles.GetSelectedPath() path := self.c.Contexts().CommitFiles.GetSelectedPath()
if path == "" { if path == "" {
return nil return nil
@ -97,7 +97,7 @@ func (self *PatchBuildingController) EditFile() error {
self.context().GetMutex().Lock() self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock() defer self.context().GetMutex().Unlock()
path := self.contexts.CommitFiles.GetSelectedPath() path := self.c.Contexts().CommitFiles.GetSelectedPath()
if path == "" { if path == "" {
return nil return nil
@ -121,21 +121,21 @@ func (self *PatchBuildingController) toggleSelection() error {
self.context().GetMutex().Lock() self.context().GetMutex().Lock()
defer self.context().GetMutex().Unlock() defer self.context().GetMutex().Unlock()
toggleFunc := self.git.Patch.PatchBuilder.AddFileLineRange toggleFunc := self.c.Git().Patch.PatchBuilder.AddFileLineRange
filename := self.contexts.CommitFiles.GetSelectedPath() filename := self.c.Contexts().CommitFiles.GetSelectedPath()
if filename == "" { if filename == "" {
return nil return nil
} }
state := self.context().GetState() state := self.context().GetState()
includedLineIndices, err := self.git.Patch.PatchBuilder.GetFileIncLineIndices(filename) includedLineIndices, err := self.c.Git().Patch.PatchBuilder.GetFileIncLineIndices(filename)
if err != nil { if err != nil {
return err return err
} }
currentLineIsStaged := lo.Contains(includedLineIndices, state.GetSelectedLineIdx()) currentLineIsStaged := lo.Contains(includedLineIndices, state.GetSelectedLineIdx())
if currentLineIsStaged { 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 // 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() selected := self.context.GetState().PlainRenderSelected()
self.c.LogAction(self.c.Tr.Actions.CopySelectedTextToClipboard) 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) return self.c.Error(err)
} }

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

@ -8,30 +8,31 @@ import (
type ReflogCommitsController struct { type ReflogCommitsController struct {
baseController baseController
*controllerCommon *controllerCommon
context *context.ReflogCommitsContext
} }
var _ types.IController = &ReflogCommitsController{} var _ types.IController = &ReflogCommitsController{}
func NewReflogCommitsController( func NewReflogCommitsController(
common *controllerCommon, common *controllerCommon,
context *context.ReflogCommitsContext,
) *ReflogCommitsController { ) *ReflogCommitsController {
return &ReflogCommitsController{ return &ReflogCommitsController{
baseController: baseController{}, baseController: baseController{},
controllerCommon: common, controllerCommon: common,
context: context,
} }
} }
func (self *ReflogCommitsController) Context() types.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 { func (self *ReflogCommitsController) GetOnRenderToMain() func() error {
return func() error { return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error { return self.helpers.Diff.WithDiffModeCheck(func() error {
commit := self.context.GetSelected() commit := self.context().GetSelected()
var task types.UpdateTask var task types.UpdateTask
if commit == nil { if commit == nil {
task = types.NewRenderStringTask("No reflog history") 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 { if remoteBranch == nil {
task = types.NewRenderStringTask("No branches for this remote") task = types.NewRenderStringTask("No branches for this remote")
} else { } else {
cmdObj := self.git.Branch.GetGraphCmdObj(remoteBranch.FullRefName()) cmdObj := self.c.Git().Branch.GetGraphCmdObj(remoteBranch.FullRefName())
task = types.NewRunCommandTask(cmdObj.GetCmd()) task = types.NewRunCommandTask(cmdObj.GetCmd())
} }
@ -101,7 +101,7 @@ func (self *RemoteBranchesController) Context() types.Context {
} }
func (self *RemoteBranchesController) context() *context.RemoteBranchesContext { 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 { 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 { 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 { func (self *RemoteBranchesController) delete(selectedBranch *models.RemoteBranch) error {
@ -128,7 +128,7 @@ func (self *RemoteBranchesController) delete(selectedBranch *models.RemoteBranch
HandleConfirm: func() error { HandleConfirm: func() error {
return self.c.WithWaitingStatus(self.c.Tr.DeletingStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.DeletingStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteRemoteBranch) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -167,7 +167,7 @@ func (self *RemoteBranchesController) setAsUpstream(selectedBranch *models.Remot
Prompt: message, Prompt: message,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.SetBranchUpstream) 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) return self.c.Error(err)
} }

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

@ -14,7 +14,6 @@ import (
type RemotesController struct { type RemotesController struct {
baseController baseController
*controllerCommon *controllerCommon
context *context.RemotesContext
setRemoteBranches func([]*models.RemoteBranch) setRemoteBranches func([]*models.RemoteBranch)
} }
@ -28,7 +27,6 @@ func NewRemotesController(
return &RemotesController{ return &RemotesController{
baseController: baseController{}, baseController: baseController{},
controllerCommon: common, controllerCommon: common,
context: common.contexts.Remotes,
setRemoteBranches: setRemoteBranches, setRemoteBranches: setRemoteBranches,
} }
} }
@ -64,11 +62,19 @@ func (self *RemotesController) GetKeybindings(opts types.KeybindingsOpts) []*typ
return bindings 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 { func (self *RemotesController) GetOnRenderToMain() func() error {
return func() error { return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error { return self.helpers.Diff.WithDiffModeCheck(func() error {
var task types.UpdateTask var task types.UpdateTask
remote := self.context.GetSelected() remote := self.context().GetSelected()
if remote == nil { if remote == nil {
task = types.NewRenderStringTask("No remotes") task = types.NewRenderStringTask("No remotes")
} else { } else {
@ -98,14 +104,14 @@ func (self *RemotesController) enter(remote *models.Remote) error {
if len(remote.Branches) == 0 { if len(remote.Branches) == 0 {
newSelectedLine = -1 newSelectedLine = -1
} }
self.contexts.RemoteBranches.SetSelectedLineIdx(newSelectedLine) self.c.Contexts().RemoteBranches.SetSelectedLineIdx(newSelectedLine)
self.contexts.RemoteBranches.SetTitleRef(remote.Name) 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 err
} }
return self.c.PushContext(self.contexts.RemoteBranches) return self.c.PushContext(self.c.Contexts().RemoteBranches)
} }
func (self *RemotesController) add() error { func (self *RemotesController) add() error {
@ -116,7 +122,7 @@ func (self *RemotesController) add() error {
Title: self.c.Tr.LcNewRemoteUrl, Title: self.c.Tr.LcNewRemoteUrl,
HandleConfirm: func(remoteUrl string) error { HandleConfirm: func(remoteUrl string) error {
self.c.LogAction(self.c.Tr.Actions.AddRemote) 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 err
} }
return self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.REMOTES}}) 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 + "'?", Prompt: self.c.Tr.LcRemoveRemotePrompt + " '" + remote.Name + "'?",
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveRemote) 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) return self.c.Error(err)
} }
@ -155,7 +161,7 @@ func (self *RemotesController) edit(remote *models.Remote) error {
HandleConfirm: func(updatedRemoteName string) error { HandleConfirm: func(updatedRemoteName string) error {
if updatedRemoteName != remote.Name { if updatedRemoteName != remote.Name {
self.c.LogAction(self.c.Tr.Actions.UpdateRemote) 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) return self.c.Error(err)
} }
} }
@ -178,7 +184,7 @@ func (self *RemotesController) edit(remote *models.Remote) error {
InitialContent: url, InitialContent: url,
HandleConfirm: func(updatedRemoteUrl string) error { HandleConfirm: func(updatedRemoteUrl string) error {
self.c.LogAction(self.c.Tr.Actions.UpdateRemote) 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.Error(err)
} }
return self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.BRANCHES, types.REMOTES}}) 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 { func (self *RemotesController) fetch(remote *models.Remote) error {
return self.c.WithWaitingStatus(self.c.Tr.FetchingRemoteStatus, func() 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 { if err != nil {
_ = self.c.Error(err) _ = 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 { func (self *RemotesController) checkSelected(callback func(*models.Remote) error) func() error {
return func() error { return func() error {
file := self.context.GetSelected() file := self.context().GetSelected()
if file == nil { if file == nil {
return nil return nil
} }
@ -209,7 +215,3 @@ func (self *RemotesController) checkSelected(callback func(*models.Remote) error
return callback(file) 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 { func (self *SnakeController) Context() types.Context {
return self.contexts.Snake return self.c.Contexts().Snake
} }
func (self *SnakeController) GetOnFocus() func(types.OnFocusOpts) error { 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 { func (self *SnakeController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
return func(types.OnFocusLostOpts) error { return func(types.OnFocusLostOpts) error {
self.helpers.Snake.ExitGame() self.helpers.Snake.ExitGame()
self.helpers.Window.MoveToTopOfWindow(self.contexts.Submodules) self.helpers.Window.MoveToTopOfWindow(self.c.Contexts().Submodules)
return nil return nil
} }
} }
@ -75,5 +75,5 @@ func (self *SnakeController) SetDirection(direction snake.Direction) func() erro
} }
func (self *SnakeController) Escape() error { 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() { if opts.NewContextKey != self.otherContext.GetKey() {
self.c.Views().Staging.Wrap = true self.c.Views().Staging.Wrap = true
self.c.Views().StagingSecondary.Wrap = true self.c.Views().StagingSecondary.Wrap = true
_ = self.contexts.Staging.Render(false) _ = self.c.Contexts().Staging.Render(false)
_ = self.contexts.StagingSecondary.Render(false) _ = self.c.Contexts().StagingSecondary.Render(false)
} }
return nil return nil
} }
@ -221,7 +221,7 @@ func (self *StagingController) applySelection(reverse bool) error {
applyFlags = append(applyFlags, "cached") applyFlags = append(applyFlags, "cached")
} }
self.c.LogAction(self.c.Tr.Actions.ApplyPatch) 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 { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -262,7 +262,7 @@ func (self *StagingController) editHunk() error {
}). }).
FormatPlain() FormatPlain()
patchFilepath, err := self.git.WorkingTree.SaveTemporaryPatch(patchText) patchFilepath, err := self.c.Git().WorkingTree.SaveTemporaryPatch(patchText)
if err != nil { if err != nil {
return err return err
} }
@ -273,7 +273,7 @@ func (self *StagingController) editHunk() error {
return err return err
} }
editedPatchText, err := self.git.File.Cat(patchFilepath) editedPatchText, err := self.c.Git().File.Cat(patchFilepath)
if err != nil { if err != nil {
return err return err
} }
@ -293,7 +293,7 @@ func (self *StagingController) editHunk() error {
if self.staged { if self.staged {
applyFlags = append(applyFlags, "reverse") 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) return self.c.Error(err)
} }
@ -301,5 +301,5 @@ func (self *StagingController) editHunk() error {
} }
func (self *StagingController) FilePath() string { 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 { if stashEntry == nil {
task = types.NewRenderStringTask(self.c.Tr.NoStashEntries) task = types.NewRenderStringTask(self.c.Tr.NoStashEntries)
} else { } 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{ return self.c.RenderToMainViews(types.RefreshMainOpts{
@ -93,13 +93,13 @@ func (self *StashController) Context() types.Context {
} }
func (self *StashController) context() *context.StashContext { func (self *StashController) context() *context.StashContext {
return self.contexts.Stash return self.c.Contexts().Stash
} }
func (self *StashController) handleStashApply(stashEntry *models.StashEntry) error { func (self *StashController) handleStashApply(stashEntry *models.StashEntry) error {
apply := func() error { apply := func() error {
self.c.LogAction(self.c.Tr.Actions.Stash) 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() _ = self.postStashRefresh()
if err != nil { if err != nil {
return self.c.Error(err) 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 { func (self *StashController) handleStashPop(stashEntry *models.StashEntry) error {
pop := func() error { pop := func() error {
self.c.LogAction(self.c.Tr.Actions.Stash) 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() _ = self.postStashRefresh()
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
@ -150,7 +150,7 @@ func (self *StashController) handleStashDrop(stashEntry *models.StashEntry) erro
Prompt: self.c.Tr.SureDropStashEntry, Prompt: self.c.Tr.SureDropStashEntry,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.Stash) 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}}) _ = self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STASH}})
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
@ -181,7 +181,7 @@ func (self *StashController) handleRenameStashEntry(stashEntry *models.StashEntr
InitialContent: stashEntry.Name, InitialContent: stashEntry.Name,
HandleConfirm: func(response string) error { HandleConfirm: func(response string) error {
self.c.LogAction(self.c.Tr.Actions.RenameStash) 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}}) _ = self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STASH}})
if err != nil { if err != nil {
return err 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 { func (self *StatusController) Context() types.Context {
return self.contexts.Status return self.c.Contexts().Status
} }
func (self *StatusController) onClick() error { func (self *StatusController) onClick() error {
@ -109,7 +109,7 @@ func (self *StatusController) onClick() error {
cx, _ := self.c.Views().Status.Cursor() cx, _ := self.c.Views().Status.Cursor()
upstreamStatus := presentation.BranchStatus(currentBranch, self.c.Tr) upstreamStatus := presentation.BranchStatus(currentBranch, self.c.Tr)
repoName := utils.GetCurrentRepoName() repoName := utils.GetCurrentRepoName()
workingTreeState := self.git.Status.WorkingTreeState() workingTreeState := self.c.Git().Status.WorkingTreeState()
switch workingTreeState { switch workingTreeState {
case enums.REBASE_MODE_REBASING, enums.REBASE_MODE_MERGING: case enums.REBASE_MODE_REBASING, enums.REBASE_MODE_MERGING:
workingTreeStatus := fmt.Sprintf("(%s)", presentation.FormatWorkingTreeState(workingTreeState)) workingTreeStatus := fmt.Sprintf("(%s)", presentation.FormatWorkingTreeState(workingTreeState))
@ -181,7 +181,7 @@ func (self *StatusController) editConfig() error {
} }
func (self *StatusController) showAllBranchLogs() error { func (self *StatusController) showAllBranchLogs() error {
cmdObj := self.git.Branch.AllBranchesLogCmdObj() cmdObj := self.c.Git().Branch.AllBranchesLogCmdObj()
task := types.NewRunPtyTask(cmdObj.GetCmd()) task := types.NewRunPtyTask(cmdObj.GetCmd())
return self.c.RenderToMainViews(types.RefreshMainOpts{ return self.c.RenderToMainViews(types.RefreshMainOpts{

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

@ -9,35 +9,36 @@ import (
type SubCommitsController struct { type SubCommitsController struct {
baseController baseController
*controllerCommon *controllerCommon
context *context.SubCommitsContext
} }
var _ types.IController = &SubCommitsController{} var _ types.IController = &SubCommitsController{}
func NewSubCommitsController( func NewSubCommitsController(
common *controllerCommon, common *controllerCommon,
context *context.SubCommitsContext,
) *SubCommitsController { ) *SubCommitsController {
return &SubCommitsController{ return &SubCommitsController{
baseController: baseController{}, baseController: baseController{},
controllerCommon: common, controllerCommon: common,
context: context,
} }
} }
func (self *SubCommitsController) Context() types.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 { func (self *SubCommitsController) GetOnRenderToMain() func() error {
return func() error { return func() error {
return self.helpers.Diff.WithDiffModeCheck(func() error { return self.helpers.Diff.WithDiffModeCheck(func() error {
commit := self.context.GetSelected() commit := self.context().GetSelected()
var task types.UpdateTask var task types.UpdateTask
if commit == nil { if commit == nil {
task = types.NewRenderStringTask("No commits") task = types.NewRenderStringTask("No commits")
} else { } 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()) task = types.NewRunPtyTask(cmdObj.GetCmd())
} }
@ -55,7 +56,7 @@ func (self *SubCommitsController) GetOnRenderToMain() func() error {
func (self *SubCommitsController) GetOnFocus() func(types.OnFocusOpts) error { func (self *SubCommitsController) GetOnFocus() func(types.OnFocusOpts) error {
return func(types.OnFocusOpts) error { return func(types.OnFocusOpts) error {
context := self.context context := self.context()
if context.GetSelectedLineIdx() > COMMIT_THRESHOLD && context.GetLimitCommits() { if context.GetSelectedLineIdx() > COMMIT_THRESHOLD && context.GetLimitCommits() {
context.SetLimitCommits(false) context.SetLimitCommits(false)
go utils.Safe(func() { 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 { if file == nil {
task = types.NewRenderStringTask(prefix) task = types.NewRenderStringTask(prefix)
} else { } 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) task = types.NewRunCommandTaskWithPrefix(cmdObj.GetCmd(), prefix)
} }
} }
@ -132,7 +132,7 @@ func (self *SubmodulesController) add() error {
HandleConfirm: func(submodulePath string) error { HandleConfirm: func(submodulePath string) error {
return self.c.WithWaitingStatus(self.c.Tr.LcAddingSubmoduleStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcAddingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.AddSubmodule) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -154,7 +154,7 @@ func (self *SubmodulesController) editURL(submodule *models.SubmoduleConfig) err
HandleConfirm: func(newUrl string) error { HandleConfirm: func(newUrl string) error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleUrlStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleUrlStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.UpdateSubmoduleUrl) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -168,7 +168,7 @@ func (self *SubmodulesController) editURL(submodule *models.SubmoduleConfig) err
func (self *SubmodulesController) init(submodule *models.SubmoduleConfig) error { func (self *SubmodulesController) init(submodule *models.SubmoduleConfig) error {
return self.c.WithWaitingStatus(self.c.Tr.LcInitializingSubmoduleStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcInitializingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.InitialiseSubmodule) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -182,11 +182,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Title: self.c.Tr.LcBulkSubmoduleOptions, Title: self.c.Tr.LcBulkSubmoduleOptions,
Items: []*types.MenuItem{ 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 { OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkInitialiseSubmodules) self.c.LogAction(self.c.Tr.Actions.BulkInitialiseSubmodules)
err := self.git.Submodule.BulkInitCmdObj().Run() err := self.c.Git().Submodule.BulkInitCmdObj().Run()
if err != nil { if err != nil {
return self.c.Error(err) return self.c.Error(err)
} }
@ -197,11 +197,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Key: 'i', 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 { OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkUpdateSubmodules) 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) return self.c.Error(err)
} }
@ -211,11 +211,11 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
Key: 'u', 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 { OnPress: func() error {
return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcRunningCommand, func() error {
self.c.LogAction(self.c.Tr.Actions.BulkDeinitialiseSubmodules) 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) return self.c.Error(err)
} }
@ -231,7 +231,7 @@ func (self *SubmodulesController) openBulkActionsMenu() error {
func (self *SubmodulesController) update(submodule *models.SubmoduleConfig) error { func (self *SubmodulesController) update(submodule *models.SubmoduleConfig) error {
return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.LcUpdatingSubmoduleStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.UpdateSubmodule) 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 { if err != nil {
_ = self.c.Error(err) _ = 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), Prompt: fmt.Sprintf(self.c.Tr.RemoveSubmodulePrompt, submodule.Name),
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveSubmodule) 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) return self.c.Error(err)
} }
@ -256,7 +256,7 @@ func (self *SubmodulesController) remove(submodule *models.SubmoduleConfig) erro
} }
func (self *SubmodulesController) easterEgg() error { 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 { 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 { 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), 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 { 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 // need to populate my sub commits
commits, err := self.git.Loaders.CommitLoader.GetCommits( commits, err := self.c.Git().Loaders.CommitLoader.GetCommits(
git_commands.GetCommitsOptions{ git_commands.GetCommitsOptions{
Limit: true, Limit: true,
FilterPath: self.modes.Filtering.GetPath(), FilterPath: self.c.Modes().Filtering.GetPath(),
IncludeRebaseCommits: false, IncludeRebaseCommits: false,
RefName: ref.FullRefName(), RefName: ref.FullRefName(),
}, },
@ -71,19 +71,19 @@ func (self *SwitchToSubCommitsController) viewCommits() error {
self.setSubCommits(commits) self.setSubCommits(commits)
self.contexts.SubCommits.SetSelectedLineIdx(0) self.c.Contexts().SubCommits.SetSelectedLineIdx(0)
self.contexts.SubCommits.SetParentContext(self.context) self.c.Contexts().SubCommits.SetParentContext(self.context)
self.contexts.SubCommits.SetWindowName(self.context.GetWindowName()) self.c.Contexts().SubCommits.SetWindowName(self.context.GetWindowName())
self.contexts.SubCommits.SetTitleRef(ref.Description()) self.c.Contexts().SubCommits.SetTitleRef(ref.Description())
self.contexts.SubCommits.SetRef(ref) self.c.Contexts().SubCommits.SetRef(ref)
self.contexts.SubCommits.SetLimitCommits(true) self.c.Contexts().SubCommits.SetLimitCommits(true)
err = self.c.PostRefreshUpdate(self.contexts.SubCommits) err = self.c.PostRefreshUpdate(self.c.Contexts().SubCommits)
if err != nil { if err != nil {
return err return err
} }
return self.c.PushContext(self.contexts.SubCommits) return self.c.PushContext(self.c.Contexts().SubCommits)
} }
func (self *SwitchToSubCommitsController) Context() types.Context { 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) return self.pushAux(opts)
} }
} else { } else {
if self.git.Config.GetPushToCurrent() { if self.c.Git().Config.GetPushToCurrent() {
return self.pushAux(pushOpts{setUpstream: true}) return self.pushAux(pushOpts{setUpstream: true})
} else { } else {
return self.helpers.Upstream.PromptForUpstreamWithInitialContent(currentBranch, func(upstream string) error { return self.helpers.Upstream.PromptForUpstreamWithInitialContent(currentBranch, func(upstream string) error {
@ -118,7 +118,7 @@ func (self *SyncController) setCurrentBranchUpstream(upstream string) error {
return err 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") { if strings.Contains(err.Error(), "does not exist") {
return fmt.Errorf( 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')", "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 { func (self *SyncController) pullWithLock(opts PullFilesOptions) error {
self.c.LogAction(opts.Action) self.c.LogAction(opts.Action)
err := self.git.Sync.Pull( err := self.c.Git().Sync.Pull(
git_commands.PullOptions{ git_commands.PullOptions{
RemoteName: opts.UpstreamRemote, RemoteName: opts.UpstreamRemote,
BranchName: opts.UpstreamBranch, BranchName: opts.UpstreamBranch,
@ -167,7 +167,7 @@ type pushOpts struct {
func (self *SyncController) pushAux(opts pushOpts) error { func (self *SyncController) pushAux(opts pushOpts) error {
return self.c.WithLoaderPanel(self.c.Tr.PushWait, func() error { return self.c.WithLoaderPanel(self.c.Tr.PushWait, func() error {
self.c.LogAction(self.c.Tr.Actions.Push) 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, Force: opts.force,
UpstreamRemote: opts.upstreamRemote, UpstreamRemote: opts.upstreamRemote,
UpstreamBranch: opts.upstreamBranch, 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 { if tag == nil {
task = types.NewRenderStringTask("No tags") task = types.NewRenderStringTask("No tags")
} else { } else {
cmdObj := self.git.Branch.GetGraphCmdObj(tag.FullRefName()) cmdObj := self.c.Git().Branch.GetGraphCmdObj(tag.FullRefName())
task = types.NewRunCommandTask(cmdObj.GetCmd()) 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 { if err := self.helpers.Refs.CheckoutRef(tag.Name, types.CheckoutRefOptions{}); err != nil {
return err 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 { func (self *TagsController) delete(tag *models.Tag) error {
@ -100,7 +100,7 @@ func (self *TagsController) delete(tag *models.Tag) error {
Prompt: prompt, Prompt: prompt,
HandleConfirm: func() error { HandleConfirm: func() error {
self.c.LogAction(self.c.Tr.Actions.DeleteTag) 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.Error(err)
} }
return self.c.Refresh(types.RefreshOptions{Mode: types.ASYNC, Scope: []types.RefreshableView{types.COMMITS, types.TAGS}}) 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 { HandleConfirm: func(response string) error {
return self.c.WithWaitingStatus(self.c.Tr.PushingTagStatus, func() error { return self.c.WithWaitingStatus(self.c.Tr.PushingTagStatus, func() error {
self.c.LogAction(self.c.Tr.Actions.PushTag) 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 { if err != nil {
_ = self.c.Error(err) _ = self.c.Error(err)
} }
@ -159,5 +159,5 @@ func (self *TagsController) Context() types.Context {
} }
func (self *TagsController) context() *context.TagsContext { 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]"} undoEnvVars := []string{"GIT_REFLOG_ACTION=[lazygit undo]"}
undoingStatus := self.c.Tr.UndoingStatus 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) return self.c.ErrorMsg(self.c.Tr.LcCantUndoWhileRebasing)
} }
@ -124,7 +124,7 @@ func (self *UndoController) reflogRedo() error {
redoEnvVars := []string{"GIT_REFLOG_ACTION=[lazygit redo]"} redoEnvVars := []string{"GIT_REFLOG_ACTION=[lazygit redo]"}
redoingStatus := self.c.Tr.RedoingStatus 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) 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. // 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 { func (self *UndoController) parseReflogForActions(onUserAction func(counter int, action reflogAction) (bool, error)) error {
counter := 0 counter := 0
reflogCommits := self.model.FilteredReflogCommits reflogCommits := self.c.Model().FilteredReflogCommits
rebaseFinishCommitSha := "" rebaseFinishCommitSha := ""
var action *reflogAction var action *reflogAction
for reflogCommitIdx, reflogCommit := range reflogCommits { for reflogCommitIdx, reflogCommit := range reflogCommits {
@ -248,14 +248,14 @@ func (self *UndoController) hardResetWithAutoStash(commitSha string, options har
Prompt: self.c.Tr.AutoStashPrompt, Prompt: self.c.Tr.AutoStashPrompt,
HandleConfirm: func() error { HandleConfirm: func() error {
return self.c.WithWaitingStatus(options.WaitingStatus, 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) return self.c.Error(err)
} }
if err := reset(); err != nil { if err := reset(); err != nil {
return err return err
} }
err := self.git.Stash.Pop(0) err := self.c.Git().Stash.Pop(0)
if err := self.c.Refresh(types.RefreshOptions{}); err != nil { if err := self.c.Refresh(types.RefreshOptions{}); err != nil {
return err return err
} }

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

@ -13,7 +13,7 @@ func (self *FilesController) createResetMenu() error {
red := style.FgRed red := style.FgRed
nukeStr := "git reset --hard HEAD && git clean -fd" 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) nukeStr = fmt.Sprintf("%s (%s)", nukeStr, self.c.Tr.LcAndResetSubmodules)
} }
@ -25,7 +25,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.NukeWorkingTree) 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) return self.c.Error(err)
} }
@ -41,7 +41,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.DiscardUnstagedFileChanges) 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) return self.c.Error(err)
} }
@ -56,7 +56,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.RemoveUntrackedFiles) 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) return self.c.Error(err)
} }
@ -75,10 +75,10 @@ func (self *FilesController) createResetMenu() error {
if !self.helpers.WorkingTree.IsWorkingTreeDirty() { if !self.helpers.WorkingTree.IsWorkingTreeDirty() {
return self.c.ErrorMsg(self.c.Tr.NoTrackedStagedFilesStash) 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) 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) return self.c.Error(err)
} }
@ -93,7 +93,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.SoftReset) 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) return self.c.Error(err)
} }
@ -108,7 +108,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.MixedReset) 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) return self.c.Error(err)
} }
@ -123,7 +123,7 @@ func (self *FilesController) createResetMenu() error {
}, },
OnPress: func() error { OnPress: func() error {
self.c.LogAction(self.c.Tr.Actions.HardReset) 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) return self.c.Error(err)
} }