14 files changed, 873 insertions, 31 deletions
diff --git a/plumbing/object/commit.go b/plumbing/object/commit.go
index e254342..6b50934 100644
--- a/plumbing/object/commit.go
+++ b/plumbing/object/commit.go
@@ -76,8 +76,8 @@ func (c *Commit) Tree() (*Tree, error) {
 	return GetTree(c.s, c.TreeHash)
 }
 
-// Patch returns the Patch between the actual commit and the provided one.
-// Error will be return if context expires. Provided context must be non-nil
+// PatchContext returns the Patch between the actual commit and the provided one.
+// Error will be return if context expires. Provided context must be non-nil.
 func (c *Commit) PatchContext(ctx context.Context, to *Commit) (*Patch, error) {
 	fromTree, err := c.Tree()
 	if err != nil {
@@ -171,7 +171,9 @@ func (c *Commit) Decode(o plumbing.EncodedObject) (err error) {
 	}
 	defer ioutil.CheckClose(reader, &err)
 
-	r := bufio.NewReader(reader)
+	r := bufPool.Get().(*bufio.Reader)
+	defer bufPool.Put(r)
+	r.Reset(reader)
 
 	var message bool
 	var pgpsig bool
@@ -233,6 +235,11 @@ func (b *Commit) Encode(o plumbing.EncodedObject) error {
 	return b.encode(o, true)
 }
 
+// EncodeWithoutSignature export a Commit into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).
+func (b *Commit) EncodeWithoutSignature(o plumbing.EncodedObject) error {
+	return b.encode(o, false)
+}
+
 func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 	o.SetType(plumbing.CommitObject)
 	w, err := o.Writer()
@@ -291,25 +298,33 @@ func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 	return err
 }
 
-// Stats shows the status of commit.
+// Stats returns the stats of a commit.
 func (c *Commit) Stats() (FileStats, error) {
-	// Get the previous commit.
-	ci := c.Parents()
-	parentCommit, err := ci.Next()
+	return c.StatsContext(context.Background())
+}
+
+// StatsContext returns the stats of a commit. Error will be return if context
+// expires. Provided context must be non-nil.
+func (c *Commit) StatsContext(ctx context.Context) (FileStats, error) {
+	fromTree, err := c.Tree()
 	if err != nil {
-		if err == io.EOF {
-			emptyNoder := treeNoder{}
-			parentCommit = &Commit{
-				Hash: emptyNoder.hash,
-				// TreeHash: emptyNoder.parent.Hash,
-				s: c.s,
-			}
-		} else {
+		return nil, err
+	}
+
+	toTree := &Tree{}
+	if c.NumParents() != 0 {
+		firstParent, err := c.Parents().Next()
+		if err != nil {
+			return nil, err
+		}
+
+		toTree, err = firstParent.Tree()
+		if err != nil {
 			return nil, err
 		}
 	}
 
-	patch, err := parentCommit.Patch(c)
+	patch, err := toTree.PatchContext(ctx, fromTree)
 	if err != nil {
 		return nil, err
 	}
@@ -339,7 +354,7 @@ func (c *Commit) Verify(armoredKeyRing string) (*openpgp.Entity, error) {
 
 	encoded := &plumbing.MemoryObject{}
 	// Encode commit components, excluding signature and get a reader object.
-	if err := c.encode(encoded, false); err != nil {
+	if err := c.EncodeWithoutSignature(encoded); err != nil {
 		return nil, err
 	}
 	er, err := encoded.Reader()
diff --git a/plumbing/object/commit_stats_test.go b/plumbing/object/commit_stats_test.go
new file mode 100644
index 0000000..2fb3f08
--- /dev/null
+++ b/plumbing/object/commit_stats_test.go
@@ -0,0 +1,95 @@
+package object_test
+
+import (
+	"context"
+	"time"
+
+	"gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-git.v4/storage/memory"
+
+	. "gopkg.in/check.v1"
+	"gopkg.in/src-d/go-billy.v4/memfs"
+	"gopkg.in/src-d/go-billy.v4/util"
+	"gopkg.in/src-d/go-git-fixtures.v3"
+)
+
+type CommitStatsSuite struct {
+	fixtures.Suite
+}
+
+var _ = Suite(&CommitStatsSuite{})
+
+func (s *CommitStatsSuite) TestStats(c *C) {
+	r, hash := s.writeHisotry(c, []byte("foo\n"), []byte("foo\nbar\n"))
+
+	aCommit, err := r.CommitObject(hash)
+	c.Assert(err, IsNil)
+
+	fileStats, err := aCommit.StatsContext(context.Background())
+	c.Assert(err, IsNil)
+
+	c.Assert(fileStats[0].Name, Equals, "foo")
+	c.Assert(fileStats[0].Addition, Equals, 1)
+	c.Assert(fileStats[0].Deletion, Equals, 0)
+	c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n")
+}
+
+func (s *CommitStatsSuite) TestStats_RootCommit(c *C) {
+	r, hash := s.writeHisotry(c, []byte("foo\n"))
+
+	aCommit, err := r.CommitObject(hash)
+	c.Assert(err, IsNil)
+
+	fileStats, err := aCommit.Stats()
+	c.Assert(err, IsNil)
+
+	c.Assert(fileStats, HasLen, 1)
+	c.Assert(fileStats[0].Name, Equals, "foo")
+	c.Assert(fileStats[0].Addition, Equals, 1)
+	c.Assert(fileStats[0].Deletion, Equals, 0)
+	c.Assert(fileStats[0].String(), Equals, " foo | 1 +\n")
+}
+
+func (s *CommitStatsSuite) TestStats_WithoutNewLine(c *C) {
+	r, hash := s.writeHisotry(c, []byte("foo\nbar"), []byte("foo\nbar\n"))
+
+	aCommit, err := r.CommitObject(hash)
+	c.Assert(err, IsNil)
+
+	fileStats, err := aCommit.Stats()
+	c.Assert(err, IsNil)
+
+	c.Assert(fileStats[0].Name, Equals, "foo")
+	c.Assert(fileStats[0].Addition, Equals, 1)
+	c.Assert(fileStats[0].Deletion, Equals, 1)
+	c.Assert(fileStats[0].String(), Equals, " foo | 2 +-\n")
+}
+
+func (s *CommitStatsSuite) writeHisotry(c *C, files ...[]byte) (*git.Repository, plumbing.Hash) {
+	cm := &git.CommitOptions{
+		Author: &object.Signature{Name: "Foo", Email: "foo@example.local", When: time.Now()},
+	}
+
+	fs := memfs.New()
+	r, err := git.Init(memory.NewStorage(), fs)
+	c.Assert(err, IsNil)
+
+	w, err := r.Worktree()
+	c.Assert(err, IsNil)
+
+	var hash plumbing.Hash
+	for _, content := range files {
+		util.WriteFile(fs, "foo", content, 0644)
+
+		_, err = w.Add("foo")
+		c.Assert(err, IsNil)
+
+		hash, err = w.Commit("foo\n", cm)
+		c.Assert(err, IsNil)
+
+	}
+
+	return r, hash
+}
diff --git a/plumbing/object/commit_test.go b/plumbing/object/commit_test.go
index c9acf42..957e7d6 100644
--- a/plumbing/object/commit_test.go
+++ b/plumbing/object/commit_test.go
@@ -4,14 +4,15 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"io/ioutil"
 	"strings"
 	"time"
 
+	fixtures "gopkg.in/src-d/go-git-fixtures.v3"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/cache"
 
 	. "gopkg.in/check.v1"
-	"gopkg.in/src-d/go-git-fixtures.v3"
 	"gopkg.in/src-d/go-git.v4/storage/filesystem"
 )
 
@@ -495,3 +496,23 @@ func (s *SuiteCommit) TestMalformedHeader(c *C) {
 	err = decoded.Decode(encoded)
 	c.Assert(err, IsNil)
 }
+
+func (s *SuiteCommit) TestEncodeWithoutSignature(c *C) {
+	//Similar to TestString since no signature
+	encoded := &plumbing.MemoryObject{}
+	err := s.Commit.EncodeWithoutSignature(encoded)
+	c.Assert(err, IsNil)
+	er, err := encoded.Reader()
+	c.Assert(err, IsNil)
+	payload, err := ioutil.ReadAll(er)
+	c.Assert(err, IsNil)
+
+	c.Assert(string(payload), Equals, ""+
+		"tree eba74343e2f15d62adedfd8c883ee0262b5c8021\n"+
+		"parent 35e85108805c84807bc66a02d91535e1e24b38b9\n"+
+		"parent a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69\n"+
+		"author Máximo Cuadros Ortiz <mcuadros@gmail.com> 1427802494 +0200\n"+
+		"committer Máximo Cuadros Ortiz <mcuadros@gmail.com> 1427802494 +0200\n"+
+		"\n"+
+		"Merge branch 'master' of github.com:tyba/git-fixture\n")
+}
diff --git a/plumbing/object/commitgraph/commitnode.go b/plumbing/object/commitgraph/commitnode.go
new file mode 100644
index 0000000..e218d32
--- /dev/null
+++ b/plumbing/object/commitgraph/commitnode.go
@@ -0,0 +1,98 @@
+package commitgraph
+
+import (
+	"io"
+	"time"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+)
+
+// CommitNode is generic interface encapsulating a lightweight commit object retrieved
+// from CommitNodeIndex
+type CommitNode interface {
+	// ID returns the Commit object id referenced by the commit graph node.
+	ID() plumbing.Hash
+	// Tree returns the Tree referenced by the commit graph node.
+	Tree() (*object.Tree, error)
+	// CommitTime returns the Commiter.When time of the Commit referenced by the commit graph node.
+	CommitTime() time.Time
+	// NumParents returns the number of parents in a commit.
+	NumParents() int
+	// ParentNodes return a CommitNodeIter for parents of specified node.
+	ParentNodes() CommitNodeIter
+	// ParentNode returns the ith parent of a commit.
+	ParentNode(i int) (CommitNode, error)
+	// ParentHashes returns hashes of the parent commits for a specified node
+	ParentHashes() []plumbing.Hash
+	// Generation returns the generation of the commit for reachability analysis.
+	// Objects with newer generation are not reachable from objects of older generation.
+	Generation() uint64
+	// Commit returns the full commit object from the node
+	Commit() (*object.Commit, error)
+}
+
+// CommitNodeIndex is generic interface encapsulating an index of CommitNode objects
+type CommitNodeIndex interface {
+	// Get returns a commit node from a commit hash
+	Get(hash plumbing.Hash) (CommitNode, error)
+}
+
+// CommitNodeIter is a generic closable interface for iterating over commit nodes.
+type CommitNodeIter interface {
+	Next() (CommitNode, error)
+	ForEach(func(CommitNode) error) error
+	Close()
+}
+
+// parentCommitNodeIter provides an iterator for parent commits from associated CommitNodeIndex.
+type parentCommitNodeIter struct {
+	node CommitNode
+	i    int
+}
+
+func newParentgraphCommitNodeIter(node CommitNode) CommitNodeIter {
+	return &parentCommitNodeIter{node, 0}
+}
+
+// Next moves the iterator to the next commit and returns a pointer to it. If
+// there are no more commits, it returns io.EOF.
+func (iter *parentCommitNodeIter) Next() (CommitNode, error) {
+	obj, err := iter.node.ParentNode(iter.i)
+	if err == object.ErrParentNotFound {
+		return nil, io.EOF
+	}
+	if err == nil {
+		iter.i++
+	}
+
+	return obj, err
+}
+
+// ForEach call the cb function for each commit contained on this iter until
+// an error appends 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 *parentCommitNodeIter) ForEach(cb func(CommitNode) error) error {
+	for {
+		obj, err := iter.Next()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+
+			return err
+		}
+
+		if err := cb(obj); err != nil {
+			if err == storer.ErrStop {
+				return nil
+			}
+
+			return err
+		}
+	}
+}
+
+func (iter *parentCommitNodeIter) Close() {
+}
diff --git a/plumbing/object/commitgraph/commitnode_graph.go b/plumbing/object/commitgraph/commitnode_graph.go
new file mode 100644
index 0000000..bd54e18
--- /dev/null
+++ b/plumbing/object/commitgraph/commitnode_graph.go
@@ -0,0 +1,131 @@
+package commitgraph
+
+import (
+	"fmt"
+	"time"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/commitgraph"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+)
+
+// graphCommitNode is a reduced representation of Commit as presented in the commit
+// graph file (commitgraph.Node). It is merely useful as an optimization for walking
+// the commit graphs.
+//
+// graphCommitNode implements the CommitNode interface.
+type graphCommitNode struct {
+	// Hash for the Commit object
+	hash plumbing.Hash
+	// Index of the node in the commit graph file
+	index int
+
+	commitData *commitgraph.CommitData
+	gci        *graphCommitNodeIndex
+}
+
+// graphCommitNodeIndex is an index that can load CommitNode objects from both the commit
+// graph files and the object store.
+//
+// graphCommitNodeIndex implements the CommitNodeIndex interface
+type graphCommitNodeIndex struct {
+	commitGraph commitgraph.Index
+	s           storer.EncodedObjectStorer
+}
+
+// NewGraphCommitNodeIndex returns CommitNodeIndex implementation that uses commit-graph
+// files as backing storage and falls back to object storage when necessary
+func NewGraphCommitNodeIndex(commitGraph commitgraph.Index, s storer.EncodedObjectStorer) CommitNodeIndex {
+	return &graphCommitNodeIndex{commitGraph, s}
+}
+
+func (gci *graphCommitNodeIndex) Get(hash plumbing.Hash) (CommitNode, error) {
+	// Check the commit graph first
+	parentIndex, err := gci.commitGraph.GetIndexByHash(hash)
+	if err == nil {
+		parent, err := gci.commitGraph.GetCommitDataByIndex(parentIndex)
+		if err != nil {
+			return nil, err
+		}
+
+		return &graphCommitNode{
+			hash:       hash,
+			index:      parentIndex,
+			commitData: parent,
+			gci:        gci,
+		}, nil
+	}
+
+	// Fallback to loading full commit object
+	commit, err := object.GetCommit(gci.s, hash)
+	if err != nil {
+		return nil, err
+	}
+
+	return &objectCommitNode{
+		nodeIndex: gci,
+		commit:    commit,
+	}, nil
+}
+
+func (c *graphCommitNode) ID() plumbing.Hash {
+	return c.hash
+}
+
+func (c *graphCommitNode) Tree() (*object.Tree, error) {
+	return object.GetTree(c.gci.s, c.commitData.TreeHash)
+}
+
+func (c *graphCommitNode) CommitTime() time.Time {
+	return c.commitData.When
+}
+
+func (c *graphCommitNode) NumParents() int {
+	return len(c.commitData.ParentIndexes)
+}
+
+func (c *graphCommitNode) ParentNodes() CommitNodeIter {
+	return newParentgraphCommitNodeIter(c)
+}
+
+func (c *graphCommitNode) ParentNode(i int) (CommitNode, error) {
+	if i < 0 || i >= len(c.commitData.ParentIndexes) {
+		return nil, object.ErrParentNotFound
+	}
+
+	parent, err := c.gci.commitGraph.GetCommitDataByIndex(c.commitData.ParentIndexes[i])
+	if err != nil {
+		return nil, err
+	}
+
+	return &graphCommitNode{
+		hash:       c.commitData.ParentHashes[i],
+		index:      c.commitData.ParentIndexes[i],
+		commitData: parent,
+		gci:        c.gci,
+	}, nil
+}
+
+func (c *graphCommitNode) ParentHashes() []plumbing.Hash {
+	return c.commitData.ParentHashes
+}
+
+func (c *graphCommitNode) Generation() uint64 {
+	// If the commit-graph file was generated with older Git version that
+	// set the generation to zero for every commit the generation assumption
+	// is still valid. It is just less useful.
+	return uint64(c.commitData.Generation)
+}
+
+func (c *graphCommitNode) Commit() (*object.Commit, error) {
+	return object.GetCommit(c.gci.s, c.hash)
+}
+
+func (c *graphCommitNode) String() string {
+	return fmt.Sprintf(
+		"%s %s\nDate:   %s",
+		plumbing.CommitObject, c.ID(),
+		c.CommitTime().Format(object.DateFormat),
+	)
+}
diff --git a/plumbing/object/commitgraph/commitnode_object.go b/plumbing/object/commitgraph/commitnode_object.go
new file mode 100644
index 0000000..2779a54
--- /dev/null
+++ b/plumbing/object/commitgraph/commitnode_object.go
@@ -0,0 +1,90 @@
+package commitgraph
+
+import (
+	"math"
+	"time"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+)
+
+// objectCommitNode is a representation of Commit as presented in the GIT object format.
+//
+// objectCommitNode implements the CommitNode interface.
+type objectCommitNode struct {
+	nodeIndex CommitNodeIndex
+	commit    *object.Commit
+}
+
+// NewObjectCommitNodeIndex returns CommitNodeIndex implementation that uses
+// only object storage to load the nodes
+func NewObjectCommitNodeIndex(s storer.EncodedObjectStorer) CommitNodeIndex {
+	return &objectCommitNodeIndex{s}
+}
+
+func (oci *objectCommitNodeIndex) Get(hash plumbing.Hash) (CommitNode, error) {
+	commit, err := object.GetCommit(oci.s, hash)
+	if err != nil {
+		return nil, err
+	}
+
+	return &objectCommitNode{
+		nodeIndex: oci,
+		commit:    commit,
+	}, nil
+}
+
+// objectCommitNodeIndex is an index that can load CommitNode objects only from the
+// object store.
+//
+// objectCommitNodeIndex implements the CommitNodeIndex interface
+type objectCommitNodeIndex struct {
+	s storer.EncodedObjectStorer
+}
+
+func (c *objectCommitNode) CommitTime() time.Time {
+	return c.commit.Committer.When
+}
+
+func (c *objectCommitNode) ID() plumbing.Hash {
+	return c.commit.ID()
+}
+
+func (c *objectCommitNode) Tree() (*object.Tree, error) {
+	return c.commit.Tree()
+}
+
+func (c *objectCommitNode) NumParents() int {
+	return c.commit.NumParents()
+}
+
+func (c *objectCommitNode) ParentNodes() CommitNodeIter {
+	return newParentgraphCommitNodeIter(c)
+}
+
+func (c *objectCommitNode) ParentNode(i int) (CommitNode, error) {
+	if i < 0 || i >= len(c.commit.ParentHashes) {
+		return nil, object.ErrParentNotFound
+	}
+
+	// Note: It's necessary to go through CommitNodeIndex here to ensure
+	// that if the commit-graph file covers only part of the history we
+	// start using it when that part is reached.
+	return c.nodeIndex.Get(c.commit.ParentHashes[i])
+}
+
+func (c *objectCommitNode) ParentHashes() []plumbing.Hash {
+	return c.commit.ParentHashes
+}
+
+func (c *objectCommitNode) Generation() uint64 {
+	// Commit nodes representing objects outside of the commit graph can never
+	// be reached by objects from the commit-graph thus we return the highest
+	// possible value.
+	return math.MaxUint64
+}
+
+func (c *objectCommitNode) Commit() (*object.Commit, error) {
+	return c.commit, nil
+}
diff --git a/plumbing/object/commitgraph/commitnode_test.go b/plumbing/object/commitgraph/commitnode_test.go
new file mode 100644
index 0000000..954f873
--- /dev/null
+++ b/plumbing/object/commitgraph/commitnode_test.go
@@ -0,0 +1,147 @@
+package commitgraph
+
+import (
+	"path"
+	"testing"
+
+	. "gopkg.in/check.v1"
+	fixtures "gopkg.in/src-d/go-git-fixtures.v3"
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/cache"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/commitgraph"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
+	"gopkg.in/src-d/go-git.v4/storage/filesystem"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type CommitNodeSuite struct {
+	fixtures.Suite
+}
+
+var _ = Suite(&CommitNodeSuite{})
+
+func unpackRepositry(f *fixtures.Fixture) *filesystem.Storage {
+	storer := filesystem.NewStorage(f.DotGit(), cache.NewObjectLRUDefault())
+	p := f.Packfile()
+	defer p.Close()
+	packfile.UpdateObjectStorage(storer, p)
+	return storer
+}
+
+func testWalker(c *C, nodeIndex CommitNodeIndex) {
+	head, err := nodeIndex.Get(plumbing.NewHash("b9d69064b190e7aedccf84731ca1d917871f8a1c"))
+	c.Assert(err, IsNil)
+
+	iter := NewCommitNodeIterCTime(
+		head,
+		nil,
+		nil,
+	)
+
+	var commits []CommitNode
+	iter.ForEach(func(c CommitNode) error {
+		commits = append(commits, c)
+		return nil
+	})
+
+	c.Assert(commits, HasLen, 9)
+
+	expected := []string{
+		"b9d69064b190e7aedccf84731ca1d917871f8a1c",
+		"6f6c5d2be7852c782be1dd13e36496dd7ad39560",
+		"a45273fe2d63300e1962a9e26a6b15c276cd7082",
+		"c0edf780dd0da6a65a7a49a86032fcf8a0c2d467",
+		"bb13916df33ed23004c3ce9ed3b8487528e655c1",
+		"03d2c021ff68954cf3ef0a36825e194a4b98f981",
+		"ce275064ad67d51e99f026084e20827901a8361c",
+		"e713b52d7e13807e87a002e812041f248db3f643",
+		"347c91919944a68e9413581a1bc15519550a3afe",
+	}
+	for i, commit := range commits {
+		c.Assert(commit.ID().String(), Equals, expected[i])
+	}
+}
+
+func testParents(c *C, nodeIndex CommitNodeIndex) {
+	merge3, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
+	c.Assert(err, IsNil)
+
+	var parents []CommitNode
+	merge3.ParentNodes().ForEach(func(c CommitNode) error {
+		parents = append(parents, c)
+		return nil
+	})
+
+	c.Assert(parents, HasLen, 3)
+
+	expected := []string{
+		"ce275064ad67d51e99f026084e20827901a8361c",
+		"bb13916df33ed23004c3ce9ed3b8487528e655c1",
+		"a45273fe2d63300e1962a9e26a6b15c276cd7082",
+	}
+	for i, parent := range parents {
+		c.Assert(parent.ID().String(), Equals, expected[i])
+	}
+}
+
+func testCommitAndTree(c *C, nodeIndex CommitNodeIndex) {
+	merge3node, err := nodeIndex.Get(plumbing.NewHash("6f6c5d2be7852c782be1dd13e36496dd7ad39560"))
+	c.Assert(err, IsNil)
+	merge3commit, err := merge3node.Commit()
+	c.Assert(err, IsNil)
+	c.Assert(merge3node.ID().String(), Equals, merge3commit.ID().String())
+	tree, err := merge3node.Tree()
+	c.Assert(err, IsNil)
+	c.Assert(tree.ID().String(), Equals, merge3commit.TreeHash.String())
+}
+
+func (s *CommitNodeSuite) TestObjectGraph(c *C) {
+	f := fixtures.ByTag("commit-graph").One()
+	storer := unpackRepositry(f)
+
+	nodeIndex := NewObjectCommitNodeIndex(storer)
+	testWalker(c, nodeIndex)
+	testParents(c, nodeIndex)
+	testCommitAndTree(c, nodeIndex)
+}
+
+func (s *CommitNodeSuite) TestCommitGraph(c *C) {
+	f := fixtures.ByTag("commit-graph").One()
+	storer := unpackRepositry(f)
+	reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph"))
+	c.Assert(err, IsNil)
+	defer reader.Close()
+	index, err := commitgraph.OpenFileIndex(reader)
+	c.Assert(err, IsNil)
+
+	nodeIndex := NewGraphCommitNodeIndex(index, storer)
+	testWalker(c, nodeIndex)
+	testParents(c, nodeIndex)
+	testCommitAndTree(c, nodeIndex)
+}
+
+func (s *CommitNodeSuite) TestMixedGraph(c *C) {
+	f := fixtures.ByTag("commit-graph").One()
+	storer := unpackRepositry(f)
+
+	// Take the commit-graph file and copy it to memory index without the last commit
+	reader, err := storer.Filesystem().Open(path.Join("objects", "info", "commit-graph"))
+	c.Assert(err, IsNil)
+	defer reader.Close()
+	fileIndex, err := commitgraph.OpenFileIndex(reader)
+	c.Assert(err, IsNil)
+	memoryIndex := commitgraph.NewMemoryIndex()
+	for i, hash := range fileIndex.Hashes() {
+		if hash.String() != "b9d69064b190e7aedccf84731ca1d917871f8a1c" {
+			node, err := fileIndex.GetCommitDataByIndex(i)
+			c.Assert(err, IsNil)
+			memoryIndex.Add(hash, node)
+		}
+	}
+
+	nodeIndex := NewGraphCommitNodeIndex(memoryIndex, storer)
+	testWalker(c, nodeIndex)
+	testParents(c, nodeIndex)
+	testCommitAndTree(c, nodeIndex)
+}
diff --git a/plumbing/object/commitgraph/commitnode_walker_ctime.go b/plumbing/object/commitgraph/commitnode_walker_ctime.go
new file mode 100644
index 0000000..f6a1b6a
--- /dev/null
+++ b/plumbing/object/commitgraph/commitnode_walker_ctime.go
@@ -0,0 +1,105 @@
+package commitgraph
+
+import (
+	"io"
+
+	"github.com/emirpasic/gods/trees/binaryheap"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+)
+
+type commitNodeIteratorByCTime struct {
+	heap         *binaryheap.Heap
+	seenExternal map[plumbing.Hash]bool
+	seen         map[plumbing.Hash]bool
+}
+
+// NewCommitNodeIterCTime returns a CommitNodeIter that walks the commit history,
+// starting at the given commit and visiting its parents while preserving Committer Time order.
+// this appears to be the closest order to `git log`
+// The given callback will be called for each visited commit. Each commit will
+// be visited only once. If the callback returns an error, walking will stop
+// and will return the error. Other errors might be returned if the history
+// cannot be traversed (e.g. missing objects). Ignore allows to skip some
+// commits from being iterated.
+func NewCommitNodeIterCTime(
+	c CommitNode,
+	seenExternal map[plumbing.Hash]bool,
+	ignore []plumbing.Hash,
+) CommitNodeIter {
+	seen := make(map[plumbing.Hash]bool)
+	for _, h := range ignore {
+		seen[h] = true
+	}
+
+	heap := binaryheap.NewWith(func(a, b interface{}) int {
+		if a.(CommitNode).CommitTime().Before(b.(CommitNode).CommitTime()) {
+			return 1
+		}
+		return -1
+	})
+
+	heap.Push(c)
+
+	return &commitNodeIteratorByCTime{
+		heap:         heap,
+		seenExternal: seenExternal,
+		seen:         seen,
+	}
+}
+
+func (w *commitNodeIteratorByCTime) Next() (CommitNode, error) {
+	var c CommitNode
+	for {
+		cIn, ok := w.heap.Pop()
+		if !ok {
+			return nil, io.EOF
+		}
+		c = cIn.(CommitNode)
+		cID := c.ID()
+
+		if w.seen[cID] || w.seenExternal[cID] {
+			continue
+		}
+
+		w.seen[cID] = true
+
+		for i, h := range c.ParentHashes() {
+			if w.seen[h] || w.seenExternal[h] {
+				continue
+			}
+			pc, err := c.ParentNode(i)
+			if err != nil {
+				return nil, err
+			}
+			w.heap.Push(pc)
+		}
+
+		return c, nil
+	}
+}
+
+func (w *commitNodeIteratorByCTime) ForEach(cb func(CommitNode) error) error {
+	for {
+		c, err := w.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		err = cb(c)
+		if err == storer.ErrStop {
+			break
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (w *commitNodeIteratorByCTime) Close() {}
diff --git a/plumbing/object/commitgraph/doc.go b/plumbing/object/commitgraph/doc.go
new file mode 100644
index 0000000..0a55ad5
--- /dev/null
+++ b/plumbing/object/commitgraph/doc.go
@@ -0,0 +1,7 @@
+// Package commitgraph provides an interface for efficient traversal over Git
+// commit graph either through the regular object storage, or optionally with
+// the index stored in commit-graph file (Git 2.18+).
+//
+// The API and functionality of this package are considered EXPERIMENTAL and is
+// not considered stable nor production ready.
+package commitgraph
diff --git a/plumbing/object/common.go b/plumbing/object/common.go
new file mode 100644
index 0000000..3591f5f
--- /dev/null
+++ b/plumbing/object/common.go
@@ -0,0 +1,12 @@
+package object
+
+import (
+	"bufio"
+	"sync"
+)
+
+var bufPool = sync.Pool{
+	New: func() interface{} {
+		return bufio.NewReader(nil)
+	},
+}
diff --git a/plumbing/object/patch.go b/plumbing/object/patch.go
index adeaccb..1efd0b1 100644
--- a/plumbing/object/patch.go
+++ b/plumbing/object/patch.go
@@ -320,11 +320,22 @@ func getFileStatsFromFilePatches(filePatches []fdiff.FilePatch) FileStats {
 		}
 
 		for _, chunk := range fp.Chunks() {
+			s := chunk.Content()
+			if len(s) == 0 {
+				continue
+			}
+
 			switch chunk.Type() {
 			case fdiff.Add:
-				cs.Addition += strings.Count(chunk.Content(), "\n")
+				cs.Addition += strings.Count(s, "\n")
+				if s[len(s)-1] != '\n' {
+					cs.Addition++
+				}
 			case fdiff.Delete:
-				cs.Deletion += strings.Count(chunk.Content(), "\n")
+				cs.Deletion += strings.Count(s, "\n")
+				if s[len(s)-1] != '\n' {
+					cs.Deletion++
+				}
 			}
 		}
 
diff --git a/plumbing/object/tag.go b/plumbing/object/tag.go
index 03749f9..9ee5509 100644
--- a/plumbing/object/tag.go
+++ b/plumbing/object/tag.go
@@ -93,7 +93,9 @@ func (t *Tag) Decode(o plumbing.EncodedObject) (err error) {
 	}
 	defer ioutil.CheckClose(reader, &err)
 
-	r := bufio.NewReader(reader)
+	r := bufPool.Get().(*bufio.Reader)
+	defer bufPool.Put(r)
+	r.Reset(reader)
 	for {
 		var line []byte
 		line, err = r.ReadBytes('\n')
@@ -141,7 +143,7 @@ func (t *Tag) Decode(o plumbing.EncodedObject) (err error) {
 			if pgpsig {
 				if bytes.Contains(l, []byte(endpgp)) {
 					t.PGPSignature += endpgp + "\n"
-					pgpsig = false
+					break
 				} else {
 					t.PGPSignature += string(l) + "\n"
 				}
@@ -169,6 +171,11 @@ func (t *Tag) Encode(o plumbing.EncodedObject) error {
 	return t.encode(o, true)
 }
 
+// EncodeWithoutSignature export a Tag into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).
+func (t *Tag) EncodeWithoutSignature(o plumbing.EncodedObject) error {
+	return t.encode(o, false)
+}
+
 func (t *Tag) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 	o.SetType(plumbing.TagObject)
 	w, err := o.Writer()
@@ -289,7 +296,7 @@ func (t *Tag) Verify(armoredKeyRing string) (*openpgp.Entity, error) {
 
 	encoded := &plumbing.MemoryObject{}
 	// Encode tag components, excluding signature and get a reader object.
-	if err := t.encode(encoded, false); err != nil {
+	if err := t.EncodeWithoutSignature(encoded); err != nil {
 		return nil, err
 	}
 	er, err := encoded.Reader()
diff --git a/plumbing/object/tag_test.go b/plumbing/object/tag_test.go
index 59c28b0..addec8d 100644
--- a/plumbing/object/tag_test.go
+++ b/plumbing/object/tag_test.go
@@ -3,16 +3,17 @@ package object
 import (
 	"fmt"
 	"io"
+	"io/ioutil"
 	"strings"
 	"time"
 
+	fixtures "gopkg.in/src-d/go-git-fixtures.v3"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/cache"
 	"gopkg.in/src-d/go-git.v4/storage/filesystem"
 	"gopkg.in/src-d/go-git.v4/storage/memory"
 
 	. "gopkg.in/check.v1"
-	"gopkg.in/src-d/go-git-fixtures.v3"
 )
 
 type TagSuite struct {
@@ -375,3 +376,96 @@ sYyf9RfOnw/KUFAQbdtvLx3ikODQC+D3KBtuKI9ISHQfgw==
 	_, ok := e.Identities["Sunny <me@darkowlzz.space>"]
 	c.Assert(ok, Equals, true)
 }
+
+func (s *TagSuite) TestDecodeAndVerify(c *C) {
+	objectText := `object 7dba2f128d1298e385b28b56a7e1c579779eac82
+type commit
+tag v1.6
+tagger Filip Navara <filip.navara@gmail.com> 1555269936 +0200
+
+Hello
+
+world
+
+boo
+-----BEGIN PGP SIGNATURE-----
+
+iQEzBAABCAAdFiEEdRIEYXeoLk1t7PBDqeqoMkraaZ4FAlyziT4ACgkQqeqoMkra
+aZ502wgAxG4+69l8PYfq45u1R3CCf4x0m5WwcYwvaa4ang0S9mExh/C32NHnpM/V
+DbqMpAlFvBlixOsZ8FNWaM8VXnvRWyx64E6WnInxjx9+Wgv2fy5P1N5rtpvi+S2V
+iGc0RQJlIloqXr7qPYDrwcbgg6AFg9EPhgJxLyizglu9nYvNsH1InaPXMjzgGX8+
+3irnIYEMIrLcKPrCyHo4Q6gdBjEEBF8hFclPJ8OwXBPc6uNYjnDYx0me9TTQYqoG
+oGgO/rADU9fy4c/Q1ZQpocba/ca6abRJ9LAx9VXFOSlQrMKLgHCYfqU/MAZXKcZM
+6XXOL4+8Z3FJN6CapZKX7cdYB8LJnw==
+=t5Px
+-----END PGP SIGNATURE-----
+
+`
+
+	armoredKeyRing := `
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQENBFyzedYBCADN3lVNUNkrjn0kfwKAxGQOI8a1977UaIq9ktFg+Uv4Jyq2Y59L
+ZVx2WYk1iDaRhxhv203HV//CA/Hr4IoPjK53qAkg2bPyi8UuDbL+gU+4Z+IiSeXd
+18ZcAbcYt188PWoUq9/82ofO8EiaBbUEEZJjEegLDtX8gxBDG0aI3Yj4Txj73mno
+w6+E5HDkgPElmH3oNQcr8iK9U2Kuj+ZAHkzbWL++gDCPiLl2eWf0Cr1nlVsv6YLa
+Fsn5vjMGT3dMJFc78ZqCHOeyYK7KHjW1EjzgqeG2eJVay+ZQ5zEx4Fp/dL0RdUSV
+U7zslRiraaPxshdhYOjQ0o72RpSkP1G6+8OhABEBAAG0JUZpbGlwIE5hdmFyYSA8
+ZmlsaXAubmF2YXJhQGdtYWlsLmNvbT6JAVQEEwEIAD4WIQR1EgRhd6guTW3s8EOp
+6qgyStppngUCXLN51gIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAK
+CRCp6qgyStppnlzjB/sFu7HqJrTRsnHsoWo2+nDeicXnR0VAhiLvv7uRRw4i90FJ
+0zDwjAmIH+po6vPffWRMcWOFVvAwZCX7/XcvDNF9OupFj/aold334+VVN0ha47IQ
+g44bJZie9mvLagEsqUXggpKQjd414Tk08aUucfaN9RFJIOGCwF05j2eXOBGR2HTe
+FLq3obeObryEPf0c8N/nw4RQ8OOcq98gxiHx5Gk+nLCcJCTvOlc9ULqpJ2a6cZry
+kxgSOI9dd74ilRQdpfPvoEeEGSqkY+daf+dhgSMT2mII0UJ6qQeY0DpCZZNsL8dr
+PxR4SPRlzLBuJIpnHY21ebOqwOPOLjzR+J2RBufkuQENBFyzedYBCADTCglXrST6
+DRz7Uq3zrrrzdCchHH0/+LgYOEoGs82UvdFfigQYGTydmXz27bHKfWNfGIa9IlLF
+MhasFueCnKnmfVxnlINRdyAXv7Tmx4mSjuCEmGkvM1nPpdhxWXptnVMqhQMddiMO
+N55bElDK2ftPc2s4dBmTItXXbet2kFZiv7MZBZpA4eRAHj5DDSwl8pnQArU50RDZ
+q3qYKvAP/z2SLjekcOFtMhZ9BXMvwAW4FWV0ztpfP3LvUUb0T7fSo5cXlm/0eqwa
+MUrUlbbwJMDg1/wJ3pbKhZlP+xXNLj5UE86TtfqNqaohOcIBdCsdTUQgbkLVlibP
+JmZH7lGDhvi3ABEBAAGJATwEGAEIACYWIQR1EgRhd6guTW3s8EOp6qgyStppngUC
+XLN51gIbDAUJA8JnAAAKCRCp6qgyStppntq1B/9bmw4XjEm5KyXwWnlAVGr8skXY
+KIJr6drUOOwQzl7rxsJRjUsFdX0IjaZwx303G/23eQMIvVkoaWpHrT0Y7EsTQ55x
++GSuANhEzobks4spzQ66VW9FHRlRr5wg5PTwWnGtV/5QVSTY/zeC9R/AFUJFsDWe
+tgHlNrb6MWx5EtypZDpAkubAMvD/QoZHX0oPXYAA2CugD4uSdzjf6Ys3xUuwjKKG
+5hvimAg1/Hympq71Znb6Ec1m4ZM22Br7dcWHIX2GWfDPyRG+rYPu4Fk9KKAD4FRz
+HdzbB2ak/HxIeCqmHVlmUqa+WfTMUJcsgOm3/ZFPCSoL6l0bz9Z1XVbiyD03
+=+gC9
+-----END PGP PUBLIC KEY BLOCK-----
+`
+
+	tagEncodedObject := &plumbing.MemoryObject{}
+
+	_, err := tagEncodedObject.Write([]byte(objectText))
+	tagEncodedObject.SetType(plumbing.TagObject)
+	c.Assert(err, IsNil)
+
+	tag := &Tag{}
+	err = tag.Decode(tagEncodedObject)
+	c.Assert(err, IsNil)
+
+	_, err = tag.Verify(armoredKeyRing)
+	c.Assert(err, IsNil)
+}
+
+func (s *TagSuite) TestEncodeWithoutSignature(c *C) {
+	//Similar to TestString since no signature
+	encoded := &plumbing.MemoryObject{}
+	tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
+	err := tag.EncodeWithoutSignature(encoded)
+	c.Assert(err, IsNil)
+	er, err := encoded.Reader()
+	c.Assert(err, IsNil)
+	payload, err := ioutil.ReadAll(er)
+	c.Assert(err, IsNil)
+
+	c.Assert(string(payload), Equals, ""+
+		"object f7b877701fbf855b44c0a9e86f3fdce2c298b07f\n"+
+		"type commit\n"+
+		"tag annotated-tag\n"+
+		"tagger Máximo Cuadros <mcuadros@gmail.com> 1474485215 +0200\n"+
+		"\n"+
+		"example annotated tag\n",
+	)
+}
diff --git a/plumbing/object/tree.go b/plumbing/object/tree.go
index 1f9ea26..d30cf6e 100644
--- a/plumbing/object/tree.go
+++ b/plumbing/object/tree.go
@@ -230,7 +230,9 @@ func (t *Tree) Decode(o plumbing.EncodedObject) (err error) {
 	}
 	defer ioutil.CheckClose(reader, &err)
 
-	r := bufio.NewReader(reader)
+	r := bufPool.Get().(*bufio.Reader)
+	defer bufPool.Put(r)
+	r.Reset(reader)
 	for {
 		str, err := r.ReadString(' ')
 		if err != nil {
@@ -383,7 +385,7 @@ func NewTreeWalker(t *Tree, recursive bool, seen map[plumbing.Hash]bool) *TreeWa
 // underlying repository will be skipped automatically. It is possible that this
 // may change in future versions.
 func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
-	var obj Object
+	var obj *Tree
 	for {
 		current := len(w.stack) - 1
 		if current < 0 {
@@ -403,7 +405,7 @@ func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
 			// Finished with the current tree, move back up to the parent
 			w.stack = w.stack[:current]
 			w.base, _ = path.Split(w.base)
-			w.base = path.Clean(w.base) // Remove trailing slash
+			w.base = strings.TrimSuffix(w.base, "/")
 			continue
 		}
 
@@ -419,7 +421,7 @@ func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
 			obj, err = GetTree(w.s, entry.Hash)
 		}
 
-		name = path.Join(w.base, entry.Name)
+		name = simpleJoin(w.base, entry.Name)
 
 		if err != nil {
 			err = io.EOF
@@ -433,9 +435,9 @@ func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
 		return
 	}
 
-	if t, ok := obj.(*Tree); ok {
-		w.stack = append(w.stack, &treeEntryIter{t, 0})
-		w.base = path.Join(w.base, entry.Name)
+	if obj != nil {
+		w.stack = append(w.stack, &treeEntryIter{obj, 0})
+		w.base = simpleJoin(w.base, entry.Name)
 	}
 
 	return
@@ -509,3 +511,10 @@ func (iter *TreeIter) ForEach(cb func(*Tree) error) error {
 		return cb(t)
 	})
 }
+
+func simpleJoin(parent, child string) string {
+	if len(parent) > 0 {
+		return parent + "/" + child
+	}
+	return child
+}
+\ No newline at end of file