Added support for annotated tags

Author: JoshuaSjoding

repository.go

@@ -110,6 +110,26 @@ func (r *Repository) Commits() *CommitIter {
 	return NewCommitIter(r, r.Storage.Iter(core.CommitObject))
 }
 
+// Tag returns a tag with the given hash.
+func (r *Repository) Tag(h core.Hash) (*Tag, error) {
+	obj, err := r.Storage.Get(h)
+	if err != nil {
+		if err == core.ObjectNotFoundErr {
+			return nil, ObjectNotFoundErr
+		}
+		return nil, err
+	}
+
+	tag := &Tag{r: r}
+	return tag, tag.Decode(obj)
+}
+
+// Tags returns a TagIter that can step through all of the annotated tags
+// in the repository.
+func (r *Repository) Tags() *TagIter {
+	return NewTagIter(r, r.Storage.Iter(core.TagObject))
+}
+
 // Tree return the tree with the given hash
 func (r *Repository) Tree(h core.Hash) (*Tree, error) {
 	obj, err := r.Storage.Get(h)

repository_test.go

@@ -1,16 +1,24 @@
 package git
 
 import (
+	"fmt"
+
 	"gopkg.in/src-d/go-git.v3/clients/http"
 	"gopkg.in/src-d/go-git.v3/core"
 
 	. "gopkg.in/check.v1"
 )
 
-type SuiteRepository struct{}
+type SuiteRepository struct {
+	repos map[string]*Repository
+}
 
 var _ = Suite(&SuiteRepository{})
 
+func (s *SuiteRepository) SetUpTest(c *C) {
+	s.repos = unpackFixtures(c, tagFixtures)
+}
+
 func (s *SuiteRepository) TestNewRepository(c *C) {
 	r, err := NewRepository(RepositoryFixture, nil)
 	c.Assert(err, IsNil)
@@ -77,6 +85,28 @@ func (s *SuiteRepository) TestCommits(c *C) {
 	c.Assert(count, Equals, 8)
 }
 
+func (s *SuiteRepository) TestTag(c *C) {
+	for i, t := range tagTests {
+		r, ok := s.repos[t.repo]
+		c.Assert(ok, Equals, true)
+		k := 0
+		for hash, expected := range t.tags {
+			tag, err := r.Tag(core.NewHash(hash))
+			c.Assert(err, IsNil)
+			testTagExpected(c, tag, expected, fmt.Sprintf("subtest %d, tag %d: ", i, k))
+			k++
+		}
+	}
+}
+
+func (s *SuiteRepository) TestTags(c *C) {
+	for i, t := range tagTests {
+		r, ok := s.repos[t.repo]
+		c.Assert(ok, Equals, true)
+		testTagIter(c, r.Tags(), t.tags, fmt.Sprintf("subtest %d, ", i))
+	}
+}
+
 func (s *SuiteRepository) TestCommitIterClosePanic(c *C) {
 	r, err := NewRepository(RepositoryFixture, nil)
 	r.Remotes["origin"].upSrv = &MockGitUploadPackService{}

storage/memory/storage.go

@@ -14,6 +14,7 @@ type ObjectStorage struct {
 	Commits map[core.Hash]core.Object
 	Trees   map[core.Hash]core.Object
 	Blobs   map[core.Hash]core.Object
+	Tags    map[core.Hash]core.Object
 }
 
 // NewObjectStorage returns a new empty ObjectStorage
@@ -23,6 +24,7 @@ func NewObjectStorage() *ObjectStorage {
 		Commits: make(map[core.Hash]core.Object, 0),
 		Trees:   make(map[core.Hash]core.Object, 0),
 		Blobs:   make(map[core.Hash]core.Object, 0),
+		Tags:    make(map[core.Hash]core.Object, 0),
 	}
 }
 
@@ -43,6 +45,8 @@ func (o *ObjectStorage) Set(obj core.Object) (core.Hash, error) {
 		o.Trees[h] = o.Objects[h]
 	case core.BlobObject:
 		o.Blobs[h] = o.Objects[h]
+	case core.TagObject:
+		o.Tags[h] = o.Objects[h]
 	default:
 		return h, ErrUnsupportedObjectType
 	}
@@ -70,6 +74,8 @@ func (o *ObjectStorage) Iter(t core.ObjectType) core.ObjectIter {
 		series = flattenObjectMap(o.Trees)
 	case core.BlobObject:
 		series = flattenObjectMap(o.Blobs)
+	case core.TagObject:
+		series = flattenObjectMap(o.Tags)
 	}
 	return core.NewObjectSliceIter(series)
 }

tag.go

@@ -0,0 +1,135 @@
+package git
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+
+	"gopkg.in/src-d/go-git.v3/core"
+)
+
+// Tag represents an annotated tag object. It points to a single git object of
+// any type, but tags typically are applied to commit or blob objects. It
+// provides a reference that associates the target with a tag name. It also
+// contains meta-information about the tag, including the tagger, tag date and
+// message.
+//
+// https://git-scm.com/book/en/v2/Git-Internals-Git-References#Tags
+type Tag struct {
+	Hash    core.Hash
+	Type    core.ObjectType
+	Name    string
+	Tagger  Signature
+	Message string
+
+	object core.Hash
+	r      *Repository
+}
+
+// Decode transforms a core.Object into a Tag struct.
+func (t *Tag) Decode(o core.Object) error {
+	if o.Type() != core.TagObject {
+		return ErrUnsupportedObject
+	}
+
+	t.Hash = o.Hash()
+
+	r := bufio.NewReader(o.Reader())
+	for {
+		line, err := r.ReadSlice('\n')
+		if err != nil && err != io.EOF {
+			return err
+		}
+
+		line = bytes.TrimSpace(line)
+		if len(line) == 0 {
+			break // Start of message
+		}
+
+		split := bytes.SplitN(line, []byte{' '}, 2)
+		switch string(split[0]) {
+		case "object":
+			t.object = core.NewHash(string(split[1]))
+		case "type":
+			t.Type, err = core.ParseObjectType(string(split[1]))
+			if err != nil {
+				return err
+			}
+		case "tag":
+			t.Name = string(split[1])
+		case "tagger":
+			t.Tagger.Decode(split[1])
+		}
+
+		if err == io.EOF {
+			return nil
+		}
+	}
+
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	t.Message = string(data)
+
+	return nil
+}
+
+// Commit returns the commit pointed to by the tag. If the tag points to a
+// different type of object an error will be returned.
+func (t *Tag) Commit() (*Commit, error) {
+	return t.r.Commit(t.object)
+}
+
+// Tree returns the tree pointed to by the tag. If the tag points to a
+// different type of object an error will be returned.
+func (t *Tag) Tree() (*Tree, error) {
+	// TODO: If the tag is of type commit, follow the commit to its tree?
+	return t.r.Tree(t.object)
+}
+
+// TODO: Add support for retrieving blobs? We don't have a type for that
+//       currently.
+
+// Object returns the object pointed to by the tag.
+func (t *Tag) Object() (core.Object, error) {
+	return t.r.Storage.Get(t.object)
+}
+
+// String returns the meta information contained in the tag as a formatted
+// string.
+func (t *Tag) String() string {
+	return fmt.Sprintf(
+		"%s %s\nObject: %s\nType: %s\nTag: %s\nTagger: %s\nDate:   %s\n",
+		core.TagObject, t.Hash, t.object, t.Type, t.Name, t.Tagger.String(), t.Tagger.When,
+	)
+}
+
+// TagIter provides an iterator for a set of tags.
+type TagIter struct {
+	core.ObjectIter
+	r *Repository
+}
+
+// NewTagIter returns a new TagIter for the given Repository and ObjectIter.
+func NewTagIter(r *Repository, iter core.ObjectIter) *TagIter {
+	return &TagIter{iter, r}
+}
+
+// Next moves the iterator to the next tag and returns a pointer to it. If it
+// has reached the end of the set it will return io.EOF.
+func (iter *TagIter) Next() (*Tag, error) {
+	obj, err := iter.ObjectIter.Next()
+	if err != nil {
+		return nil, err
+	}
+
+	tag := &Tag{r: iter.r}
+	return tag, tag.Decode(obj)
+}
+
+// Close releases any resources used by the iterator.
+func (iter *TagIter) Close() {
+}