Merge pull request #9 from danielgtaylor/map-where

feat: where for maps; various small fixes

Author: danielgtaylor

README.md

@@ -187,7 +187,7 @@ Indexes are zero-based. Slice indexes are optional and are _inclusive_. `foo[1:2
 
 #### Array/slice filtering
 
-A `where` clause can be used to filter the items in an array. The left side of the clause is the array to be filtered, while the right side is an expression to run on each item of the array. If the right side expression evaluates to true then the item is added to the result. For example:
+A `where` clause can be used to filter the items in an array. The left side of the clause is the array to be filtered, while the right side is an expression to run on each item of the array. If the right side expression evaluates to true then the item is added to the result slice. For example:
 
 ```
 // Get a list of items where the item.id is bigger than 3
@@ -221,6 +221,33 @@ not (items where id > 3)
 - `in` (has key), e.g. `"key" in foo`
 - `contains` e.g. `foo contains "key"`
 
+#### Map wildcard filtering
+
+A `where` clause can be used as a wildcard key to filter values for all keys in a map. The left side of the clause is the map to be filtered, while the right side is an expression to run on each value of the map. If the right side expression evaluates to true then the value is added to the result slice. For example, given:
+
+```json
+{
+  "operations": {
+    "id1": { "method": "GET", "path": "/op1" },
+    "id2": { "method": "PUT", "path": "/op2" },
+    "id3": { "method": "DELETE", "path": "/op3" }
+  }
+}
+```
+
+You can run:
+
+```
+// Get all operations where the HTTP method is GET
+operations where method == "GET"
+```
+
+And the result would be a slice of matched values:
+
+```json
+[{ "method": "GET", "path": "/op1" }]
+```
+
 ## Performance
 
 Performance compares favorably to [antonmedv/expr](https://github.com/antonmedv/expr) for both `Eval(...)` and cached program performance, which is expected given the more limited feature set. The `slow` benchmarks include lexing/parsing/interpreting while the `cached` ones are just the interpreting step. The `complex` example expression used is non-trivial: `foo.bar / (1 * 1024 * 1024) >= 1.0 and "v" in baz and baz.length > 3 and arr[2:].length == 1`.

expr.go

@@ -4,7 +4,7 @@ package mexpr
 // Parse an expression and return the abstract syntax tree. If `types` is
 // passed, it should be a set of representative example values for the input
 // which will be used to type check the expression against.
-func Parse(expression string, types map[string]interface{}, options ...InterpreterOption) (*Node, Error) {
+func Parse(expression string, types any, options ...InterpreterOption) (*Node, Error) {
 	l := NewLexer(expression)
 	p := NewParser(l)
 	ast, err := p.Parse()
@@ -13,21 +13,21 @@ func Parse(expression string, types map[string]interface{}, options ...Interpret
 	}
 	if types != nil {
 		if err := TypeCheck(ast, types, options...); err != nil {
-			return nil, err
+			return ast, err
 		}
 	}
 	return ast, nil
 }
 
 // TypeCheck will take a parsed AST and type check against the given input
 // structure with representative example values.
-func TypeCheck(ast *Node, types map[string]interface{}, options ...InterpreterOption) Error {
+func TypeCheck(ast *Node, types any, options ...InterpreterOption) Error {
 	i := NewTypeChecker(ast, options...)
 	return i.Run(types)
 }
 
 // Run executes an AST with the given input and returns the output.
-func Run(ast *Node, input map[string]interface{}, options ...InterpreterOption) (interface{}, Error) {
+func Run(ast *Node, input any, options ...InterpreterOption) (any, Error) {
 	i := NewInterpreter(ast, options...)
 	return i.Run(input)
 }
@@ -36,7 +36,7 @@ func Run(ast *Node, input map[string]interface{}, options ...InterpreterOption)
 // expression with the given input. If you plan to execute the expression
 // multiple times consider caching the output of `Parse(...)` instead for a
 // big speed improvement.
-func Eval(expression string, input map[string]interface{}, options ...InterpreterOption) (interface{}, Error) {
+func Eval(expression string, input any, options ...InterpreterOption) (any, Error) {
 	// No need to type check because we are about to run with the input.
 	ast, err := Parse(expression, nil)
 	if err != nil {

go.mod

@@ -2,7 +2,10 @@ module github.com/danielgtaylor/mexpr
 
 go 1.18
 
-require github.com/stretchr/testify v1.7.0
+require (
+	github.com/stretchr/testify v1.7.0
+	golang.org/x/exp v0.0.0-20230108222341-4b8118a2686a
+)
 
 require (
 	github.com/davecgh/go-spew v1.1.0 // indirect

go.sum

@@ -5,6 +5,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/exp v0.0.0-20230108222341-4b8118a2686a h1:tlXy25amD5A7gOfbXdqCGN5k8ESEed/Ee1E5RcrYnqU=
+golang.org/x/exp v0.0.0-20230108222341-4b8118a2686a/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=

interpreter.go

@@ -3,6 +3,8 @@ package mexpr
 import (
 	"math"
 	"strings"
+
+	"golang.org/x/exp/maps"
 )
 
 // InterpreterOption passes configuration settings when creating a new
@@ -434,6 +436,16 @@ func (i *interpreter) run(ast *Node, value any) (any, Error) {
 		if resultLeft == nil {
 			return nil, nil
 		}
+		if m, ok := resultLeft.(map[string]any); ok {
+			resultLeft = maps.Values(m)
+		}
+		if m, ok := resultLeft.(map[any]any); ok {
+			values := make([]any, 0, len(m))
+			for _, v := range m {
+				values = append(values, v)
+			}
+			resultLeft = values
+		}
 		for _, item := range resultLeft.([]any) {
 			// In an unquoted string scenario it makes no sense for the first/only
 			// token after a `where` clause to be treated as a string. Instead we

interpreter_test.go

@@ -10,12 +10,13 @@ import (
 
 func TestInterpreter(t *testing.T) {
 	type test struct {
-		expr   string
-		input  string
-		skipTC bool
-		opts   []InterpreterOption
-		err    string
-		output interface{}
+		expr        string
+		input       string
+		inputParsed any
+		skipTC      bool
+		opts        []InterpreterOption
+		err         string
+		output      interface{}
 	}
 	cases := []test{
 		// Add/sub
@@ -71,7 +72,7 @@ func TestInterpreter(t *testing.T) {
 		{expr: `foo[-1]`, input: `{"foo": "hello"}`, output: "o"},
 		{expr: `foo[0:-3]`, input: `{"foo": "hello"}`, output: "hel"},
 		// Unquoted strings
-		{expr: `"foo" == foo`, output: false},
+		{expr: `"foo" == foo`, skipTC: true, output: false},
 		{expr: `"foo" == foo`, opts: []InterpreterOption{UnquotedStrings}, output: true},
 		{expr: `"foo" == bar`, opts: []InterpreterOption{UnquotedStrings}, output: false},
 		{expr: `foo == foo`, opts: []InterpreterOption{UnquotedStrings}, output: true},
@@ -142,6 +143,9 @@ func TestInterpreter(t *testing.T) {
 		{expr: `(items where id > 3).length == 2`, input: `{"items": [{"id": 1}, {"id": 3}, {"id": 5}, {"id": 7}]}`, output: true},
 		{expr: `not (items where id > 3)`, input: `{"items": [{"id": 1}, {"id": 3}, {"id": 5}, {"id": 7}]}`, output: false},
 		{expr: `items where id > 3`, input: `{}`, skipTC: true, output: nil},
+		{expr: `foo where method == "GET"`, input: `{"foo": {"op1": {"method": "GET", "path": "/op1"}, "op2": {"method": "PUT", "path": "/op2"}, "op3": {"method": "DELETE", "path": "/op3"}}}`, output: []any{map[string]any{"method": "GET", "path": "/op1"}}},
+		{expr: `foo where method == "GET"`, inputParsed: map[any]any{"foo": map[any]any{"op1": map[any]any{"method": "GET", "path": "/op1"}, "op2": map[any]any{"method": "PUT", "path": "/op2"}, "op3": map[any]any{"method": "DELETE", "path": "/op3"}}}, output: []any{map[any]any{"method": "GET", "path": "/op1"}}},
+		{expr: `items where id > 3`, input: `{"items": []}`, err: "where clause requires a non-empty array or object"},
 		// Order of operations
 		{expr: "1 + 2 + 3", output: 6.0},
 		{expr: "1 + 2 * 3", output: 7.0},
@@ -152,7 +156,7 @@ func TestInterpreter(t *testing.T) {
 		{expr: "6 -", err: "incomplete expression"},
 		{expr: `foo.bar + "baz"`, input: `{"foo": 1}`, err: "no property bar"},
 		{expr: `foo + 1`, input: `{"foo": [1, 2]}`, err: "cannot operate on incompatible types"},
-		{expr: `foo > 1`, input: `{"foo": []}`, err: "cannot compare array with number"},
+		{expr: `foo > 1`, input: `{"foo": []}`, err: "cannot compare array[<nil>] with number"},
 		{expr: `foo[1-]`, input: `{"foo": "hello"}`, err: "unexpected right-bracket"},
 		{expr: `not (1- <= 5)`, err: "missing right operand"},
 		{expr: `(1 >=)`, err: "unexpected right-paren"},
@@ -175,8 +179,10 @@ func TestInterpreter(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.expr, func(t *testing.T) {
-			var input map[string]interface{}
-			if tc.input != "" {
+			var input any
+			if tc.inputParsed != nil {
+				input = tc.inputParsed
+			} else if tc.input != "" {
 				if err := json.Unmarshal([]byte(tc.input), &input); err != nil {
 					t.Fatal(err)
 				}
@@ -188,6 +194,10 @@ func TestInterpreter(t *testing.T) {
 			}
 			ast, err := Parse(tc.expr, types, tc.opts...)
 
+			if ast != nil {
+				t.Log("graph G {\n" + ast.Dot("") + "\n}")
+			}
+
 			if tc.err != "" {
 				if err != nil {
 					if strings.Contains(err.Error(), tc.err) {
@@ -200,7 +210,7 @@ func TestInterpreter(t *testing.T) {
 					t.Fatal(err.Pretty(tc.expr))
 				}
 			}
-			t.Log("graph G {\n" + ast.Dot("") + "\n}")
+
 			result, err := Run(ast, input, tc.opts...)
 			if tc.err != "" {
 				if err == nil {
@@ -229,7 +239,7 @@ func FuzzMexpr(f *testing.F) {
 			"f": 1.0,
 			"s": "Hello",
 			"a": []any{false, 1, "a"},
-			"o": map[string]any{
+			"o": map[any]any{
 				"prop": 123,
 			},
 		})

typecheck.go

@@ -1,7 +1,11 @@
 package mexpr
 
 import (
+	"fmt"
+	"sort"
 	"strings"
+
+	"golang.org/x/exp/maps"
 )
 
 type valueType string
@@ -22,6 +26,12 @@ type schema struct {
 }
 
 func (s *schema) String() string {
+	if s.isArray() {
+		return fmt.Sprintf("%s[%s]", s.typeName, s.items)
+	}
+	if s.isObject() {
+		return fmt.Sprintf("%s{%v}", s.typeName, maps.Keys(s.properties))
+	}
 	return string(s.typeName)
 }
 
@@ -37,6 +47,10 @@ func (s *schema) isArray() bool {
 	return s != nil && s.typeName == typeArray
 }
 
+func (s *schema) isObject() bool {
+	return s != nil && s.typeName == typeObject
+}
+
 var (
 	schemaBool   = newSchema(typeBool)
 	schemaNumber = newSchema(typeNumber)
@@ -270,8 +284,18 @@ func (i *typeChecker) run(ast *Node, value any) (*schema, Error) {
 		if err != nil {
 			return nil, err
 		}
-		if !leftType.isArray() {
-			return nil, NewError(ast.Offset, ast.Length, "where clause requires an array, but found %s", leftType)
+		if leftType.isObject() {
+			keys := maps.Keys(leftType.properties)
+			sort.Strings(keys)
+			if len(keys) > 0 {
+				// Pick the first prop as the representative item type.
+				prop := leftType.properties[keys[0]]
+				leftType = newSchema(typeArray)
+				leftType.items = prop
+			}
+		}
+		if !leftType.isArray() || leftType.items == nil {
+			return nil, NewError(ast.Offset, ast.Length, "where clause requires a non-empty array or object, but found %s", leftType)
 		}
 		// In an unquoted string scenario it makes no sense for the first/only
 		// token after a `where` clause to be treated as a string. Instead we
@@ -289,5 +313,5 @@ func (i *typeChecker) run(ast *Node, value any) (*schema, Error) {
 		}
 		return schemaBool, nil
 	}
-	return nil, NewError(ast.Offset, ast.Length, "unexpected node")
+	return nil, NewError(ast.Offset, ast.Length, "unexpected node %v", ast)
 }