git: Repository methods changes

To have a more consistent public API, we decided to rename some methods, and add others:

- Commit method renamed to CommitObject
- Commits method renamed to CommitObjects
- Tree method renamed to TreeObject
- Trees method renamed to TreeObjects
- Tags method renamed to TagObjects
- Tag method renamed to TagObject
- Added method Tags that returns tag references
- Added method Branches that returns branch references
- Added method Notes that returns note references
- Added BlobObject method
- Added BlobObjects method

Also, we added more functionality related to references:
- Added iterator to iterate References with a specific filter

Some notes:
- #298

1 files changed, 62 insertions, 1 deletions

diff --git a/plumbing/storer/reference.go b/plumbing/storer/reference.go
index d821ecf..32265fe 100644
--- a/plumbing/storer/reference.go
+++ b/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,
 	}