Add a DisabledReason mechanism for menu items and keybindings (#2992)

pkg/gui/context/menu_context.go

@@ -90,6 +90,9 @@ func (self *MenuViewModel) GetDisplayStrings(_ int, _ int) [][]string {
 
 	return lo.Map(menuItems, func(item *types.MenuItem, _ int) []string {
 		displayStrings := item.LabelColumns
+		if item.DisabledReason != "" {
+			displayStrings[0] = style.FgDefault.SetStrikethrough().Sprint(displayStrings[0])
+		}
 
 		if !showKeys {
 			return displayStrings
@@ -169,6 +172,10 @@ func (self *MenuContext) GetKeybindings(opts types.KeybindingsOpts) []*types.Bin
 }
 
 func (self *MenuContext) OnMenuPress(selectedItem *types.MenuItem) error {
+	if selectedItem != nil && selectedItem.DisabledReason != "" {
+		return self.c.ErrorMsg(selectedItem.DisabledReason)
+	}
+
 	if err := self.c.PopContext(); err != nil {
 		return err
 	}

pkg/gui/controllers/branches_controller.go

@@ -12,6 +12,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/gui/controllers/helpers"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/samber/lo"
 )
 
 type BranchesController struct {
@@ -75,9 +76,10 @@ func (self *BranchesController) GetKeybindings(opts types.KeybindingsOpts) []*ty
 			OpensMenu:   true,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Branches.RebaseBranch),
+			Key:               opts.GetKey(opts.Config.Branches.RebaseBranch),
-			Handler:     opts.Guards.OutsideFilterMode(self.rebase),
+			Handler:           opts.Guards.OutsideFilterMode(self.rebase),
-			Description: self.c.Tr.RebaseBranch,
+			Description:       self.c.Tr.RebaseBranch,
+			GetDisabledReason: self.getDisabledReasonForRebase,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Branches.MergeIntoCurrentBranch),
@@ -140,32 +142,55 @@ func (self *BranchesController) GetOnRenderToMain() func() error {
 }
 
 func (self *BranchesController) setUpstream(selectedBranch *models.Branch) error {
-	options := []*types.MenuItem{
+	viewDivergenceItem := &types.MenuItem{
-		{
+		LabelColumns: []string{self.c.Tr.ViewDivergenceFromUpstream},
-			LabelColumns: []string{self.c.Tr.ViewDivergenceFromUpstream},
+		OnPress: func() error {
-			OnPress: func() error {
+			branch := self.context().GetSelected()
-				branch := self.context().GetSelected()
+			if branch == nil {
-				if branch == nil {
+				return nil
-					return nil
+			}
+
+			return self.c.Helpers().SubCommits.ViewSubCommits(helpers.ViewSubCommitsOpts{
+				Ref:                     branch,
+				TitleRef:                fmt.Sprintf("%s <-> %s", branch.RefName(), branch.ShortUpstreamRefName()),
+				RefToShowDivergenceFrom: branch.FullUpstreamRefName(),
+				Context:                 self.context(),
+				ShowBranchHeads:         false,
+			})
+		},
+		Key: 'v',
+	}
+
+	unsetUpstreamItem := &types.MenuItem{
+		LabelColumns: []string{self.c.Tr.UnsetUpstream},
+		OnPress: func() error {
+			if err := self.c.Git().Branch.UnsetUpstream(selectedBranch.Name); err != nil {
+				return self.c.Error(err)
+			}
+			if err := self.c.Refresh(types.RefreshOptions{
+				Mode: types.SYNC,
+				Scope: []types.RefreshableView{
+					types.BRANCHES,
+					types.COMMITS,
+				},
+			}); err != nil {
+				return self.c.Error(err)
+			}
+			return nil
+		},
+		Key: 'u',
+	}
+
+	setUpstreamItem := &types.MenuItem{
+		LabelColumns: []string{self.c.Tr.SetUpstream},
+		OnPress: func() error {
+			return self.c.Helpers().Upstream.PromptForUpstreamWithoutInitialContent(selectedBranch, func(upstream string) error {
+				upstreamRemote, upstreamBranch, err := self.c.Helpers().Upstream.ParseUpstream(upstream)
+				if err != nil {
+					return self.c.Error(err)
 				}
 
-				if !branch.RemoteBranchStoredLocally() {
+				if err := self.c.Git().Branch.SetUpstream(upstreamRemote, upstreamBranch, selectedBranch.Name); err != nil {
-					return self.c.ErrorMsg(self.c.Tr.DivergenceNoUpstream)
-				}
-				return self.c.Helpers().SubCommits.ViewSubCommits(helpers.ViewSubCommitsOpts{
-					Ref:                     branch,
-					TitleRef:                fmt.Sprintf("%s <-> %s", branch.RefName(), branch.ShortUpstreamRefName()),
-					RefToShowDivergenceFrom: branch.FullUpstreamRefName(),
-					Context:                 self.context(),
-					ShowBranchHeads:         false,
-				})
-			},
-			Key: 'v',
-		},
-		{
-			LabelColumns: []string{self.c.Tr.UnsetUpstream},
-			OnPress: func() error {
-				if err := self.c.Git().Branch.UnsetUpstream(selectedBranch.Name); err != nil {
 					return self.c.Error(err)
 				}
 				if err := self.c.Refresh(types.RefreshOptions{
@@ -178,75 +203,48 @@ func (self *BranchesController) setUpstream(selectedBranch *models.Branch) error
 					return self.c.Error(err)
 				}
 				return nil
-			},
+			})
-			Key: 'u',
-		},
-		{
-			LabelColumns: []string{self.c.Tr.SetUpstream},
-			OnPress: func() error {
-				return self.c.Helpers().Upstream.PromptForUpstreamWithoutInitialContent(selectedBranch, func(upstream string) error {
-					upstreamRemote, upstreamBranch, err := self.c.Helpers().Upstream.ParseUpstream(upstream)
-					if err != nil {
-						return self.c.Error(err)
-					}
-
-					if err := self.c.Git().Branch.SetUpstream(upstreamRemote, upstreamBranch, selectedBranch.Name); err != nil {
-						return self.c.Error(err)
-					}
-					if err := self.c.Refresh(types.RefreshOptions{
-						Mode: types.SYNC,
-						Scope: []types.RefreshableView{
-							types.BRANCHES,
-							types.COMMITS,
-						},
-					}); err != nil {
-						return self.c.Error(err)
-					}
-					return nil
-				})
-			},
-			Key: 's',
 		},
+		Key: 's',
 	}
 
-	if selectedBranch.IsTrackingRemote() {
+	upstream := lo.Ternary(selectedBranch.RemoteBranchStoredLocally(),
-		upstream := fmt.Sprintf("%s/%s", selectedBranch.UpstreamRemote, selectedBranch.Name)
+		fmt.Sprintf("%s/%s", selectedBranch.UpstreamRemote, selectedBranch.Name),
-		upstreamResetOptions := utils.ResolvePlaceholderString(
+		self.c.Tr.UpstreamGenericName)
-			self.c.Tr.ViewUpstreamResetOptions,
+	upstreamResetOptions := utils.ResolvePlaceholderString(
-			map[string]string{"upstream": upstream},
+		self.c.Tr.ViewUpstreamResetOptions,
-		)
+		map[string]string{"upstream": upstream},
-		upstreamResetTooltip := utils.ResolvePlaceholderString(
+	)
-			self.c.Tr.ViewUpstreamResetOptionsTooltip,
+	upstreamResetTooltip := utils.ResolvePlaceholderString(
-			map[string]string{"upstream": upstream},
+		self.c.Tr.ViewUpstreamResetOptionsTooltip,
-		)
+		map[string]string{"upstream": upstream},
+	)
 
-		options = append(options, &types.MenuItem{
+	upstreamResetItem := &types.MenuItem{
-			LabelColumns: []string{upstreamResetOptions},
+		LabelColumns: []string{upstreamResetOptions},
-			OpensMenu:    true,
+		OpensMenu:    true,
-			OnPress: func() error {
+		OnPress: func() error {
-				if selectedBranch.RemoteBranchNotStoredLocally() {
+			err := self.c.Helpers().Refs.CreateGitResetMenu(upstream)
-					return self.c.ErrorMsg(self.c.Tr.UpstreamNotStoredLocallyError)
+			if err != nil {
-				}
+				return self.c.Error(err)
+			}
+			return nil
+		},
+		Tooltip: upstreamResetTooltip,
+		Key:     'g',
+	}
 
-				err := self.c.Helpers().Refs.CreateGitResetMenu(upstream)
+	if !selectedBranch.RemoteBranchStoredLocally() {
-				if err != nil {
+		viewDivergenceItem.DisabledReason = self.c.Tr.UpstreamNotSetError
-					return self.c.Error(err)
+		unsetUpstreamItem.DisabledReason = self.c.Tr.UpstreamNotSetError
-				}
+		upstreamResetItem.DisabledReason = self.c.Tr.UpstreamNotSetError
-				return nil
+	}
-			},
+
-			Tooltip: upstreamResetTooltip,
+	options := []*types.MenuItem{
-			Key:     'g',
+		viewDivergenceItem,
-		})
+		unsetUpstreamItem,
-	} else {
+		setUpstreamItem,
-		options = append(options, &types.MenuItem{
+		upstreamResetItem,
-			LabelColumns: []string{self.c.Tr.ViewUpstreamDisabledResetOptions},
-			OpensMenu:    true,
-			OnPress: func() error {
-				return self.c.ErrorMsg(self.c.Tr.UpstreamNotSetError)
-			},
-			Tooltip: self.c.Tr.UpstreamNotSetError,
-			Key:     'g',
-		})
 	}
 
 	return self.c.Menu(types.CreateMenuOptions{
@@ -468,7 +466,6 @@ func (self *BranchesController) forceDelete(branch *models.Branch) error {
 }
 
 func (self *BranchesController) delete(branch *models.Branch) error {
-	menuItems := []*types.MenuItem{}
 	checkedOutBranch := self.c.Helpers().Refs.GetCheckedOutRef()
 
 	localDeleteItem := &types.MenuItem{
@@ -479,25 +476,18 @@ func (self *BranchesController) delete(branch *models.Branch) error {
 		},
 	}
 	if checkedOutBranch.Name == branch.Name {
-		localDeleteItem = &types.MenuItem{
+		localDeleteItem.DisabledReason = self.c.Tr.CantDeleteCheckOutBranch
-			Label:   self.c.Tr.DeleteLocalBranch,
-			Key:     'c',
-			Tooltip: self.c.Tr.CantDeleteCheckOutBranch,
-			OnPress: func() error {
-				return self.c.ErrorMsg(self.c.Tr.CantDeleteCheckOutBranch)
-			},
-		}
 	}
-	menuItems = append(menuItems, localDeleteItem)
 
-	if branch.IsTrackingRemote() && !branch.UpstreamGone {
+	remoteDeleteItem := &types.MenuItem{
-		menuItems = append(menuItems, &types.MenuItem{
+		Label: self.c.Tr.DeleteRemoteBranch,
-			Label: self.c.Tr.DeleteRemoteBranch,
+		Key:   'r',
-			Key:   'r',
+		OnPress: func() error {
-			OnPress: func() error {
+			return self.remoteDelete(branch)
-				return self.remoteDelete(branch)
+		},
-			},
+	}
-		})
+	if !branch.IsTrackingRemote() || branch.UpstreamGone {
+		remoteDeleteItem.DisabledReason = self.c.Tr.UpstreamNotSetError
 	}
 
 	menuTitle := utils.ResolvePlaceholderString(
@@ -509,7 +499,7 @@ func (self *BranchesController) delete(branch *models.Branch) error {
 
 	return self.c.Menu(types.CreateMenuOptions{
 		Title: menuTitle,
-		Items: menuItems,
+		Items: []*types.MenuItem{localDeleteItem, remoteDeleteItem},
 	})
 }
 
@@ -523,6 +513,16 @@ func (self *BranchesController) rebase() error {
 	return self.c.Helpers().MergeAndRebase.RebaseOntoRef(selectedBranchName)
 }
 
+func (self *BranchesController) getDisabledReasonForRebase() string {
+	selectedBranchName := self.context().GetSelected().Name
+	checkedOutBranch := self.c.Helpers().Refs.GetCheckedOutRef().Name
+	if selectedBranchName == checkedOutBranch {
+		return self.c.Tr.CantRebaseOntoSelf
+	}
+
+	return ""
+}
+
 func (self *BranchesController) fastForward(branch *models.Branch) error {
 	if !branch.IsTrackingRemote() {
 		return self.c.ErrorMsg(self.c.Tr.FwdNoUpstream)

pkg/gui/controllers/helpers/cherry_pick_helper.go

@@ -85,6 +85,10 @@ func (self *CherryPickHelper) Paste() error {
 	})
 }
 
+func (self *CherryPickHelper) CanPaste() bool {
+	return self.getData().Active()
+}
+
 func (self *CherryPickHelper) Reset() error {
 	self.getData().ContextKey = ""
 	self.getData().CherryPickedCommits = nil

pkg/gui/controllers/helpers/confirmation_helper.go

@@ -333,7 +333,7 @@ func (self *ConfirmationHelper) resizeMenu() {
 	tooltip := ""
 	selectedItem := self.c.Contexts().Menu.GetSelected()
 	if selectedItem != nil {
-		tooltip = selectedItem.Tooltip
+		tooltip = self.TooltipForMenuItem(selectedItem)
 	}
 	tooltipHeight := getMessageHeight(true, tooltip, panelWidth) + 2 // plus 2 for the frame
 	_, _ = self.c.GocuiGui().SetView(self.c.Views().Tooltip.Name(), x0, tooltipTop, x1, tooltipTop+tooltipHeight-1, 0)
@@ -382,3 +382,14 @@ func (self *ConfirmationHelper) IsPopupPanel(viewName string) bool {
 func (self *ConfirmationHelper) IsPopupPanelFocused() bool {
 	return self.IsPopupPanel(self.c.CurrentContext().GetViewName())
 }
+
+func (self *ConfirmationHelper) TooltipForMenuItem(menuItem *types.MenuItem) string {
+	tooltip := menuItem.Tooltip
+	if menuItem.DisabledReason != "" {
+		if tooltip != "" {
+			tooltip += "\n\n"
+		}
+		tooltip += style.FgRed.Sprintf(self.c.Tr.DisabledMenuItemPrefix) + menuItem.DisabledReason
+	}
+	return tooltip
+}

pkg/gui/controllers/helpers/merge_and_rebase_helper.go

@@ -220,9 +220,6 @@ func (self *MergeAndRebaseHelper) PromptToContinueRebase() error {
 
 func (self *MergeAndRebaseHelper) RebaseOntoRef(ref string) error {
 	checkedOutBranch := self.refsHelper.GetCheckedOutRef().Name
-	if ref == checkedOutBranch {
-		return self.c.ErrorMsg(self.c.Tr.CantRebaseOntoSelf)
-	}
 	menuItems := []*types.MenuItem{
 		{
 			Label: self.c.Tr.SimpleRebase,

pkg/gui/controllers/local_commits_controller.go

@@ -44,70 +44,83 @@ func NewLocalCommitsController(
 func (self *LocalCommitsController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
 	outsideFilterModeBindings := []*types.Binding{
 		{
-			Key:         opts.GetKey(opts.Config.Commits.SquashDown),
+			Key:               opts.GetKey(opts.Config.Commits.SquashDown),
-			Handler:     self.checkSelected(self.squashDown),
+			Handler:           self.checkSelected(self.squashDown),
-			Description: self.c.Tr.SquashDown,
+			GetDisabledReason: self.callGetDisabledReasonFuncWithSelectedCommit(self.getDisabledReasonForSquashDown),
+			Description:       self.c.Tr.SquashDown,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.MarkCommitAsFixup),
+			Key:               opts.GetKey(opts.Config.Commits.MarkCommitAsFixup),
-			Handler:     self.checkSelected(self.fixup),
+			Handler:           self.checkSelected(self.fixup),
-			Description: self.c.Tr.FixupCommit,
+			GetDisabledReason: self.callGetDisabledReasonFuncWithSelectedCommit(self.getDisabledReasonForFixup),
+			Description:       self.c.Tr.FixupCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.RenameCommit),
+			Key:               opts.GetKey(opts.Config.Commits.RenameCommit),
-			Handler:     self.checkSelected(self.reword),
+			Handler:           self.checkSelected(self.reword),
-			Description: self.c.Tr.RewordCommit,
+			GetDisabledReason: self.getDisabledReasonForRebaseCommandWithSelectedCommit(todo.Reword),
+			Description:       self.c.Tr.RewordCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.RenameCommitWithEditor),
+			Key:               opts.GetKey(opts.Config.Commits.RenameCommitWithEditor),
-			Handler:     self.checkSelected(self.rewordEditor),
+			Handler:           self.checkSelected(self.rewordEditor),
-			Description: self.c.Tr.RenameCommitEditor,
+			GetDisabledReason: self.getDisabledReasonForRebaseCommandWithSelectedCommit(todo.Reword),
+			Description:       self.c.Tr.RenameCommitEditor,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Universal.Remove),
+			Key:               opts.GetKey(opts.Config.Universal.Remove),
-			Handler:     self.checkSelected(self.drop),
+			Handler:           self.checkSelected(self.drop),
-			Description: self.c.Tr.DeleteCommit,
+			GetDisabledReason: self.getDisabledReasonForRebaseCommandWithSelectedCommit(todo.Drop),
+			Description:       self.c.Tr.DeleteCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Universal.Edit),
+			Key:               opts.GetKey(opts.Config.Universal.Edit),
-			Handler:     self.checkSelected(self.edit),
+			Handler:           self.checkSelected(self.edit),
-			Description: self.c.Tr.EditCommit,
+			GetDisabledReason: self.getDisabledReasonForRebaseCommandWithSelectedCommit(todo.Edit),
+			Description:       self.c.Tr.EditCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.PickCommit),
+			Key:               opts.GetKey(opts.Config.Commits.PickCommit),
-			Handler:     self.checkSelected(self.pick),
+			Handler:           self.checkSelected(self.pick),
-			Description: self.c.Tr.PickCommit,
+			GetDisabledReason: self.getDisabledReasonForRebaseCommandWithSelectedCommit(todo.Pick),
+			Description:       self.c.Tr.PickCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.CreateFixupCommit),
+			Key:               opts.GetKey(opts.Config.Commits.CreateFixupCommit),
-			Handler:     self.checkSelected(self.createFixupCommit),
+			Handler:           self.checkSelected(self.createFixupCommit),
-			Description: self.c.Tr.CreateFixupCommitDescription,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
+			Description:       self.c.Tr.CreateFixupCommitDescription,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.SquashAboveCommits),
+			Key:               opts.GetKey(opts.Config.Commits.SquashAboveCommits),
-			Handler:     self.checkSelected(self.squashAllAboveFixupCommits),
+			Handler:           self.checkSelected(self.squashAllAboveFixupCommits),
-			Description: self.c.Tr.SquashAboveCommits,
+			GetDisabledReason: self.callGetDisabledReasonFuncWithSelectedCommit(self.getDisabledReasonForSquashAllAboveFixupCommits),
+			Description:       self.c.Tr.SquashAboveCommits,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.MoveDownCommit),
+			Key:               opts.GetKey(opts.Config.Commits.MoveDownCommit),
-			Handler:     self.checkSelected(self.moveDown),
+			Handler:           self.checkSelected(self.moveDown),
-			Description: self.c.Tr.MoveDownCommit,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
+			Description:       self.c.Tr.MoveDownCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.MoveUpCommit),
+			Key:               opts.GetKey(opts.Config.Commits.MoveUpCommit),
-			Handler:     self.checkSelected(self.moveUp),
+			Handler:           self.checkSelected(self.moveUp),
-			Description: self.c.Tr.MoveUpCommit,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
+			Description:       self.c.Tr.MoveUpCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.PasteCommits),
+			Key:               opts.GetKey(opts.Config.Commits.PasteCommits),
-			Handler:     self.paste,
+			Handler:           self.paste,
-			Description: self.c.Tr.PasteCommits,
+			GetDisabledReason: self.getDisabledReasonForPaste,
+			Description:       self.c.Tr.PasteCommits,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.MarkCommitAsBaseForRebase),
+			Key:               opts.GetKey(opts.Config.Commits.MarkCommitAsBaseForRebase),
-			Handler:     self.checkSelected(self.markAsBaseCommit),
+			Handler:           self.checkSelected(self.markAsBaseCommit),
-			Description: self.c.Tr.MarkAsBaseCommit,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
-			Tooltip:     self.c.Tr.MarkAsBaseCommitTooltip,
+			Description:       self.c.Tr.MarkAsBaseCommit,
+			Tooltip:           self.c.Tr.MarkAsBaseCommitTooltip,
 		},
 		// overriding these navigation keybindings because we might need to load
 		// more commits on demand
@@ -131,25 +144,29 @@ func (self *LocalCommitsController) GetKeybindings(opts types.KeybindingsOpts) [
 
 	bindings := append(outsideFilterModeBindings, []*types.Binding{
 		{
-			Key:         opts.GetKey(opts.Config.Commits.AmendToCommit),
+			Key:               opts.GetKey(opts.Config.Commits.AmendToCommit),
-			Handler:     self.checkSelected(self.amendTo),
+			Handler:           self.checkSelected(self.amendTo),
-			Description: self.c.Tr.AmendToCommit,
+			GetDisabledReason: self.callGetDisabledReasonFuncWithSelectedCommit(self.getDisabledReasonForAmendTo),
+			Description:       self.c.Tr.AmendToCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.ResetCommitAuthor),
+			Key:               opts.GetKey(opts.Config.Commits.ResetCommitAuthor),
-			Handler:     self.checkSelected(self.amendAttribute),
+			Handler:           self.checkSelected(self.amendAttribute),
-			Description: self.c.Tr.SetResetCommitAuthor,
+			GetDisabledReason: self.callGetDisabledReasonFuncWithSelectedCommit(self.getDisabledReasonForAmendTo),
-			OpensMenu:   true,
+			Description:       self.c.Tr.SetResetCommitAuthor,
+			OpensMenu:         true,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.RevertCommit),
+			Key:               opts.GetKey(opts.Config.Commits.RevertCommit),
-			Handler:     self.checkSelected(self.revert),
+			Handler:           self.checkSelected(self.revert),
-			Description: self.c.Tr.RevertCommit,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
+			Description:       self.c.Tr.RevertCommit,
 		},
 		{
-			Key:         opts.GetKey(opts.Config.Commits.CreateTag),
+			Key:               opts.GetKey(opts.Config.Commits.CreateTag),
-			Handler:     self.checkSelected(self.createTag),
+			Handler:           self.checkSelected(self.createTag),
-			Description: self.c.Tr.TagCommit,
+			GetDisabledReason: self.disabledIfNoSelectedCommit(),
+			Description:       self.c.Tr.TagCommit,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Commits.OpenLogMenu),
@@ -208,10 +225,6 @@ func secondaryPatchPanelUpdateOpts(c *ControllerCommon) *types.ViewUpdateOpts {
 }
 
 func (self *LocalCommitsController) squashDown(commit *models.Commit) error {
-	if self.context().GetSelectedLineIdx() >= len(self.c.Model().Commits)-1 {
-		return self.c.ErrorMsg(self.c.Tr.CannotSquashOrFixupFirstCommit)
-	}
-
 	applied, err := self.handleMidRebaseCommand(todo.Squash, commit)
 	if err != nil {
 		return err
@@ -232,11 +245,15 @@ func (self *LocalCommitsController) squashDown(commit *models.Commit) error {
 	})
 }
 
-func (self *LocalCommitsController) fixup(commit *models.Commit) error {
+func (self *LocalCommitsController) getDisabledReasonForSquashDown(commit *models.Commit) string {
 	if self.context().GetSelectedLineIdx() >= len(self.c.Model().Commits)-1 {
-		return self.c.ErrorMsg(self.c.Tr.CannotSquashOrFixupFirstCommit)
+		return self.c.Tr.CannotSquashOrFixupFirstCommit
 	}
 
+	return self.rebaseCommandEnabled(todo.Squash, commit)
+}
+
+func (self *LocalCommitsController) fixup(commit *models.Commit) error {
 	applied, err := self.handleMidRebaseCommand(todo.Fixup, commit)
 	if err != nil {
 		return err
@@ -257,6 +274,14 @@ func (self *LocalCommitsController) fixup(commit *models.Commit) error {
 	})
 }
 
+func (self *LocalCommitsController) getDisabledReasonForFixup(commit *models.Commit) string {
+	if self.context().GetSelectedLineIdx() >= len(self.c.Model().Commits)-1 {
+		return self.c.Tr.CannotSquashOrFixupFirstCommit
+	}
+
+	return self.rebaseCommandEnabled(todo.Squash, commit)
+}
+
 func (self *LocalCommitsController) reword(commit *models.Commit) error {
 	applied, err := self.handleMidRebaseCommand(todo.Reword, commit)
 	if err != nil {
@@ -428,34 +453,10 @@ func (self *LocalCommitsController) interactiveRebase(action todo.TodoCommand) e
 // commit meaning you are trying to edit the todo file rather than actually
 // begin a rebase. It then updates the todo file with that action
 func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoCommand, commit *models.Commit) (bool, error) {
-	if commit.Action == models.ActionConflict {
-		return true, self.c.ErrorMsg(self.c.Tr.ChangingThisActionIsNotAllowed)
-	}
-
 	if !commit.IsTODO() {
-		if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
-			// If we are in a rebase, the only action that is allowed for
-			// non-todo commits is rewording the current head commit
-			if !(action == todo.Reword && self.isHeadCommit()) {
-				return true, self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
-			}
-		}
-
 		return false, nil
 	}
 
-	// for now we do not support setting 'reword' because it requires an editor
-	// and that means we either unconditionally wait around for the subprocess to ask for
-	// our input or we set a lazygit client as the EDITOR env variable and have it
-	// request us to edit the commit message when prompted.
-	if action == todo.Reword {
-		return true, self.c.ErrorMsg(self.c.Tr.RewordNotSupported)
-	}
-
-	if allowed := isChangeOfRebaseTodoAllowed(action); !allowed {
-		return true, self.c.ErrorMsg(self.c.Tr.ChangingThisActionIsNotAllowed)
-	}
-
 	self.c.LogAction("Update rebase TODO")
 
 	msg := utils.ResolvePlaceholderString(
@@ -476,6 +477,38 @@ func (self *LocalCommitsController) handleMidRebaseCommand(action todo.TodoComma
 	})
 }
 
+func (self *LocalCommitsController) rebaseCommandEnabled(action todo.TodoCommand, commit *models.Commit) string {
+	if commit.Action == models.ActionConflict {
+		return self.c.Tr.ChangingThisActionIsNotAllowed
+	}
+
+	if !commit.IsTODO() {
+		if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
+			// If we are in a rebase, the only action that is allowed for
+			// non-todo commits is rewording the current head commit
+			if !(action == todo.Reword && self.isHeadCommit()) {
+				return self.c.Tr.AlreadyRebasing
+			}
+		}
+
+		return ""
+	}
+
+	// for now we do not support setting 'reword' because it requires an editor
+	// and that means we either unconditionally wait around for the subprocess to ask for
+	// our input or we set a lazygit client as the EDITOR env variable and have it
+	// request us to edit the commit message when prompted.
+	if action == todo.Reword {
+		return self.c.Tr.RewordNotSupported
+	}
+
+	if allowed := isChangeOfRebaseTodoAllowed(action); !allowed {
+		return self.c.Tr.ChangingThisActionIsNotAllowed
+	}
+
+	return ""
+}
+
 func (self *LocalCommitsController) moveDown(commit *models.Commit) error {
 	index := self.context().GetSelectedLineIdx()
 	commits := self.c.Model().Commits
@@ -601,6 +634,14 @@ func (self *LocalCommitsController) amendTo(commit *models.Commit) error {
 	})
 }
 
+func (self *LocalCommitsController) getDisabledReasonForAmendTo(commit *models.Commit) string {
+	if !self.isHeadCommit() && self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
+		return self.c.Tr.AlreadyRebasing
+	}
+
+	return ""
+}
+
 func (self *LocalCommitsController) amendAttribute(commit *models.Commit) error {
 	if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE && !self.isHeadCommit() {
 		return self.c.ErrorMsg(self.c.Tr.AlreadyRebasing)
@@ -772,6 +813,14 @@ func (self *LocalCommitsController) squashAllAboveFixupCommits(commit *models.Co
 	})
 }
 
+func (self *LocalCommitsController) getDisabledReasonForSquashAllAboveFixupCommits(commit *models.Commit) string {
+	if self.c.Git().Status.WorkingTreeState() != enums.REBASE_MODE_NONE {
+		return self.c.Tr.AlreadyRebasing
+	}
+
+	return ""
+}
+
 func (self *LocalCommitsController) createTag(commit *models.Commit) error {
 	return self.c.Helpers().Tags.OpenCreateTagPrompt(commit.Sha, func() {})
 }
@@ -896,13 +945,35 @@ func (self *LocalCommitsController) checkSelected(callback func(*models.Commit)
 	return func() error {
 		commit := self.context().GetSelected()
 		if commit == nil {
-			return nil
+			// The enabled callback should have checked for this
+			panic("no commit selected")
 		}
 
 		return callback(commit)
 	}
 }
 
+func (self *LocalCommitsController) callGetDisabledReasonFuncWithSelectedCommit(callback func(*models.Commit) string) func() string {
+	return func() string {
+		commit := self.context().GetSelected()
+		if commit == nil {
+			return self.c.Tr.NoCommitSelected
+		}
+
+		return callback(commit)
+	}
+}
+
+func (self *LocalCommitsController) disabledIfNoSelectedCommit() func() string {
+	return self.callGetDisabledReasonFuncWithSelectedCommit(func(*models.Commit) string { return "" })
+}
+
+func (self *LocalCommitsController) getDisabledReasonForRebaseCommandWithSelectedCommit(action todo.TodoCommand) func() string {
+	return self.callGetDisabledReasonFuncWithSelectedCommit(func(commit *models.Commit) string {
+		return self.rebaseCommandEnabled(action, commit)
+	})
+}
+
 func (self *LocalCommitsController) GetOnFocus() func(types.OnFocusOpts) error {
 	return func(types.OnFocusOpts) error {
 		context := self.context()
@@ -931,6 +1002,14 @@ func (self *LocalCommitsController) paste() error {
 	return self.c.Helpers().CherryPick.Paste()
 }
 
+func (self *LocalCommitsController) getDisabledReasonForPaste() string {
+	if !self.c.Helpers().CherryPick.CanPaste() {
+		return self.c.Tr.NoCopiedCommits
+	}
+
+	return ""
+}
+
 func (self *LocalCommitsController) markAsBaseCommit(commit *models.Commit) error {
 	if commit.Sha == self.c.Modes().MarkedBaseCommit.GetSha() {
 		// Reset when invoking it again on the marked commit

pkg/gui/controllers/menu_controller.go

@@ -54,7 +54,7 @@ func (self *MenuController) GetOnFocus() func(types.OnFocusOpts) error {
 	return func(types.OnFocusOpts) error {
 		selectedMenuItem := self.context().GetSelected()
 		if selectedMenuItem != nil {
-			self.c.Views().Tooltip.SetContent(selectedMenuItem.Tooltip)
+			self.c.Views().Tooltip.SetContent(self.c.Helpers().Confirmation.TooltipForMenuItem(selectedMenuItem))
 		}
 		return nil
 	}

pkg/gui/controllers/options_menu_action.go

@@ -25,6 +25,10 @@ func (self *OptionsMenuAction) Call() error {
 	appendBindings := func(bindings []*types.Binding, section *types.MenuSection) {
 		menuItems = append(menuItems,
 			lo.Map(bindings, func(binding *types.Binding, _ int) *types.MenuItem {
+				disabledReason := ""
+				if binding.GetDisabledReason != nil {
+					disabledReason = binding.GetDisabledReason()
+				}
 				return &types.MenuItem{
 					OpensMenu: binding.OpensMenu,
 					Label:     binding.Description,
@@ -33,11 +37,12 @@ func (self *OptionsMenuAction) Call() error {
 							return nil
 						}
 
-						return binding.Handler()
+						return self.c.IGuiCommon.CallKeybindingHandler(binding)
 					},
-					Key:     binding.Key,
+					Key:            binding.Key,
-					Tooltip: binding.Tooltip,
+					Tooltip:        binding.Tooltip,
-					Section: section,
+					DisabledReason: disabledReason,
+					Section:        section,
 				}
 			})...)
 	}

pkg/gui/gui_common.go

@@ -171,6 +171,10 @@ func (self *guiCommon) KeybindingsOpts() types.KeybindingsOpts {
 	return self.gui.keybindingOpts()
 }
 
+func (self *guiCommon) CallKeybindingHandler(binding *types.Binding) error {
+	return self.gui.callKeybindingHandler(binding)
+}
+
 func (self *guiCommon) IsAnyModeActive() bool {
 	return self.gui.helpers.Mode.IsAnyModeActive()
 }

pkg/gui/keybindings.go

@@ -375,7 +375,10 @@ func (gui *Gui) wrappedHandler(f func() error) func(g *gocui.Gui, v *gocui.View)
 }
 
 func (gui *Gui) SetKeybinding(binding *types.Binding) error {
-	handler := binding.Handler
+	handler := func() error {
+		return gui.callKeybindingHandler(binding)
+	}
+
 	// TODO: move all mouse-ey stuff into new mouse approach
 	if gocui.IsMouseKey(binding.Key) {
 		handler = func() error {
@@ -406,3 +409,14 @@ func (gui *Gui) SetMouseKeybinding(binding *gocui.ViewMouseBinding) error {
 
 	return gui.g.SetViewClickBinding(binding)
 }
+
+func (gui *Gui) callKeybindingHandler(binding *types.Binding) error {
+	disabledReason := ""
+	if binding.GetDisabledReason != nil {
+		disabledReason = binding.GetDisabledReason()
+	}
+	if disabledReason != "" {
+		return gui.c.ErrorMsg(disabledReason)
+	}
+	return binding.Handler()
+}

pkg/gui/types/common.go

@@ -104,6 +104,7 @@ type IGuiCommon interface {
 	State() IStateAccessor
 
 	KeybindingsOpts() KeybindingsOpts
+	CallKeybindingHandler(binding *Binding) error
 
 	// hopefully we can remove this once we've moved all our keybinding stuff out of the gui god struct.
 	GetInitialKeybindingsWithCustomCommands() ([]*Binding, []*gocui.ViewMouseBinding)
@@ -204,6 +205,10 @@ type MenuItem struct {
 	// The tooltip will be displayed upon highlighting the menu item
 	Tooltip string
 
+	// If non-empty, show this in a tooltip, style the menu item as disabled,
+	// and refuse to invoke the command
+	DisabledReason string
+
 	// Can be used to group menu items into sections with headers. MenuItems
 	// with the same Section should be contiguous, and will automatically get a
 	// section header. If nil, the item is not part of a section.

pkg/gui/types/keybindings.go

@@ -25,6 +25,13 @@ type Binding struct {
 
 	// to be displayed if the keybinding is highlighted from within a menu
 	Tooltip string
+
+	// Function to decide whether the command is enabled, and why. If this
+	// returns an empty string, it is; if it returns a non-empty string, it is
+	// disabled and we show the given text in an error message when trying to
+	// invoke it. When left nil, the command is always enabled. Note that this
+	// function must not do expensive calls.
+	GetDisabledReason func() string
 }
 
 // A guard is a decorator which checks something before executing a handler

pkg/i18n/english.go

@@ -352,12 +352,11 @@ type TranslationSet struct {
 	SetUpstream                         string
 	UnsetUpstream                       string
 	ViewDivergenceFromUpstream          string
-	DivergenceNoUpstream                string
 	DivergenceSectionHeaderLocal        string
 	DivergenceSectionHeaderRemote       string
 	ViewUpstreamResetOptions            string
 	ViewUpstreamResetOptionsTooltip     string
-	ViewUpstreamDisabledResetOptions    string
+	UpstreamGenericName                 string
 	SetUpstreamTitle                    string
 	SetUpstreamMessage                  string
 	EditRemote                          string
@@ -405,7 +404,6 @@ type TranslationSet struct {
 	ViewBranchUpstreamOptions           string
 	BranchUpstreamOptionsTitle          string
 	ViewBranchUpstreamOptionsTooltip    string
-	UpstreamNotStoredLocallyError       string
 	UpstreamNotSetError                 string
 	NewGitFlowBranchPrompt              string
 	RenameBranchWarning                 string
@@ -612,6 +610,9 @@ type TranslationSet struct {
 	MarkAsBaseCommitTooltip             string
 	MarkedCommitMarker                  string
 	PleaseGoToURL                       string
+	DisabledMenuItemPrefix              string
+	NoCommitSelected                    string
+	NoCopiedCommits                     string
 	Actions                             Actions
 	Bisect                              Bisect
 	Log                                 Log
@@ -1147,12 +1148,11 @@ func EnglishTranslationSet() TranslationSet {
 		SetUpstream:                         "Set upstream of selected branch",
 		UnsetUpstream:                       "Unset upstream of selected branch",
 		ViewDivergenceFromUpstream:          "View divergence from upstream",
-		DivergenceNoUpstream:                "Cannot show divergence of a branch that has no (locally tracked) upstream",
 		DivergenceSectionHeaderLocal:        "Local",
 		DivergenceSectionHeaderRemote:       "Remote",
 		ViewUpstreamResetOptions:            "Reset checked-out branch onto {{.upstream}}",
 		ViewUpstreamResetOptionsTooltip:     "View options for resetting the checked-out branch onto {{upstream}}. Note: this will not reset the selected branch onto the upstream, it will reset the checked-out branch onto the upstream",
-		ViewUpstreamDisabledResetOptions:    "Reset checked-out branch onto upstream of selected branch",
+		UpstreamGenericName:                 "upstream of selected branch",
 		SetUpstreamTitle:                    "Set upstream branch",
 		SetUpstreamMessage:                  "Are you sure you want to set the upstream branch of '{{.checkedOut}}' to '{{.selected}}'",
 		EditRemote:                          "Edit remote",
@@ -1196,8 +1196,7 @@ func EnglishTranslationSet() TranslationSet {
 		RenameBranch:                     "Rename branch",
 		BranchUpstreamOptionsTitle:       "Upstream options",
 		ViewBranchUpstreamOptionsTooltip: "View options relating to the branch's upstream e.g. setting/unsetting the upstream and resetting to the upstream",
-		UpstreamNotStoredLocallyError:    "Cannot reset to upstream branch because it is not stored locally",
+		UpstreamNotSetError:              "The selected branch has no upstream (or the upstream is not stored locally)",
-		UpstreamNotSetError:              "The selected branch has no upstream",
 		ViewBranchUpstreamOptions:        "View upstream options",
 		NewBranchNamePrompt:              "Enter new branch name for branch",
 		RenameBranchWarning:              "This branch is tracking a remote. This action will only rename the local branch name, not the name of the remote branch. Continue?",
@@ -1403,6 +1402,9 @@ func EnglishTranslationSet() TranslationSet {
 		MarkAsBaseCommitTooltip:             "Select a base commit for the next rebase; this will effectively perform a 'git rebase --onto'.",
 		MarkedCommitMarker:                  "↑↑↑ Will rebase from here ↑↑↑",
 		PleaseGoToURL:                       "Please go to {{.url}}",
+		DisabledMenuItemPrefix:              "Disabled: ",
+		NoCommitSelected:                    "No commit selected",
+		NoCopiedCommits:                     "No copied commits",
 		Actions: Actions{
 			// TODO: combine this with the original keybinding descriptions (those are all in lowercase atm)
 			CheckoutCommit:                    "Checkout commit",

pkg/integration/tests/branch/reset_to_upstream.go

@@ -41,11 +41,11 @@ var ResetToUpstream = NewIntegrationTest(NewIntegrationTestArgs{
 				t.ExpectPopup().Menu().
 					Title(Equals("Upstream options")).
 					Select(Contains("Reset checked-out branch onto upstream of selected branch")).
-					Tooltip(Contains("The selected branch has no upstream")).
+					Tooltip(Contains("Disabled: The selected branch has no upstream (or the upstream is not stored locally)")).
 					Confirm()
 				t.ExpectPopup().Alert().
 					Title(Equals("Error")).
-					Content(Equals("The selected branch has no upstream")).
+					Content(Equals("The selected branch has no upstream (or the upstream is not stored locally)")).
 					Confirm()
 			}).
 			SelectNextItem().