tests; now handle arrays as set

Author: pjdufour

dfl/After_test.go

@@ -10,7 +10,7 @@ package dfl
 import (
 	"reflect"
 	"testing"
-  "time"
+	"time"
 )
 
 import (
@@ -20,9 +20,9 @@ import (
 func TestAfter(t *testing.T) {
 
 	ctx := Context{
-    "a": time.Date(2018, time.April, 2, 3, 28, 56, 0, time.UTC),
-    "b": time.Date(2018, time.May, 2, 3, 28, 56, 0, time.UTC),
-  }
+		"a": time.Date(2018, time.April, 2, 3, 28, 56, 0, time.UTC),
+		"b": time.Date(2018, time.May, 2, 3, 28, 56, 0, time.UTC),
+	}
 
 	testCases := []TestCase{
 		NewTestCase("2017-01-01 after 2018-01-01", ctx, false),

dfl/Before_test.go

@@ -10,7 +10,7 @@ package dfl
 import (
 	"reflect"
 	"testing"
-  "time"
+	"time"
 )
 
 import (
@@ -20,9 +20,9 @@ import (
 func TestBefore(t *testing.T) {
 
 	ctx := Context{
-    "a": time.Date(2018, time.April, 2, 3, 28, 56, 0, time.UTC),
-    "b": time.Date(2018, time.May, 2, 3, 28, 56, 0, time.UTC),
-  }
+		"a": time.Date(2018, time.April, 2, 3, 28, 56, 0, time.UTC),
+		"b": time.Date(2018, time.May, 2, 3, 28, 56, 0, time.UTC),
+	}
 
 	testCases := []TestCase{
 		NewTestCase("2017-01-01 before 2018-01-01", ctx, true),

dfl/ILike_test.go

@@ -25,9 +25,9 @@ func TestILike(t *testing.T) {
 		NewTestCase("@a ilike cafe", ctx, false),
 		NewTestCase("bar ilike @b", ctx, true),
 		NewTestCase("@a ilike @b", ctx, false),
-    NewTestCase("@a ilike cafe%", ctx, true),
-    NewTestCase("@a ilike %bar", ctx, true),
-    NewTestCase("@a ilike %and%", ctx, true),
+		NewTestCase("@a ilike cafe%", ctx, true),
+		NewTestCase("@a ilike %bar", ctx, true),
+		NewTestCase("@a ilike %and%", ctx, true),
 	}
 
 	for _, testCase := range testCases {

dfl/In.go

@@ -63,6 +63,16 @@ func (i In) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
 		return strings.Contains(fmt.Sprint(rv), lvs), nil
 	case float64:
 		return strings.Contains(strconv.FormatFloat(rv.(float64), 'f', 6, 64), lvs), nil
+	case map[string]struct{}:
+		_, ok := rv.(map[string]struct{})[lvs]
+		return ok, nil
+	case []string:
+		for _, x := range rv.([]string) {
+			if lvs == x {
+				return true, nil
+			}
+		}
+		return false, nil
 	case []interface{}:
 		for _, x := range rv.([]interface{}) {
 			if lvs == fmt.Sprint(x) {

dfl/In_test.go

@@ -0,0 +1,46 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package dfl
+
+import (
+	"reflect"
+	"testing"
+)
+
+import (
+	"github.com/pkg/errors"
+)
+
+func TestIn(t *testing.T) {
+
+	ctx := Context{"a": "cafe", "b": []string{"bar", "cafe"}}
+
+	testCases := []TestCase{
+		NewTestCase("bar in @b", ctx, true),
+		NewTestCase("@a in @b", ctx, true),
+		NewTestCase("bar in [bar, cafe]", ctx, true),
+		NewTestCase("fast_food in [bar, cafe]", ctx, false),
+		NewTestCase("fast_food in @b", ctx, false),
+	}
+
+	for _, testCase := range testCases {
+		node, err := Parse(testCase.Expression)
+		if err != nil {
+			t.Errorf(errors.Wrap(err, "Error parsing expression \""+testCase.Expression+"\"").Error())
+			continue
+		}
+		node = node.Compile()
+		got, err := node.Evaluate(testCase.Context, FunctionMap{})
+		if err != nil {
+			t.Errorf(errors.Wrap(err, "Error evaluating expression \""+testCase.Expression+"\"").Error())
+		} else if got != testCase.Result {
+			t.Errorf("TestILike(%q) == %v (%q), want %v (%q)", testCase.Expression, got, reflect.TypeOf(got), testCase.Result, reflect.TypeOf(testCase.Result))
+		}
+	}
+
+}

dfl/Like_test.go

@@ -25,9 +25,9 @@ func TestLike(t *testing.T) {
 		NewTestCase("@a like cafe", ctx, false),
 		NewTestCase("bar like @b", ctx, true),
 		NewTestCase("@a like @b", ctx, false),
-    NewTestCase("@a like cafe%", ctx, true),
-    NewTestCase("@a like %bar", ctx, true),
-    NewTestCase("@a like %and%", ctx, true),
+		NewTestCase("@a like cafe%", ctx, true),
+		NewTestCase("@a like %bar", ctx, true),
+		NewTestCase("@a like %and%", ctx, true),
 	}
 
 	for _, testCase := range testCases {

dfl/Parse.go

@@ -67,7 +67,7 @@ func Parse(in string) (Node, error) {
 				if len(s) >= 2 && ((strings.HasPrefix(s, "'") && strings.HasSuffix(s, "'")) || (strings.HasPrefix(s, "\"") && strings.HasSuffix(s, "\""))) {
 					return ParseLiteral(s[1:len(s)-1], remainder)
 				} else if len(s) >= 2 && strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") {
-					return ParseArray(s[1:len(s)-1], remainder)
+					return ParseSet(s[1:len(s)-1], remainder)
 				} else if len(s) >= 2 && strings.HasPrefix(s, "(") && strings.HasSuffix(s, ")") {
 					return ParseSub(s[1:len(s)-1], remainder)
 				} else if s_lc == "and" {

dfl/ParseArray.go dfl/ParseSet.godfl/ParseArray.go renamed to dfl/ParseSet.go

@@ -17,16 +17,16 @@ import (
 	"github.com/pkg/errors"
 )
 
-// ParseArray parses an Array Node and recursively any remainder.
+// ParseSet parses a Set Node and recursively any remainder.
 // If parameter "in" is gramatically a child node, then return the parent node.
-// DFL arrays can include Attribute or Literal Nodes.
+// DFL sets can include Attribute or Literal Nodes.
 // As all attribute references must start with an "@" character, parantheses are optional for literals except if a comma exists.
 // Below are some example inputs
 //
 //	[bank, bureau_de_change, atm]
 //	[1, 2, @target]
 //	[Taco, Tacos, Burrito, Burritos, "Mexican Food", @example]
-func ParseArray(in string, remainder string) (Node, error) {
+func ParseSet(in string, remainder string) (Node, error) {
 
 	nodes := make([]Node, 0)
 	singlequotes := 0
@@ -69,10 +69,10 @@ func ParseArray(in string, remainder string) (Node, error) {
 	}
 
 	if len(remainder) == 0 {
-		return &Array{Nodes: nodes}, nil
+		return &Set{Nodes: nodes}, nil
 	}
 
-	left := &Array{Nodes: nodes}
+	left := &Set{Nodes: nodes}
 	root, err := Parse(remainder)
 	if err != nil {
 		return root, err

dfl/Array.go dfl/Set.godfl/Array.go renamed to dfl/Set.go

@@ -11,12 +11,12 @@ import (
 	"reflect"
 )
 
-// Array is a Node representing an array (aka slice in Go) of values, which can be either a Literal or Attribute.
-type Array struct {
+// Set is a Node representing a set of values, which can be either a Literal or Attribute.
+type Set struct {
 	Nodes []Node
 }
 
-func (a Array) Dfl() string {
+func (a Set) Dfl() string {
 	str := "["
 	for i, x := range a.Nodes {
 		if i > 0 {
@@ -28,15 +28,16 @@ func (a Array) Dfl() string {
 	return str
 }
 
-func (a Array) Map() map[string]interface{} {
+func (a Set) Map() map[string]interface{} {
 	return map[string]interface{}{
 		"nodes": a.Nodes,
 	}
 }
 
 // Compile returns a compiled version of this node.
-// If all the values of an array are literals, returns a single Literal with the corresponding array/slice as its value.
-func (a Array) Compile() Node {
+// If all the values of an Set are literals, returns a single Literal with the corresponding Set/slice as its value.
+// Otherwise returns the original node..
+func (a Set) Compile() Node {
 	values := make([]interface{}, len(a.Nodes))
 	nodes := reflect.ValueOf(a.Nodes)
 	for i := 0; i < nodes.Len(); i++ {
@@ -48,10 +49,19 @@ func (a Array) Compile() Node {
 			return a
 		}
 	}
-	return Literal{Value: values}
+	set := make(map[string]struct{}, len(values))
+	for _, v := range values {
+		switch v.(type) {
+		case string:
+			set[v.(string)] = struct{}{}
+		default:
+			return Literal{Value: values}
+		}
+	}
+	return Literal{Value: set}
 }
 
-func (a Array) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
+func (a Set) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
 	values := make([]interface{}, len(a.Nodes))
 	for i, n := range a.Nodes {
 		v, err := n.Evaluate(ctx, funcs)
@@ -63,7 +73,7 @@ func (a Array) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
 	return values, nil
 }
 
-func (a Array) Attributes() []string {
+func (a Set) Attributes() []string {
 	set := make(map[string]struct{})
 	for _, n := range a.Nodes {
 		for _, x := range n.Attributes() {

dfl/TestCase.go

@@ -9,8 +9,8 @@ package dfl
 
 // TestCase is a struct containing the variables for a unit test of expression evaluation.
 type TestCase struct {
-	Expression string // the DFL expression
-	Context    Context // the Context to use for evaluation
+	Expression string      // the DFL expression
+	Context    Context     // the Context to use for evaluation
 	Result     interface{} // The result of the evaluation
 }