package object
import (
"path/filepath"
"strings"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/plumbing/filemode"
"github.com/go-git/go-git/v5/storage/memory"
. "gopkg.in/check.v1"
)
type RenameSuite struct {
BaseObjectsSuite
}
var _ = Suite(&RenameSuite{})
func (s *RenameSuite) TestNameSimilarityScore(c *C) {
testCases := []struct {
a, b string
score int
}{
{"foo/bar.c", "foo/baz.c", 70},
{"src/utils/Foo.java", "tests/utils/Foo.java", 64},
{"foo/bar/baz.py", "README.md", 0},
{"src/utils/something/foo.py", "src/utils/something/other/foo.py", 69},
{"src/utils/something/foo.py", "src/utils/yada/foo.py", 63},
{"src/utils/something/foo.py", "src/utils/something/other/bar.py", 44},
{"src/utils/something/foo.py", "src/utils/something/foo.py", 100},
}
for _, tt := range testCases {
c.Assert(nameSimilarityScore(tt.a, tt.b), Equals, tt.score)
}
}
const (
pathA = "src/A"
pathB = "src/B"
pathH = "src/H"
pathQ = "src/Q"
)
func (s *RenameSuite) TestExactRename_OneRename(c *C) {
a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
b := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
result := detectRenames(c, Changes{a, b}, nil, 1)
assertRename(c, b, a, result[0])
}
func (s *RenameSuite) TestExactRename_DifferentObjects(c *C) {
a := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
h := makeAdd(c, makeFile(c, pathH, filemode.Regular, "foo"))
q := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "bar"))
result := detectRenames(c, Changes{a, h, q}, nil, 3)
c.Assert(result[0], DeepEquals, a)
c.Assert(result[1], DeepEquals, h)
c.Assert(result[2], DeepEquals, q)
}
func (s *RenameSuite) TestExactRename_OneRenameOneModify(c *C) {
c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
c3 := makeChange(c,
makeFile(c, pathH, filemode.Regular, "bar"),
makeFile(c, pathH, filemode.Regular, "bar"),
)
result := detectRenames(c, Changes{c1, c2, c3}, nil, 2)
c.Assert(result[0], DeepEquals, c3)
assertRename(c, c2, c1, result[1])
}
func (s *RenameSuite) TestExactRename_ManyRenames(c *C) {
c1 := makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo"))
c2 := makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo"))
c3 := makeAdd(c, makeFile(c, pathH, filemode.Regular, "bar"))
c4 := makeDelete(c, makeFile(c, pathB, filemode.Regular, "bar"))
result := detectRenames(c, Changes{c1, c2, c3, c4}, nil, 2)
assertRename(c, c4, c3, result[0])
assertRename(c, c2, c1, result[1])
}
func (s *RenameSuite) TestExactRename_MultipleIdenticalDeletes(c *C) {
changes := Changes{
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")),
makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo")),
makeDelete(c, makeFile(c, pathH, filemode.Regular, "foo")),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 3)
assertRename(c, changes[0], changes[3], result[0])
c.Assert(result[1], DeepEquals, changes[1])
c.Assert(result[2], DeepEquals, changes[2])
}
func (s *RenameSuite) TestRenameExact_PathBreaksTie(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "the_e_file.txt", filemode.Regular, "foo")),
}
// Add out of order to avoid first-match succeeding
result := detectRenames(c, Changes{
changes[0],
changes[3],
changes[4],
changes[1],
changes[2],
}, nil, 3)
assertRename(c, changes[3], changes[2], result[0])
assertRename(c, changes[1], changes[0], result[1])
c.Assert(result[2], DeepEquals, changes[4])
}
func (s *RenameSuite) TestExactRename_OneDeleteManyAdds(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, "src/com/foo/a.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "src/com/foo/b.java", filemode.Regular, "foo")),
makeAdd(c, makeFile(c, "c.txt", filemode.Regular, "foo")),
makeDelete(c, makeFile(c, "d.txt", filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 3)
assertRename(c, changes[3], changes[2], result[0])
c.Assert(result[1], DeepEquals, changes[0])
c.Assert(result[2], DeepEquals, changes[1])
}
func (s *RenameSuite) TestExactRename_UnstagedFile(c *C) {
changes := Changes{
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo")),
makeAdd(c, makeFile(c, pathB, filemode.Regular, "foo")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[0], changes[1], result[0])
}
func (s *RenameSuite) TestContentRename_OnePair(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_OneRenameTwoUnrelatedFiles(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
makeAdd(c, makeFile(c, pathB, filemode.Regular, "some\nsort\nof\ntext\n")),
makeDelete(c, makeFile(c, pathH, filemode.Regular, "completely\nunrelated\ntext\n")),
}
result := detectRenames(c, changes, nil, 3)
c.Assert(result[0], DeepEquals, changes[2])
c.Assert(result[1], DeepEquals, changes[3])
assertRename(c, changes[1], changes[0], result[2])
}
func (s *RenameSuite) TestContentRename_LastByteDifferent(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\na")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "foo\nbar\nb")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_NewlinesOnly(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, strings.Repeat("\n", 3))),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, strings.Repeat("\n", 4))),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_SameContentMultipleTimes(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "a\na\na\na\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\na\na\n")),
}
result := detectRenames(c, changes, nil, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestContentRename_OnePairRenameScore50(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "ab\nab\nab\nac\nad\nae\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "ac\nab\nab\nab\naa\na0\na1\n")),
}
result := detectRenames(c, changes, &DiffTreeOptions{RenameScore: 50}, 1)
assertRename(c, changes[1], changes[0], result[0])
}
func (s *RenameSuite) TestNoRenames_SingleByteFiles(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "a")),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, "b")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_EmptyFile(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "")),
}
result := detectRenames(c, changes, nil, 1)
c.Assert(result[0], DeepEquals, changes[0])
}
func (s *RenameSuite) TestNoRenames_EmptyFile2(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "blah")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_SymlinkAndFile(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")),
makeDelete(c, makeFile(c, pathQ, filemode.Symlink, "src/dest")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestNoRenames_SymlinkAndFileSamePath(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "src/dest")),
makeDelete(c, makeFile(c, pathA, filemode.Symlink, "src/dest")),
}
result := detectRenames(c, changes, nil, 2)
c.Assert(result[0], DeepEquals, changes[0])
c.Assert(result[1], DeepEquals, changes[1])
}
func (s *RenameSuite) TestRenameLimit(c *C) {
changes := Changes{
makeAdd(c, makeFile(c, pathA, filemode.Regular, "foo\nbar\nbaz\nblarg\n")),
makeDelete(c, makeFile(c, pathB, filemode.Regular, "foo\nbar\nbaz\nblah\n")),
makeAdd(c, makeFile(c, pathH, filemode.Regular, "a\nb\nc\nd\n")),
makeDelete(c, makeFile(c, pathQ, filemode.Regular, "a\nb\nc\n")),
}
result := detectRenames(c, changes, &DiffTreeOptions{RenameLimit: 1}, 4)
for i, res := range result {
c.Assert(res, DeepEquals, changes[i])
}
}
func (s *RenameSuite) TestRenameExactManyAddsManyDeletesNoGaps(c *C) {
content := "a"
detector := &renameDetector{
added: []*Change{
makeAdd(c, makeFile(c, pathA, filemode.Regular, content)),
makeAdd(c, makeFile(c, pathQ, filemode.Regular, content)),
makeAdd(c, makeFile(c, "something", filemode.Regular, content)),
},
deleted: []*Change{
makeDelete(c, makeFile(c, pathA, filemode.Regular, content)),
makeDelete(c, makeFile(c, pathB, filemode.Regular, content)),
makeDelete(c, makeFile(c, "foo/bar/other", filemode.Regular, content)),
},
}
detector.detectExactRenames()
for _, added := range detector.added {
c.Assert(added, NotNil)
}
for _, deleted := range detector.deleted {
c.Assert(deleted, NotNil)
}
}
func detectRenames(c *C, changes Changes, opts *DiffTreeOptions, expectedResults int) Changes {
result, err := DetectRenames(changes, opts)
c.Assert(err, IsNil)
c.Assert(result, HasLen, expectedResults)
return result
}
func assertRename(c *C, from, to *Change, rename *Change) {
c.Assert(&Change{From: from.From, To: to.To}, DeepEquals, rename)
}
type SimilarityIndexSuite struct {
BaseObjectsSuite
}
var _ = Suite(&SimilarityIndexSuite{})
func (s *SimilarityIndexSuite) TestScoreFiles(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
binary, err := tree.File("binary.jpg")
c.Assert(err, IsNil)
binIndex, err := fileSimilarityIndex(binary)
c.Assert(err, IsNil)
long, err := tree.File("json/long.json")
c.Assert(err, IsNil)
longIndex, err := fileSimilarityIndex(long)
c.Assert(err, IsNil)
short, err := tree.File("json/short.json")
c.Assert(err, IsNil)
shortIndex, err := fileSimilarityIndex(short)
c.Assert(err, IsNil)
php, err := tree.File("php/crappy.php")
c.Assert(err, IsNil)
phpIndex, err := fileSimilarityIndex(php)
c.Assert(err, IsNil)
testCases := []struct {
src, dst *similarityIndex
expectedScore int
}{
{binIndex, binIndex, 10000}, // same file
{shortIndex, longIndex, 32}, // slightly similar files
{longIndex, shortIndex, 32}, // same as previous, diff order
{shortIndex, phpIndex, 1}, // different files
{longIndex, binIndex, 0}, // code vs binary file
}
for _, tt := range testCases {
score := tt.src.score(tt.dst, 10000)
c.Assert(score, Equals, tt.expectedScore)
}
}
func (s *SimilarityIndexSuite) TestHashContent(c *C) {
idx := textIndex(c, "A\n"+
"B\n"+
"D\n"+
"B\n")
keyA := keyFor(c, "A\n")
keyB := keyFor(c, "B\n")
keyD := keyFor(c, "D\n")
c.Assert(keyA, Not(Equals), keyB)
c.Assert(keyA, Not(Equals), keyD)
c.Assert(keyD, Not(Equals), keyB)
c.Assert(idx.numHashes, Equals, 3)
c.Assert(idx.hashes[findIndex(idx, keyA)].count(), Equals, uint64(2))
c.Assert(idx.hashes[findIndex(idx, keyB)].count(), Equals, uint64(4))
c.Assert(idx.hashes[findIndex(idx, keyD)].count(), Equals, uint64(2))
}
func (s *SimilarityIndexSuite) TestCommonSameFiles(c *C) {
content := "A\n" +
"B\n" +
"D\n" +
"B\n"
src := textIndex(c, content)
dst := textIndex(c, content)
c.Assert(src.common(dst), Equals, uint64(8))
c.Assert(dst.common(src), Equals, uint64(8))
c.Assert(src.score(dst, 100), Equals, 100)
c.Assert(dst.score(src, 100), Equals, 100)
}
func (s *SimilarityIndexSuite) TestCommonSameFilesCR(c *C) {
content := "A\r\n" +
"B\r\n" +
"D\r\n" +
"B\r\n"
src := textIndex(c, content)
dst := textIndex(c, strings.ReplaceAll(content, "\r", ""))
c.Assert(src.common(dst), Equals, uint64(8))
c.Assert(dst.common(src), Equals, uint64(8))
c.Assert(src.score(dst, 100), Equals, 100)
c.Assert(dst.score(src, 100), Equals, 100)
}
func (s *SimilarityIndexSuite) TestCommonEmptyFiles(c *C) {
src := textIndex(c, "")
dst := textIndex(c, "")
c.Assert(src.common(dst), Equals, uint64(0))
c.Assert(dst.common(src), Equals, uint64(0))
}
func (s *SimilarityIndexSuite) TestCommonTotallyDifferentFiles(c *C) {
src := textIndex(c, "A\n")
dst := textIndex(c, "D\n")
c.Assert(src.common(dst), Equals, uint64(0))
c.Assert(dst.common(src), Equals, uint64(0))
}
func (s *SimilarityIndexSuite) TestSimilarity75(c *C) {
src := textIndex(c, "A\nB\nC\nD\n")
dst := textIndex(c, "A\nB\nC\nQ\n")
c.Assert(src.common(dst), Equals, uint64(6))
c.Assert(dst.common(src), Equals, uint64(6))
c.Assert(src.score(dst, 100), Equals, 75)
c.Assert(dst.score(src, 100), Equals, 75)
}
func keyFor(c *C, line string) int {
idx := newSimilarityIndex()
err := idx.hashContent(strings.NewReader(line), int64(len(line)), false)
c.Assert(err, IsNil)
c.Assert(idx.numHashes, Equals, 1)
for _, h := range idx.hashes {
if h != 0 {
return h.key()
}
}
return -1
}
func textIndex(c *C, content string) *similarityIndex {
idx := newSimilarityIndex()
err := idx.hashContent(strings.NewReader(content), int64(len(content)), false)
c.Assert(err, IsNil)
return idx
}
func findIndex(idx *similarityIndex, key int) int {
for i, h := range idx.hashes {
if h.key() == key {
return i
}
}
return -1
}
func makeFile(c *C, name string, mode filemode.FileMode, content string) *File {
obj := new(plumbing.MemoryObject)
obj.SetType(plumbing.BlobObject)
_, err := obj.Write([]byte(content))
c.Assert(err, IsNil)
return &File{
Name: name,
Mode: mode,
Blob: Blob{Hash: obj.Hash(), Size: obj.Size(), obj: obj},
}
}
func makeChangeEntry(f *File) ChangeEntry {
sto := memory.NewStorage()
sto.SetEncodedObject(f.obj)
tree := &Tree{s: sto}
return ChangeEntry{
Name: f.Name,
Tree: tree,
TreeEntry: TreeEntry{
Name: filepath.Base(f.Name),
Mode: f.Mode,
Hash: f.Hash,
},
}
}
func makeAdd(c *C, f *File) *Change {
return makeChange(c, nil, f)
}
func makeDelete(c *C, f *File) *Change {
return makeChange(c, f, nil)
}
func makeChange(c *C, from *File, to *File) *Change {
if from == nil {
return &Change{To: makeChangeEntry(to)}
}
if to == nil {
return &Change{From: makeChangeEntry(from)}
}
if from == nil && to == nil {
c.Error("cannot make change without from or to")
}
return &Change{From: makeChangeEntry(from), To: makeChangeEntry(to)}
}
