fix PR#7 comments

1 files changed, 64 insertions, 42 deletions

diff --git a/revlist/revlist.go b/revlist/revlist.go
index f34ddb5..181e56d 100644
--- a/revlist/revlist.go
+++ b/revlist/revlist.go
@@ -12,26 +12,25 @@
 // The current implementation tries to get something similar to what you
 // whould get using git-revlist. See the failing tests for some
 // insight about how the current implementation and git-revlist differs.
+//
+// Another way to get the revision history for a file is:
+// git log --follow -p -- file
 package revlist
 
 import (
 	"bytes"
-	"errors"
 	"io"
 	"sort"
 
-	"github.com/sergi/go-diff/diffmatchpatch"
-
 	"gopkg.in/src-d/go-git.v2"
 	"gopkg.in/src-d/go-git.v2/core"
 	"gopkg.in/src-d/go-git.v2/diff"
-)
 
-// New errors defined by the package.
-var ErrFileNotFound = errors.New("file not found")
+	"github.com/sergi/go-diff/diffmatchpatch"
+)
 
 // A Revs is a list of revisions for a file (basically a list of commits).
-// It implements sort.Interface.
+// It implements sort.Interface using the commit time.
 type Revs []*git.Commit
 
 func (l Revs) Len() int {
@@ -48,7 +47,7 @@ func (l Revs) Swap(i, j int) {
 }
 
 // for debugging
-func (l Revs) String() string {
+func (l Revs) GoString() string {
 	var buf bytes.Buffer
 	for _, c := range l {
 		buf.WriteString(c.Hash.String()[:8])
@@ -57,16 +56,16 @@ func (l Revs) String() string {
 	return buf.String()
 }
 
-// New returns a Revs pointer for the
-// file at "path", from commit "commit" backwards in time.
-// The commits are stored in arbitrary order.
+// NewRevs returns a Revs pointer for the
+// file at "path", from commit "commit".
+// The commits are sorted in commit order.
 // It stops searching a branch for a file upon reaching the commit
-// were it was created.
+// were the file was created.
 // Moves and copies are not currently supported.
-// Cherry-picks are not detected and therefore are added to the list
+// Cherry-picks are not detected unless there are no commits between
+// them and therefore can appear repeated in the list.
 // (see git path-id for hints on how to fix this).
-// This function implements is equivalent to running go-rev-Revs.
-func New(repo *git.Repository, commit *git.Commit, path string) (Revs, error) {
+func NewRevs(repo *git.Repository, commit *git.Commit, path string) (Revs, error) {
 	result := make(Revs, 0)
 	seen := make(map[core.Hash]struct{}, 0)
 	err := walkGraph(&result, &seen, repo, commit, path)
@@ -74,7 +73,7 @@ func New(repo *git.Repository, commit *git.Commit, path string) (Revs, error) {
 		return nil, err
 	}
 	sort.Sort(result)
-	result = removeComp(path, result, equivalent) // for merges of identical cherry-picks
+	result, err = removeComp(path, result, equivalent) // for merges of identical cherry-picks
 	if err != nil {
 		return nil, err
 	}
@@ -91,10 +90,12 @@ func walkGraph(result *Revs, seen *map[core.Hash]struct{}, repo *git.Repository,
 	(*seen)[current.Hash] = struct{}{}
 
 	// if the path is not in the current commit, stop searching.
-	if _, found := git.FindFile(path, current); !found {
+	if _, err := current.File(path); err != nil {
 		return nil
 	}
 
+	// optimization: don't traverse branches that does not
+	// contain the path.
 	parents := parentsContainingPath(path, current)
 
 	switch len(parents) {
@@ -103,7 +104,6 @@ func walkGraph(result *Revs, seen *map[core.Hash]struct{}, repo *git.Repository,
 	// stop searching. This includes the case when current is the
 	// initial commit.
 	case 0:
-		//fmt.Println(current.Hash.String(), ": case 0")
 		*result = append(*result, current)
 		return nil
 	case 1: // only one parent contains the path
@@ -113,7 +113,6 @@ func walkGraph(result *Revs, seen *map[core.Hash]struct{}, repo *git.Repository,
 			return err
 		}
 		if len(different) == 1 {
-			//fmt.Println(current.Hash.String(), ": case 1")
 			*result = append(*result, current)
 		}
 		// in any case, walk the parent
@@ -144,7 +143,7 @@ func parentsContainingPath(path string, c *git.Commit) []*git.Commit {
 			}
 			panic("unreachable")
 		}
-		if _, found := git.FindFile(path, parent); found {
+		if _, err := parent.File(path); err == nil {
 			result = append(result, parent)
 		}
 	}
@@ -156,7 +155,7 @@ func differentContents(path string, c *git.Commit, cs []*git.Commit) ([]*git.Com
 	result := make([]*git.Commit, 0, len(cs))
 	h, found := blobHash(path, c)
 	if !found {
-		return nil, ErrFileNotFound
+		return nil, git.ErrFileNotFound
 	}
 	for _, cx := range cs {
 		if hx, found := blobHash(path, cx); found && h != hx {
@@ -168,8 +167,8 @@ func differentContents(path string, c *git.Commit, cs []*git.Commit) ([]*git.Com
 
 // blobHash returns the hash of a path in a commit
 func blobHash(path string, commit *git.Commit) (hash core.Hash, found bool) {
-	file, found := git.FindFile(path, commit)
-	if !found {
+	file, err := commit.File(path)
+	if err != nil {
 		var empty core.Hash
 		return empty, found
 	}
@@ -179,48 +178,71 @@ func blobHash(path string, commit *git.Commit) (hash core.Hash, found bool) {
 // Returns a new slice of commits, with duplicates removed.  Expects a
 // sorted commit list.  Duplication is defined according to "comp".  It
 // will always keep the first commit of a series of duplicated commits.
-func removeComp(path string, cs []*git.Commit, comp func(string, *git.Commit, *git.Commit) bool) []*git.Commit {
+func removeComp(path string, cs []*git.Commit, comp func(string, *git.Commit, *git.Commit) (bool, error)) ([]*git.Commit, error) {
 	result := make([]*git.Commit, 0, len(cs))
 	if len(cs) == 0 {
-		return result
+		return result, nil
 	}
 	result = append(result, cs[0])
 	for i := 1; i < len(cs); i++ {
-		if !comp(path, cs[i], cs[i-1]) {
+		equals, err := comp(path, cs[i], cs[i-1])
+		if err != nil {
+			return nil, err
+		}
+		if !equals {
 			result = append(result, cs[i])
 		}
 	}
-	return result
+	return result, nil
 }
 
 // Equivalent commits are commits whos patch is the same.
-func equivalent(path string, a, b *git.Commit) bool {
+func equivalent(path string, a, b *git.Commit) (bool, error) {
 	numParentsA := a.NumParents()
 	numParentsB := b.NumParents()
 
 	// the first commit is not equivalent to anyone
 	// and "I think" merges can not be equivalent to anything
 	if numParentsA != 1 || numParentsB != 1 {
-		return false
+		return false, nil
 	}
 
-	iterA := a.Parents()
-	parentA, _ := iterA.Next()
-	iterB := b.Parents()
-	parentB, _ := iterB.Next()
+	diffsA, err := patch(a, path)
+	if err != nil {
+		return false, err
+	}
+	diffsB, err := patch(b, path)
+	if err != nil {
+		return false, err
+	}
 
-	dataA, _ := git.Data(path, a)
-	dataParentA, _ := git.Data(path, parentA)
-	dataB, _ := git.Data(path, b)
-	dataParentB, _ := git.Data(path, parentB)
+	return sameDiffs(diffsA, diffsB), nil
+}
 
-	diffsA := diff.Do(dataParentA, dataA)
-	diffsB := diff.Do(dataParentB, dataB)
+func patch(c *git.Commit, path string) ([]diffmatchpatch.Diff, error) {
+	// get contents of the file in the commit
+	file, err := c.File(path)
+	if err != nil {
+		return nil, err
+	}
+	content := file.Contents()
 
-	if sameDiffs(diffsA, diffsB) {
-		return true
+	// get contents of the file in the first parent of the commit
+	var contentParent string
+	iter := c.Parents()
+	parent, err := iter.Next()
+	if err != nil {
+		return nil, err
 	}
-	return false
+	file, err = parent.File(path)
+	if err != nil {
+		contentParent = ""
+	} else {
+		contentParent = file.Contents()
+	}
+
+	// compare the contents of parent and child
+	return diff.Do(content, contentParent), nil
 }
 
 func sameDiffs(a, b []diffmatchpatch.Diff) bool {