git: Add references relation (#34)

Author: ajnavarro

git/commits.go

@@ -50,19 +50,19 @@ func (r commitsRelation) RowIter() (sql.RowIter, error) {
 	if err != nil {
 		return nil, err
 	}
-	iter := &iter{i: cIter}
+	iter := &commitIter{i: cIter}
 	return iter, nil
 }
 
 func (commitsRelation) Children() []sql.Node {
 	return []sql.Node{}
 }
 
-type iter struct {
+type commitIter struct {
 	i *git.CommitIter
 }
 
-func (i *iter) Next() (sql.Row, error) {
+func (i *commitIter) Next() (sql.Row, error) {
 	commit, err := i.i.Next()
 	if err == io.EOF {
 		return nil, io.EOF

git/database.go

@@ -7,20 +7,23 @@ import (
 )
 
 const (
-	commitsRelationName = "commits"
-	tagsRelationName    = "tags"
+	referencesRelationName = "references"
+	commitsRelationName    = "commits"
+	tagsRelationName       = "tags"
 )
 
 type Database struct {
 	name string
 	cr   sql.PhysicalRelation
 	tr   sql.PhysicalRelation
+	rr   sql.PhysicalRelation
 }
 
 func NewDatabase(name string, r *git.Repository) sql.Database {
 	return &Database{
 		name: name,
 		cr:   newCommitsRelation(r),
+		rr:   newReferencesRelation(r),
 		tr:   newTagsRelation(r),
 	}
 }
@@ -31,7 +34,8 @@ func (d *Database) Name() string {
 
 func (d *Database) Relations() map[string]sql.PhysicalRelation {
 	return map[string]sql.PhysicalRelation{
-		commitsRelationName: d.cr,
-		tagsRelationName:    d.tr,
+		commitsRelationName:    d.cr,
+		tagsRelationName:       d.tr,
+		referencesRelationName: d.rr,
 	}
 }

git/references.go

@@ -0,0 +1,82 @@
+package git
+
+import (
+	"github.com/gitql/gitql/sql"
+
+	"gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-git.v4/core"
+)
+
+type referencesRelation struct {
+	r *git.Repository
+}
+
+func newReferencesRelation(r *git.Repository) sql.PhysicalRelation {
+	return &referencesRelation{r: r}
+}
+
+func (referencesRelation) Resolved() bool {
+	return true
+}
+
+func (referencesRelation) Name() string {
+	return referencesRelationName
+}
+
+func (referencesRelation) Schema() sql.Schema {
+	return sql.Schema{
+		sql.Field{"hash", sql.String},
+		sql.Field{"name", sql.String},
+		sql.Field{"is_branch", sql.Boolean},
+		sql.Field{"is_note", sql.Boolean},
+		sql.Field{"is_remote", sql.Boolean},
+		sql.Field{"is_tag", sql.Boolean},
+		sql.Field{"target", sql.String},
+	}
+}
+
+func (r *referencesRelation) TransformUp(f func(sql.Node) sql.Node) sql.Node {
+	return f(r)
+}
+
+func (r *referencesRelation) TransformExpressionsUp(f func(sql.Expression) sql.Expression) sql.Node {
+	return r
+}
+
+func (r referencesRelation) RowIter() (sql.RowIter, error) {
+	rIter, err := r.r.Refs()
+	if err != nil {
+		return nil, err
+	}
+	iter := &referenceIter{i: rIter}
+	return iter, nil
+}
+
+func (referencesRelation) Children() []sql.Node {
+	return []sql.Node{}
+}
+
+type referenceIter struct {
+	i core.ReferenceIter
+}
+
+func (i *referenceIter) Next() (sql.Row, error) {
+	reference, err := i.i.Next()
+	if err != nil {
+		return nil, err
+	}
+
+	return referenceToRow(reference), nil
+}
+
+func referenceToRow(c *core.Reference) sql.Row {
+	return sql.NewMemoryRow(
+		c.Hash().String(),
+		c.Name().String(),
+		c.IsBranch(),
+		c.IsNote(),
+		c.IsRemote(),
+		c.IsTag(),
+		c.Target().String(),
+	)
+}

git/references_test.go

@@ -0,0 +1,45 @@
+package git
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-git.v4/fixtures"
+)
+
+func TestRefsRelation(t *testing.T) {
+	assert := assert.New(t)
+
+	f := fixtures.Basic().One()
+	r, err := git.NewFilesystemRepository(f.DotGit().Base())
+	assert.Nil(err)
+
+	db := NewDatabase("foo", r)
+	assert.NotNil(db)
+
+	relations := db.Relations()
+	rel, ok := relations[referencesRelationName]
+	assert.True(ok)
+	assert.NotNil(rel)
+	assert.Equal(referencesRelationName, rel.Name())
+	assert.Equal(0, len(rel.Children()))
+
+	iter, err := rel.RowIter()
+	assert.Nil(err)
+	assert.NotNil(iter)
+
+	row, err := iter.Next()
+	assert.Nil(err)
+	assert.NotNil(row)
+
+	fields := row.Fields()
+	assert.NotNil(fields)
+	assert.IsType("", fields[0])
+	assert.IsType("", fields[1])
+	assert.IsType(true, fields[2])
+	assert.IsType(true, fields[3])
+	assert.IsType(true, fields[4])
+	assert.IsType(true, fields[5])
+	assert.IsType("", fields[6])
+}