git: Repository methods changes

_examples/clone/main.go

@@ -28,7 +28,7 @@ func main() {
 	ref, err := r.Head()
 	CheckIfError(err)
 	// ... retrieving the commit object
-	commit, err := r.Commit(ref.Hash())
+	commit, err := r.CommitObject(ref.Hash())
 	CheckIfError(err)
 
 	fmt.Println(commit)

_examples/log/main.go

@@ -30,7 +30,7 @@ func main() {
 	CheckIfError(err)
 
 	// ... retrieves the commit object
-	commit, err := r.Commit(ref.Hash())
+	commit, err := r.CommitObject(ref.Hash())
 	CheckIfError(err)
 
 	// ... retrieves the commit history

_examples/open/main.go

@@ -25,7 +25,7 @@ func main() {
 	CheckIfError(err)
 
 	// ... retrieving the commit object
-	commit, err := r.Commit(ref.Hash())
+	commit, err := r.CommitObject(ref.Hash())
 	CheckIfError(err)
 
 	// ... calculating the commit history

_examples/showcase/main.go

@@ -39,7 +39,7 @@ func main() {
 	CheckIfError(err)
 
 	// ... retrieving the commit object
-	commit, err := r.Commit(ref.Hash())
+	commit, err := r.CommitObject(ref.Hash())
 	CheckIfError(err)
 	fmt.Println(commit)
 

blame_test.go

@@ -26,7 +26,7 @@ func (s *BlameSuite) TestBlame(c *C) {
 		r := s.NewRepositoryFromPackfile(fixtures.ByURL(t.repo).One())
 
 		exp := s.mockBlame(c, t, r)
-		commit, err := r.Commit(plumbing.NewHash(t.rev))
+		commit, err := r.CommitObject(plumbing.NewHash(t.rev))
 		c.Assert(err, IsNil)
 
 		obt, err := Blame(commit, t.path)
@@ -36,7 +36,7 @@ func (s *BlameSuite) TestBlame(c *C) {
 }
 
 func (s *BlameSuite) mockBlame(c *C, t blameTest, r *Repository) (blame *BlameResult) {
-	commit, err := r.Commit(plumbing.NewHash(t.rev))
+	commit, err := r.CommitObject(plumbing.NewHash(t.rev))
 	c.Assert(err, IsNil, Commentf("%v: repo=%s, rev=%s", err, t.repo, t.rev))
 
 	f, err := commit.File(t.path)
@@ -48,7 +48,7 @@ func (s *BlameSuite) mockBlame(c *C, t blameTest, r *Repository) (blame *BlameRe
 
 	blamedLines := make([]*Line, 0, len(t.blames))
 	for i := range t.blames {
-		commit, err := r.Commit(plumbing.NewHash(t.blames[i]))
+		commit, err := r.CommitObject(plumbing.NewHash(t.blames[i]))
 		c.Assert(err, IsNil)
 		l := &Line{
 			Author: commit.Author.Email,

plumbing/storer/reference.go

@@ -28,6 +28,67 @@ type ReferenceIter interface {
 	Close()
 }
 
+type referenceFilteredIter struct {
+	ff   func(r *plumbing.Reference) bool
+	iter ReferenceIter
+}
+
+// NewReferenceFilteredIter returns a reference iterator for the given reference
+// Iterator. This iterator will iterate only references that accomplish the
+// provided function.
+func NewReferenceFilteredIter(
+	ff func(r *plumbing.Reference) bool, iter ReferenceIter) ReferenceIter {
+	return &referenceFilteredIter{ff, iter}
+}
+
+// Next returns the next reference from the iterator. If the iterator has reached
+// the end it will return io.EOF as an error.
+func (iter *referenceFilteredIter) Next() (*plumbing.Reference, error) {
+	for {
+		r, err := iter.iter.Next()
+		if err != nil {
+			return nil, err
+		}
+
+		if iter.ff(r) {
+			return r, nil
+		}
+
+		continue
+	}
+}
+
+// ForEach call the cb function for each reference contained on this iter until
+// an error happens or the end of the iter is reached. If ErrStop is sent
+// the iteration is stopped but no error is returned. The iterator is closed.
+func (iter *referenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error {
+	defer iter.Close()
+	for {
+		r, err := iter.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		if err := cb(r); err != nil {
+			if err == ErrStop {
+				break
+			}
+
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Close releases any resources used by the iterator.
+func (iter *referenceFilteredIter) Close() {
+	iter.iter.Close()
+}
+
 // ReferenceSliceIter implements ReferenceIter. It iterates over a series of
 // references stored in a slice and yields each one in turn when Next() is
 // called.
@@ -41,7 +102,7 @@ type ReferenceSliceIter struct {
 
 // NewReferenceSliceIter returns a reference iterator for the given slice of
 // objects.
-func NewReferenceSliceIter(series []*plumbing.Reference) *ReferenceSliceIter {
+func NewReferenceSliceIter(series []*plumbing.Reference) ReferenceIter {
 	return &ReferenceSliceIter{
 		series: series,
 	}

plumbing/storer/reference_test.go

@@ -89,3 +89,102 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) {
 
 	c.Assert(count, Equals, 1)
 }
+
+func (s *ReferenceSuite) TestReferenceFilteredIterNext(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	foo, err := i.Next()
+	c.Assert(err, IsNil)
+	c.Assert(foo == slice[0], Equals, false)
+	c.Assert(foo == slice[1], Equals, true)
+
+	empty, err := i.Next()
+	c.Assert(err, Equals, io.EOF)
+	c.Assert(empty, IsNil)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterForEach(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	var count int
+	i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		return nil
+	})
+
+	c.Assert(count, Equals, 1)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	var count int
+	exampleErr := errors.New("SOME ERROR")
+	err := i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		if count == 1 {
+			return exampleErr
+		}
+
+		return nil
+	})
+
+	c.Assert(err, Equals, exampleErr)
+	c.Assert(count, Equals, 1)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+
+	var count int
+	i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		return ErrStop
+	})
+
+	c.Assert(count, Equals, 1)
+}

references_test.go

@@ -291,7 +291,7 @@ func (s *ReferencesSuite) TestRevList(c *C) {
 	for _, t := range referencesTests {
 		r := s.NewRepositoryFromPackfile(fixtures.ByURL(t.repo).One())
 
-		commit, err := r.Commit(plumbing.NewHash(t.commit))
+		commit, err := r.CommitObject(plumbing.NewHash(t.commit))
 		c.Assert(err, IsNil)
 
 		revs, err := References(commit, t.path)
@@ -300,7 +300,7 @@ func (s *ReferencesSuite) TestRevList(c *C) {
 
 		for i := range revs {
 			if revs[i].Hash.String() != t.revs[i] {
-				commit, err := s.Repository.Commit(plumbing.NewHash(t.revs[i]))
+				commit, err := s.Repository.CommitObject(plumbing.NewHash(t.revs[i]))
 				c.Assert(err, IsNil)
 				equiv, err := equivalent(t.path, revs[i], commit)
 				c.Assert(err, IsNil)
@@ -358,7 +358,7 @@ func (s *ReferencesSuite) commits(c *C, repo string, hs ...string) []*object.Com
 
 	result := make([]*object.Commit, 0, len(hs))
 	for _, h := range hs {
-		commit, err := r.Commit(plumbing.NewHash(h))
+		commit, err := r.CommitObject(plumbing.NewHash(h))
 		c.Assert(err, IsNil)
 
 		result = append(result, commit)