internal/function: implement is_remote function

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

Author: erizocosmico

internal/function/is_remote.go

@@ -0,0 +1,55 @@
+package function
+
+import (
+	"reflect"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+// IsRemote checks the given string is a tag name.
+type IsRemote struct {
+	expression.UnaryExpression
+}
+
+// NewIsRemote creates a new IsRemote function.
+func NewIsRemote(e sql.Expression) *IsRemote {
+	return &IsRemote{expression.UnaryExpression{Child: e}}
+}
+
+var _ sql.Expression = (*IsRemote)(nil)
+
+// Eval implements the expression interface.
+func (f *IsRemote) Eval(row sql.Row) (interface{}, error) {
+	val, err := f.Child.Eval(row)
+	if err != nil {
+		return nil, err
+	}
+
+	if val == nil {
+		return false, nil
+	}
+
+	name, ok := val.(string)
+	if !ok {
+		return nil, sql.ErrInvalidType.New(reflect.TypeOf(val).String())
+	}
+
+	return plumbing.ReferenceName(name).IsRemote(), nil
+}
+
+// Name implements the Expression interface.
+func (IsRemote) Name() string {
+	return "is_remote"
+}
+
+// TransformUp implements the Expression interface.
+func (f IsRemote) TransformUp(fn func(sql.Expression) sql.Expression) sql.Expression {
+	return NewIsRemote(fn(f.Child))
+}
+
+// Type implements the Expression interface.
+func (IsRemote) Type() sql.Type {
+	return sql.Boolean
+}

internal/function/is_remote_test.go

@@ -0,0 +1,40 @@
+package function
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+func TestIsRemote(t *testing.T) {
+	f := NewIsRemote(expression.NewGetField(0, sql.Text, "name", true))
+
+	testCases := []struct {
+		name     string
+		row      sql.Row
+		expected bool
+		err      bool
+	}{
+		{"null", sql.NewRow(nil), false, false},
+		{"not a branch", sql.NewRow("foo bar"), false, false},
+		{"not remote branch", sql.NewRow("refs/heads/foo"), false, false},
+		{"remote branch", sql.NewRow("refs/remotes/foo/bar"), true, false},
+		{"mismatched type", sql.NewRow(1), false, true},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+			val, err := f.Eval(tt.row)
+			if tt.err {
+				require.Error(err)
+				require.True(sql.ErrInvalidType.Is(err))
+			} else {
+				require.NoError(err)
+				require.Equal(tt.expected, val)
+			}
+		})
+	}
+}