Merge pull request #25 from spatialcurrent/aug5_update

Multi-line Expressions and Other Enhancements

Author: pjdufour

README.md

@@ -70,7 +70,7 @@ With the `-env` flag you can use DFL filters against the current environment.
 You can use DFL to filter integer arrays.
 
 ```
-./dfl -verbose -f '@a == [1, 2, 3, 4]' 'a=[1, 2, 3, 4]'
+./dfl -f '@a == [1, 2, 3, 4]' 'a=[1, 2, 3, 4]'
 # returns true as exit code 0
 ```
 
@@ -86,7 +86,7 @@ You can also use DFl to compare byte arrays.
 You can use DFL to filter IP addresses.
 
 ```
-./dfl -verbose -f '@ip in 10.10.0.0/16' ip=10.10.20.22
+./dfl -f '@ip in 10.10.0.0/16' ip=10.10.20.22
 # returns true as exit code 0
 ```
 

cmd/dfljs/main.go cmd/dfl.js/main.gocmd/dfljs/main.go renamed to cmd/dfl.js/main.go

@@ -30,10 +30,14 @@ var GO_DFL_VERSION = "0.0.3"
 
 type Node struct {
 	Node dfl.Node
+	FunctionMap dfl.FunctionMap
 }
 
 func (n Node) Compile() *js.Object {
-	return js.MakeWrapper(Node{Node:n.Node.Compile()})
+	return js.MakeWrapper(Node{
+		Node: n.Node.Compile(),
+		FunctionMap: dfl.NewFuntionMapWithDefaults(),
+	})
 }
 
 func (n Node) Evaluate(options *js.Object) interface{} {
@@ -43,7 +47,7 @@ func (n Node) Evaluate(options *js.Object) interface{} {
 		ctx[key] = options.Get(key).Interface()
 	}
 
-	result, err := n.Node.Evaluate(ctx, dfl.FunctionMap{})
+	result, err := n.Node.Evaluate(ctx, n.FunctionMap)
 	if err != nil {
 		console.Log(err.Error())
 		return false
@@ -87,7 +91,7 @@ func EvaluateBool(s string, options *js.Object) bool {
 		ctx[key] = options.Get(key).Interface()
 	}
 
-	result, err := dfl.EvaluateBool(root, ctx, dfl.FunctionMap{})
+	result, err := dfl.EvaluateBool(root, ctx, dfl.NewFuntionMapWithDefaults())
 	if err != nil {
 		console.Log(err.Error())
 		return false
@@ -110,7 +114,7 @@ func EvaluateInt(s string, options *js.Object) int {
 		ctx[key] = options.Get(key).Interface()
 	}
 
-	result, err := dfl.EvaluateInt(root, ctx, dfl.FunctionMap{})
+	result, err := dfl.EvaluateInt(root, ctx, dfl.NewFuntionMapWithDefaults())
 	if err != nil {
 		console.Log(err.Error())
 		return 0
@@ -133,7 +137,7 @@ func EvaluateFloat64(s string, options *js.Object) float64 {
 		ctx[key] = options.Get(key).Interface()
 	}
 
-	result, err := dfl.EvaluateFloat64(root, ctx, dfl.FunctionMap{})
+	result, err := dfl.EvaluateFloat64(root, ctx, dfl.NewFuntionMapWithDefaults())
 	if err != nil {
 		console.Log(err.Error())
 		return 0.0
@@ -156,7 +160,7 @@ func EvaluateString(s string, options *js.Object) string {
 		ctx[key] = options.Get(key).Interface()
 	}
 
-	result, err := dfl.EvaluateString(root, ctx, dfl.FunctionMap{})
+	result, err := dfl.EvaluateString(root, ctx, dfl.NewFuntionMapWithDefaults())
 	if err != nil {
 		console.Log(err.Error())
 		return ""

cmd/dfl/main.go

@@ -46,19 +46,6 @@ import (
 
 var GO_DFL_VERSION = "0.0.3"
 
-func dfl_build_funcs() dfl.FunctionMap {
-	funcs := dfl.FunctionMap{}
-
-	funcs["len"] = func(ctx dfl.Context, args []string) (interface{}, error) {
-		if len(args) != 1 {
-			return 0, errors.New("Invalid number of arguments to len.")
-		}
-		return len(args[0]), nil
-	}
-
-	return funcs
-}
-
 func main() {
 
 	start := time.Now()
@@ -171,8 +158,7 @@ func main() {
 		fmt.Println(string(out))
 	}
 
-	funcs := dfl_build_funcs()
-	result, err := root.Evaluate(ctx, funcs)
+	result, err := root.Evaluate(ctx, dfl.NewFuntionMapWithDefaults())
 	if err != nil {
 		fmt.Println("Error evaluating expression.")
 		fmt.Println(err)

dfl/And_test.go

@@ -38,7 +38,7 @@ func TestAnd(t *testing.T) {
 		if err != nil {
 			t.Errorf(errors.Wrap(err, "Error evaluating expression \""+testCase.Expression+"\"").Error())
 		} else if got != testCase.Result {
-			t.Errorf("TestSubtract(%q) == %v (%q), want %v (%q)", testCase.Expression, got, reflect.TypeOf(got), testCase.Result, reflect.TypeOf(testCase.Result))
+			t.Errorf("TestAnd(%q) == %v (%q), want %v (%q)", testCase.Expression, got, reflect.TypeOf(got), testCase.Result, reflect.TypeOf(testCase.Result))
 		}
 	}
 

dfl/AttachLeft.go

@@ -0,0 +1,55 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package dfl
+
+import (
+	"github.com/pkg/errors"
+)
+
+// AttachLeft attaches the left Node as the left child node to the parent root Node.
+func AttachLeft(root Node, left Node) error {
+	switch root.(type) {
+	case *And:
+		root.(*And).Left = left
+	case *Or:
+		root.(*Or).Left = left
+	case *Xor:
+		root.(*Xor).Left = left
+	case *Coalesce:
+		root.(*Coalesce).Left = left
+	case *In:
+		root.(*In).Left = left
+	case *Like:
+		root.(*Like).Left = left
+	case *ILike:
+		root.(*ILike).Left = left
+	case *LessThan:
+		root.(*LessThan).Left = left
+	case *LessThanOrEqual:
+		root.(*LessThanOrEqual).Left = left
+	case *GreaterThan:
+		root.(*GreaterThan).Left = left
+	case *GreaterThanOrEqual:
+		root.(*GreaterThanOrEqual).Left = left
+	case *Equal:
+		root.(*Equal).Left = left
+	case *NotEqual:
+		root.(*NotEqual).Left = left
+	case *Add:
+		root.(*Add).Left = left
+	case *Subtract:
+		root.(*Subtract).Left = left
+	case *Before:
+		root.(*Before).Left = left
+	case *After:
+		root.(*After).Left = left
+	default:
+		return errors.New("Could not attach left as root is not a binary operator")
+	}
+	return nil
+}

dfl/Attribute.go

@@ -7,7 +7,9 @@
 
 package dfl
 
-// Array is a Node representing the value of an attribute in the context map.
+// Attribute is a Node representing the value of an attribute in the context map.
+// Attributes start with a "@" and follow with the name or full path into the object if multiple levels deep.
+// For example, @a and @a.b.c.d.  You can also use a null-safe operator, e.g., @a?.b?.c?.d
 type Attribute struct {
 	Name string
 }
@@ -23,15 +25,11 @@ func (a Attribute) Map() map[string]interface{} {
 }
 
 func (a Attribute) Compile() Node {
-	return a
+	return Attribute{Name: a.Name}
 }
 
 func (a Attribute) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
-	if v, ok := ctx[a.Name]; ok {
-		return v, nil
-	} else {
-		return "", nil
-	}
+	return Extract(a.Name, ctx)
 }
 
 func (a Attribute) Attributes() []string {

dfl/Attribute_test.go

@@ -0,0 +1,63 @@
+// =================================================================
+//
+// 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 TestAttribute(t *testing.T) {
+
+	ctx := Context{
+		"a": nil,
+		"b": nil,
+		"c": map[string]interface{}{"d": 10, "e": map[string]interface{}{"f": 100}},
+		"g": []int{10, 20, 30},
+		"h": map[string]interface{}{"i": []int{10, 20, 30, 40}},
+		"j": "bars",
+		"k": []map[string]interface{}{
+			map[string]interface{}{"l": "m"},
+		},
+	}
+
+	testCases := []TestCase{
+		NewTestCase("(@a?.d ?: 10) == 10", ctx, true),
+		NewTestCase("@c?.d == 10", ctx, true),
+		NewTestCase("@c.d == 10", ctx, true),
+		NewTestCase("@c.e.f == 100", ctx, true),
+		NewTestCase("@c.e?.f == 100", ctx, true),
+		NewTestCase("@g[0] == 10", ctx, true),
+		NewTestCase("@g[0:2] == [10,20]", ctx, true),
+		NewTestCase("@h?.i[1:3] == [20,30]", ctx, true),
+		NewTestCase("@h?.i[1:3] == [20,30]", ctx, true),
+		NewTestCase("@j[0:3] == bar", ctx, true),
+		NewTestCase("@j[:3] == bar", ctx, true),
+		NewTestCase("@k[0]l == m", ctx, true),
+	}
+
+	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("TestAttribute(%q) == %v (%q), want %v (%q)", testCase.Expression, got, reflect.TypeOf(got), testCase.Result, reflect.TypeOf(testCase.Result))
+		}
+	}
+
+}

dfl/Coalesce.go

@@ -0,0 +1,60 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package dfl
+
+import (
+	"github.com/pkg/errors"
+)
+
+// Coalesce is a BinaryOperator which returns the left value if not null otherwise the right value.
+type Coalesce struct {
+	*BinaryOperator
+}
+
+func (c Coalesce) Dfl() string {
+	return "(" + c.Left.Dfl() + " ?: " + c.Right.Dfl() + ")"
+}
+
+func (c Coalesce) Map() map[string]interface{} {
+	return map[string]interface{}{
+		"op":    "?:",
+		"left":  c.Left.Map(),
+		"right": c.Right.Map(),
+	}
+}
+
+// Compile returns a compiled version of this node.
+// If the left value is compiled as a Literal, then returns the left value.
+// Otherwise, returns a clone.
+func (c Coalesce) Compile() Node {
+	left := c.Left.Compile()
+	switch left.(type) {
+	case Literal:
+		return Literal{Value: left.(Literal).Value}
+	}
+	right := c.Right.Compile()
+	return Coalesce{&BinaryOperator{Left: left, Right: right}}
+}
+
+func (c Coalesce) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
+	lv, err := c.Left.Evaluate(ctx, funcs)
+	if err != nil {
+		return lv, errors.Wrap(err, "Error evaluating Coalesce left value")
+	}
+
+	switch lv.(type) {
+	case Null:
+		rv, err := c.Right.Evaluate(ctx, funcs)
+		if err != nil {
+			return rv, errors.Wrap(err, "Error evaluating Coalesce right value")
+		}
+		return rv, nil
+	}
+
+	return lv, nil
+}

dfl/Coalesce_test.go

@@ -0,0 +1,45 @@
+// =================================================================
+//
+// 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 TestCoalesce(t *testing.T) {
+
+	ctx := Context{"a": nil, "b": 10, "c": 10}
+
+	testCases := []TestCase{
+		NewTestCase("(@a ?: 10) == 10", ctx, true),
+		NewTestCase("(@a ?: @b) == 10", ctx, true),
+		NewTestCase("(@a ?: @Z ?: @c) == 10", ctx, true),
+		NewTestCase("(@a ?: @Z ?: @c) == 15", 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("TestCoalesce(%q) == %v (%q), want %v (%q)", testCase.Expression, got, reflect.TypeOf(got), testCase.Result, reflect.TypeOf(testCase.Result))
+		}
+	}
+
+}

dfl/Counter.go

@@ -1,5 +1,13 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
 package dfl
 
+// Counter is used for creating a frequency histogram of values
 type Counter map[string]int
 
 func (c Counter) Len() int {