Blame func prototype skeleton

Signed-off-by: Juanjo Alvarez <[email protected]>

Author: Juanjo Alvarez

internal/function/blame.go

@@ -0,0 +1,145 @@
+package function
+
+import (
+	"fmt"
+	"github.com/src-d/gitbase"
+	"gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+)
+
+type (
+	// Blame implements git-blame function as UDF
+	Blame struct {
+		repo   sql.Expression
+		commit sql.Expression
+	}
+
+	// BlameLine represents each line of git blame's output
+	BlameLine struct {
+		Commit  string `json:"commit"`
+		File    string `json:"file"`
+		LineNum int    `json:"linenum"`
+		Author  string `json:"author"`
+		Text    string `json:"text"`
+	}
+)
+
+// NewBlame constructor
+func NewBlame(repo, commit sql.Expression) sql.Expression {
+	return &Blame{repo, commit}
+}
+
+func (b *Blame) String() string {
+	return fmt.Sprintf("blame(%s, %s)", b.repo, b.commit)
+}
+
+// Type implements the sql.Expression interface
+func (*Blame) Type() sql.Type {
+	return sql.Array(sql.JSON)
+}
+
+// TransformUp implements the sql.Expression interface
+func (b *Blame) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error) {
+	repo, err := b.repo.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	commit, err := b.commit.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return fn(&Blame{repo, commit})
+}
+
+// Children implements the Expression interface.
+func (b *Blame) Children() []sql.Expression {
+	return []sql.Expression{b.commit}
+}
+
+// IsNullable implements the Expression interface.
+func (*Blame) IsNullable() bool {
+	return false
+}
+
+// Resolved implements the Expression interface.
+func (b *Blame) Resolved() bool {
+	return b.commit.Resolved()
+}
+
+// Eval implements the sql.Expression interface.
+func (b *Blame) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.Blame")
+	defer span.Finish()
+
+	repo, err := b.resolveRepo(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+
+	commit, err := b.resolveCommit(ctx, repo, row)
+	if err != nil {
+		return nil, err
+	}
+
+	fIter, err := commit.Files()
+	if err != nil {
+		return nil, err
+	}
+	defer fIter.Close()
+
+	var lines []BlameLine
+	for f, err := fIter.Next(); err == nil; f, err = fIter.Next() {
+		result, err := git.Blame(commit, f.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		for i, l := range result.Lines {
+			lines = append(lines, BlameLine{
+				Commit:  commit.Hash.String(),
+				File:    f.Name,
+				LineNum: i,
+				Author:  l.Author,
+				Text:    l.Text,
+			})
+		}
+	}
+
+	return lines, nil
+}
+
+func (b *Blame) resolveCommit(ctx *sql.Context, repo *gitbase.Repository, row sql.Row) (*object.Commit, error) {
+	str, err := exprToString(ctx, b.commit, row)
+	if err != nil {
+		return nil, err
+	}
+
+	commitHash, err := repo.ResolveRevision(plumbing.Revision(str))
+	if err != nil {
+		h := plumbing.NewHash(str)
+		commitHash = &h
+	}
+	to, err := repo.CommitObject(*commitHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return to, nil
+}
+
+func (b *Blame) resolveRepo(ctx *sql.Context, r sql.Row) (*gitbase.Repository, error) {
+	repoID, err := exprToString(ctx, b.repo, r)
+	if err != nil {
+		return nil, err
+	}
+	s, ok := ctx.Session.(*gitbase.Session)
+	if !ok {
+		return nil, gitbase.ErrInvalidGitbaseSession.New(ctx.Session)
+	}
+	return s.Pool.GetRepo(repoID)
+}

internal/function/blame_test.go

@@ -0,0 +1,64 @@
+package function
+
+import (
+	"context"
+	"fmt"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+
+	"github.com/src-d/gitbase"
+	"github.com/stretchr/testify/require"
+	fixtures "gopkg.in/src-d/go-git-fixtures.v3"
+	"gopkg.in/src-d/go-git.v4/plumbing/cache"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"testing"
+)
+
+func TestBlameEval(t *testing.T) {
+	require.NoError(t, fixtures.Init())
+
+	defer func() {
+		require.NoError(t, fixtures.Clean())
+	}()
+
+	path := fixtures.ByTag("worktree").One().Worktree().Root()
+
+	pool := gitbase.NewRepositoryPool(cache.DefaultMaxSize)
+	require.NoError(t, pool.AddGitWithID("worktree", path))
+
+	session := gitbase.NewSession(pool)
+	ctx := sql.NewContext(context.TODO(), sql.WithSession(session))
+
+	testCases := []struct {
+		name     string
+		repo     sql.Expression
+		commit   sql.Expression
+		row      sql.Row
+		expected BlameLine
+	}{
+		{
+			name:   "init commit",
+			repo:   expression.NewGetField(0, sql.Text, "repository_id", false),
+			commit: expression.NewGetField(1, sql.Text, "commit_hash", false),
+			row:    sql.NewRow("worktree", "b029517f6300c2da0f4b651b8642506cd6aaf45d"),
+			expected: BlameLine{
+				"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+				".gitignore",
+				0,
+				"[email protected]",
+				"*.class",
+			},
+		}}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			blame := NewBlame(tc.repo, tc.commit)
+			results, err := blame.Eval(ctx, tc.row)
+			require.NoError(t, err)
+			for _, r := range results.([]BlameLine) {
+				fmt.Println(r)
+				require.EqualValues(t, tc.expected, r)
+				break
+			}
+		})
+	}
+}