mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-09-10 23:56:24 -04:00
cf8e5fd27e
The focused main view's click/enter/e/G handlers all need the same thing: given a rendered diff row, the patch-space line it corresponds to. Until now that came solely from delta's lazygit-edit:// hyperlinks, which only carry a path and a single line number — no side. That's lossy: for a deletion the number is the old line, but the consumers fed it into new-file lookups, and two consecutive deletions (which share a new-file line number) couldn't be told apart at all. Replace GetFileAndLineForClickedDiffLine with GetDiffLineInfo, returning the fuller (file, type, new-line, old-line) record from diff-line-metadata-notes.md. This is mechanism #1: parse the decolorized view buffer — walk up to the file's "diff --git" section, reuse patch.Parse on it (splitting multi-file commit diffs on the "diff --git" boundaries), and read the type and line numbers off the patch arithmetic. It serves the structure-preserving renderings — no pager, git diff --color, and delta --color-only without line numbers — with no external dependency. To avoid trusting a mis-parse, the parser bails when a hunk's body no longer matches its header (Patch.IsWellFormed). That's what happens when a pager keeps the diff/hunk headers but restructures the body: delta's line-number gutters push the +/- marker off the start of each line, so every body line reads as context. Such renderings fall through to the next backend rather than yielding a confident wrong answer. (diff-so-fancy goes further and rewrites the headers too, so it fails even earlier, on the missing "diff --git".) GetDiffLineInfo is a seam with swappable backends: the buffer parser first, then the old hyperlink reader as a fallback for renderings the parser can't handle (delta's default mode, or delta with line-number gutters). The future #2 OSC per-cell metadata reader plugs in ahead of both, behind the same record shape. Wire the consumers to the record per that doc's field mapping: - dive into staging/patch building lands on the exact patch line, looking a deletion up by its old-file line number (PatchLineForOldLineNumber) so the two-deletions case resolves correctly; - `e` edits at the new-file line; - `G` anchors the PR link on the left (old) side for a deletion, the right (new) side otherwise. The hyperlink fallback can't convey the side, so it reports DiffLineOther, which the consumers treat as a non-deletion — i.e. exactly today's behavior. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
101 lines
2.3 KiB
Go
101 lines
2.3 KiB
Go
package patch
|
|
|
|
import (
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/jesseduffield/lazygit/pkg/utils"
|
|
)
|
|
|
|
// Captures, in order: old start, old length (omitted when 1), new start, new
|
|
// length (omitted when 1), and the trailing context.
|
|
var hunkHeaderRegexp = regexp.MustCompile(`(?m)^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$`)
|
|
|
|
func Parse(patchStr string) *Patch {
|
|
// ignore trailing newline.
|
|
lines := strings.Split(strings.TrimSuffix(patchStr, "\n"), "\n")
|
|
|
|
hunks := []*Hunk{}
|
|
patchHeader := []string{}
|
|
|
|
var currentHunk *Hunk
|
|
for _, line := range lines {
|
|
if strings.HasPrefix(line, "@@") {
|
|
oldStart, oldLength, newStart, newLength, headerContext := headerInfo(line)
|
|
|
|
currentHunk = &Hunk{
|
|
oldStart: oldStart,
|
|
newStart: newStart,
|
|
declaredOldLength: oldLength,
|
|
declaredNewLength: newLength,
|
|
headerContext: headerContext,
|
|
bodyLines: []*PatchLine{},
|
|
}
|
|
hunks = append(hunks, currentHunk)
|
|
} else if currentHunk != nil {
|
|
currentHunk.bodyLines = append(currentHunk.bodyLines, newHunkLine(line))
|
|
} else {
|
|
patchHeader = append(patchHeader, line)
|
|
}
|
|
}
|
|
|
|
return &Patch{
|
|
hunks: hunks,
|
|
header: patchHeader,
|
|
}
|
|
}
|
|
|
|
func headerInfo(header string) (oldStart int, oldLength int, newStart int, newLength int, headerContext string) {
|
|
match := hunkHeaderRegexp.FindStringSubmatch(header)
|
|
|
|
oldStart = utils.MustConvertToInt(match[1])
|
|
oldLength = declaredLength(match[2])
|
|
newStart = utils.MustConvertToInt(match[3])
|
|
newLength = declaredLength(match[4])
|
|
headerContext = match[5]
|
|
|
|
return oldStart, oldLength, newStart, newLength, headerContext
|
|
}
|
|
|
|
// declaredLength parses a hunk header length capture, which git omits when it
|
|
// is 1 (e.g. "@@ -0,0 +1 @@").
|
|
func declaredLength(match string) int {
|
|
if match == "" {
|
|
return 1
|
|
}
|
|
return utils.MustConvertToInt(match)
|
|
}
|
|
|
|
func newHunkLine(line string) *PatchLine {
|
|
if line == "" {
|
|
return &PatchLine{
|
|
Kind: CONTEXT,
|
|
Content: "",
|
|
}
|
|
}
|
|
|
|
firstChar := line[:1]
|
|
|
|
kind := parseFirstChar(firstChar)
|
|
|
|
return &PatchLine{
|
|
Kind: kind,
|
|
Content: line,
|
|
}
|
|
}
|
|
|
|
func parseFirstChar(firstChar string) PatchLineKind {
|
|
switch firstChar {
|
|
case " ":
|
|
return CONTEXT
|
|
case "+":
|
|
return ADDITION
|
|
case "-":
|
|
return DELETION
|
|
case "\\":
|
|
return NEWLINE_MESSAGE
|
|
}
|
|
|
|
return CONTEXT
|
|
}
|