mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-10-05 21:46:49 -04:00
Stefan HallerandClaude Opus 5
ae58e9233f
The five panels that show a commit's diff now offer on it what the patch explorer offers on the one file it can show at a time: space takes the selected lines into the custom patch being built, or back out of it again, and d takes them out of the commit itself. So a patch can be built straight from the diff already on screen, over several files at once and without entering the commit's files first — and from a stash entry or a reflog entry too, whose diffs the explorer could reach but which had no patch preview of their own to show for it. The two arrive together because they are one answer to what a commit's diff offers, and because d needs exactly what space builds: a patch of the selection, which the rebase then removes from the commit. Which of the two space is doing is decided by the first selected line, as toggling a file in the commit files panel is, and the selection then moves past the lines dealt with — they are still in the diff, a patch leaving the commit alone, so a second press would otherwise take them straight back out. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
85 lines
2.5 KiB
Go
85 lines
2.5 KiB
Go
package controllers
|
|
|
|
import (
|
|
"github.com/jesseduffield/lazygit/pkg/commands/models"
|
|
"github.com/jesseduffield/lazygit/pkg/gui/context"
|
|
"github.com/jesseduffield/lazygit/pkg/gui/types"
|
|
)
|
|
|
|
type ReflogCommitsController struct {
|
|
baseController
|
|
*ListControllerTrait[*models.Commit]
|
|
c *ControllerCommon
|
|
|
|
// what this panel offers on the diff it shows in the focused main view
|
|
diffActions *CommitDiffActions
|
|
}
|
|
|
|
var _ types.IController = &ReflogCommitsController{}
|
|
|
|
func NewReflogCommitsController(
|
|
c *ControllerCommon,
|
|
) *ReflogCommitsController {
|
|
controller := &ReflogCommitsController{
|
|
baseController: baseController{},
|
|
ListControllerTrait: NewListControllerTrait(
|
|
c,
|
|
c.Contexts().ReflogCommits,
|
|
c.Contexts().ReflogCommits.GetSelected,
|
|
c.Contexts().ReflogCommits.GetSelectedItems,
|
|
),
|
|
c: c,
|
|
}
|
|
controller.diffActions = NewCommitDiffActions(c, c.Contexts().ReflogCommits, controller.diffTarget)
|
|
return controller
|
|
}
|
|
|
|
// diffTarget is the reflog entry the panel has selected, whose diff its main view
|
|
// shows. A reflog entry is never a commit of the checked-out branch as far as we are
|
|
// concerned, so nothing here may be rewritten.
|
|
func (self *ReflogCommitsController) diffTarget() *commitDiffTarget {
|
|
commit := self.context().GetSelected()
|
|
if commit == nil {
|
|
return nil
|
|
}
|
|
return &commitDiffTarget{from: commit.ParentRefName(), to: commit.RefName()}
|
|
}
|
|
|
|
func (self *ReflogCommitsController) Context() types.Context {
|
|
return self.context()
|
|
}
|
|
|
|
func (self *ReflogCommitsController) context() *context.ReflogCommitsContext {
|
|
return self.c.Contexts().ReflogCommits
|
|
}
|
|
|
|
func (self *ReflogCommitsController) GetFocusedMainViewDiffSource() types.FocusedMainViewDiffSource {
|
|
return self.diffActions
|
|
}
|
|
|
|
func (self *ReflogCommitsController) GetOnRenderToMain() func() {
|
|
return func() {
|
|
self.c.Helpers().Diff.WithDiffModeCheck(func() {
|
|
commit := self.context().GetSelected()
|
|
var task types.UpdateTask
|
|
if commit == nil {
|
|
task = types.NewRenderStringTask("No reflog history")
|
|
} else {
|
|
mode := self.c.Helpers().DiffLine.MainViewDiffMode()
|
|
cmdObj := self.c.Git().Commit.ShowCmdObj(commit.Hash(), self.c.Helpers().Diff.FilterPathsForCommit(commit), mode)
|
|
|
|
task = types.NewMainViewDiffTask(cmdObj.GetCmd(), mode)
|
|
}
|
|
|
|
self.c.RenderToMainViews(types.RefreshMainOpts{
|
|
Pair: self.c.MainViewPairs().Normal,
|
|
Main: &types.ViewUpdateOpts{
|
|
Title: "Reflog Entry",
|
|
Task: task,
|
|
},
|
|
Secondary: secondaryPatchPanelUpdateOpts(self.c),
|
|
})
|
|
})
|
|
}
|
|
}
|