mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-10-06 05:57:38 -04:00
Stefan HallerandClaude Opus 5
e0aa9ad075
The pane beside a commit's diff showed the patch being built from it by assembling the text itself. That text could not be handed to a diff renderer the way a diff can: a stdin filter might have coped, but a tool that diffs two files could not. Its idea of how much context to show around a hunk was also its own rather than git's. Materialize the patch instead: write each of its files as it is before the patch into one tree and as it is after into another, and let git diff the two trees. The patch becomes a diff of real files, rendered by whatever renders the rest of them, with git's own context around it. Its lines can then be pointed at; taking them back out of the patch will need that. The trees are named a and b, so that with git's own prefixes suppressed the paths read like an ordinary diff's over the repo's own paths. They are written when the patch changes rather than when it is shown, the patch builder counting its own versions for that, and they go away with the patch. A renamed file is materialized under the name the patch expects to find it under. Where the patch carries the rename, that is the name the file had before, so the rename comes out as a rename. git names the trees themselves in the two rename lines, having only the two paths to go by. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
108 lines
4.1 KiB
Go
108 lines
4.1 KiB
Go
package patch
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
// newTestPatchBuilder returns a patch builder started for a dummy commit, in which
|
|
// every file's diff is the given one.
|
|
func newTestPatchBuilder(diff string) *PatchBuilder {
|
|
patchBuilder := NewPatchBuilder(logrus.New().WithField("test", "test"),
|
|
func(from string, to string, reverse bool, filename string, previousPath string) (string, error) {
|
|
return diff, nil
|
|
},
|
|
// Nothing here renders the patch, so it needs no directory to be
|
|
// materialized into.
|
|
nil)
|
|
patchBuilder.Start("from", "to", false, true)
|
|
return patchBuilder
|
|
}
|
|
|
|
// In simpleDiff the deletion "-orange" is line index 6 of the parsed diff (line 2 of
|
|
// the old file) and the addition "+grape" is index 7 (line 2 of the new file).
|
|
func TestPatchLineIndicesForLines(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(simpleDiff)
|
|
|
|
indices, err := patchBuilder.PatchLineIndicesForLines("filename", "", []LineIdentity{
|
|
{LineNumber: 2, IsDeletion: true}, // -orange
|
|
{LineNumber: 2, IsDeletion: false}, // +grape
|
|
{LineNumber: 1, IsDeletion: false}, // " apple", a context line
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []int{6, 7}, indices, "the context line names no change line")
|
|
}
|
|
|
|
// A renamed file's rename header makes its change lines sit further down the diff, and
|
|
// its old-file line numbers are of the file under its previous name.
|
|
func TestPatchLineIndicesForLinesOfARenamedFile(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(renameWithModificationDiff)
|
|
|
|
indices, err := patchBuilder.PatchLineIndicesForLines("newname", "oldname", []LineIdentity{
|
|
{LineNumber: 2, IsDeletion: true}, // -orange
|
|
{LineNumber: 2, IsDeletion: false}, // +grape
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []int{9, 10}, indices)
|
|
}
|
|
|
|
func TestIncludedLineIdentities(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(simpleDiff)
|
|
|
|
// A file no part of the patch has nothing included.
|
|
assert.Empty(t, patchBuilder.IncludedLineIdentities("filename"))
|
|
|
|
// With only the deletion in, only its identity comes back.
|
|
assert.NoError(t, patchBuilder.AddFileLineRange("filename", "", []int{6}))
|
|
assert.Equal(t,
|
|
[]LineIdentity{{LineNumber: 2, IsDeletion: true}},
|
|
patchBuilder.IncludedLineIdentities("filename"))
|
|
|
|
// With the addition in as well, both do.
|
|
assert.NoError(t, patchBuilder.AddFileLineRange("filename", "", []int{7}))
|
|
assert.ElementsMatch(t,
|
|
[]LineIdentity{{LineNumber: 2, IsDeletion: true}, {LineNumber: 2, IsDeletion: false}},
|
|
patchBuilder.IncludedLineIdentities("filename"))
|
|
}
|
|
|
|
func TestFilesInPatch(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(simpleDiff)
|
|
|
|
// A file no part of the patch is no part of what the patch is materialized from.
|
|
assert.Empty(t, patchBuilder.FilesInPatch())
|
|
|
|
assert.NoError(t, patchBuilder.AddFileLineRange("filename", "", []int{6}))
|
|
assert.Equal(t,
|
|
[]PatchFile{{Path: "filename", ContentPath: "filename"}},
|
|
patchBuilder.FilesInPatch())
|
|
}
|
|
|
|
// A renamed file's content is under the name it had before whatever the patch calls the
|
|
// file, and the patch calls it by the name it had before only where it carries the
|
|
// rename — a partial selection has the rename stripped and names the file by the new one.
|
|
func TestFilesInPatchOfARenamedFile(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(renameWithModificationDiff)
|
|
|
|
assert.NoError(t, patchBuilder.AddFileLineRange("newname", "oldname", []int{9}))
|
|
assert.Equal(t,
|
|
[]PatchFile{{Path: "newname", ContentPath: "oldname"}},
|
|
patchBuilder.FilesInPatch())
|
|
|
|
assert.NoError(t, patchBuilder.AddFileWhole("newname", "oldname"))
|
|
assert.Equal(t,
|
|
[]PatchFile{{Path: "oldname", ContentPath: "oldname"}},
|
|
patchBuilder.FilesInPatch())
|
|
}
|
|
|
|
// A file taken into the patch whole has every one of its change lines in it.
|
|
func TestIncludedLineIdentitiesOfAWholeFile(t *testing.T) {
|
|
patchBuilder := newTestPatchBuilder(simpleDiff)
|
|
|
|
assert.NoError(t, patchBuilder.AddFileWhole("filename", ""))
|
|
assert.ElementsMatch(t,
|
|
[]LineIdentity{{LineNumber: 2, IsDeletion: true}, {LineNumber: 2, IsDeletion: false}},
|
|
patchBuilder.IncludedLineIdentities("filename"))
|
|
}
|