internal/function: rename commit_contains to commit_has_blob

Signed-off-by: Miguel Molina <[email protected]>

Author: erizocosmico

internal/function/commit_contains.go renamed to internal/function/commit_has_blob.go

@@ -9,27 +9,27 @@ import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 )
 
-// CommitContains is a function that checks whether a blob is in a commit.
-type CommitContains struct {
+// CommitHasBlob is a function that checks whether a blob is in a commit.
+type CommitHasBlob struct {
 	commitHash sql.Expression
 	blob       sql.Expression
 }
 
-// NewCommitContains creates a new commit_contains function.
-func NewCommitContains(commitHash, blob sql.Expression) sql.Expression {
-	return &CommitContains{
+// NewCommitHasBlob creates a new commit_has_blob function.
+func NewCommitHasBlob(commitHash, blob sql.Expression) sql.Expression {
+	return &CommitHasBlob{
 		commitHash: commitHash,
 		blob:       blob,
 	}
 }
 
 // Type implements the Expression interface.
-func (CommitContains) Type() sql.Type {
+func (CommitHasBlob) Type() sql.Type {
 	return sql.Boolean
 }
 
 // Eval implements the Expression interface.
-func (f *CommitContains) Eval(session sql.Session, row sql.Row) (interface{}, error) {
+func (f *CommitHasBlob) Eval(session sql.Session, row sql.Row) (interface{}, error) {
 	s, ok := session.(*gitquery.Session)
 	if !ok {
 		return nil, gitquery.ErrInvalidGitQuerySession.New(session)
@@ -63,14 +63,14 @@ func (f *CommitContains) Eval(session sql.Session, row sql.Row) (interface{}, er
 		return nil, err
 	}
 
-	return f.commitContains(
+	return f.commitHasBlob(
 		s.Pool,
 		plumbing.NewHash(commitHash.(string)),
 		plumbing.NewHash(blob.(string)),
 	)
 }
 
-func (f *CommitContains) commitContains(
+func (f *CommitHasBlob) commitHasBlob(
 	pool *gitquery.RepositoryPool,
 	commitHash, blob plumbing.Hash,
 ) (bool, error) {
@@ -135,22 +135,22 @@ func hashInTree(hash plumbing.Hash, tree *object.Tree) (bool, error) {
 }
 
 // Name implements the Expression interface.
-func (CommitContains) Name() string {
-	return "commit_contains"
+func (CommitHasBlob) Name() string {
+	return "commit_has_blob"
 }
 
 // IsNullable implements the Expression interface.
-func (f CommitContains) IsNullable() bool {
+func (f CommitHasBlob) IsNullable() bool {
 	return f.commitHash.IsNullable() || f.blob.IsNullable()
 }
 
 // Resolved implements the Expression interface.
-func (f CommitContains) Resolved() bool {
+func (f CommitHasBlob) Resolved() bool {
 	return f.commitHash.Resolved() && f.blob.Resolved()
 }
 
 // TransformUp implements the Expression interface.
-func (f CommitContains) TransformUp(fn func(sql.Expression) (sql.Expression, error)) (sql.Expression, error) {
+func (f CommitHasBlob) TransformUp(fn func(sql.Expression) (sql.Expression, error)) (sql.Expression, error) {
 	commitHash, err := f.commitHash.TransformUp(fn)
 	if err != nil {
 		return nil, err
@@ -161,5 +161,5 @@ func (f CommitContains) TransformUp(fn func(sql.Expression) (sql.Expression, err
 		return nil, err
 	}
 
-	return fn(NewCommitContains(commitHash, blob))
+	return fn(NewCommitHasBlob(commitHash, blob))
 }

internal/function/commit_contains_test.go renamed to internal/function/commit_has_blob_test.go

@@ -11,13 +11,13 @@ import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
 )
 
-func TestCommitContains(t *testing.T) {
+func TestCommitHasBlob(t *testing.T) {
 	require.NoError(t, fixtures.Init())
 	defer func() {
 		require.NoError(t, fixtures.Clean())
 	}()
 
-	f := NewCommitContains(
+	f := NewCommitHasBlob(
 		expression.NewGetField(0, sql.Text, "commit_hash", true),
 		expression.NewGetField(1, sql.Text, "blob", true),
 	)

internal/function/registry.go

@@ -5,7 +5,7 @@ import "gopkg.in/src-d/go-mysql-server.v0/sql"
 var functions = map[string]sql.Function{
 	"is_tag":          sql.Function1(NewIsTag),
 	"is_remote":       sql.Function1(NewIsRemote),
-	"commit_contains": sql.Function2(NewCommitContains),
+	"commit_has_blob": sql.Function2(NewCommitHasBlob),
 	"history_idx":     sql.Function2(NewHistoryIdx),
 }