Add type checks

This commits implements more advance type checks in strict mode.
To enter strict mode set variable types with expr.Define() or
expr.With() functions.

Author: antonmedv

README.md

@@ -24,8 +24,8 @@ Inspired by
 ## Features
 
 * Works with any valid Go object (structs, maps, etc)
-* Compile-time checks for used variables
-* Сlear error messages:
+* Strict mode with type checks
+* User-friendly error messages
   ```
   unclosed "("
   (boo + bar]
@@ -48,3 +48,4 @@ go get -u github.com/antonmedv/expr
 ## License
 
 MIT
+

bench_test.go

@@ -1,8 +1,9 @@
-package expr
+package expr_test
 
 import (
 	"testing"
 
+	"github.com/antonmedv/expr"
 	"github.com/dop251/goja"
 	"github.com/robertkrimen/otto"
 )
@@ -30,13 +31,13 @@ func Benchmark_expr(b *testing.B) {
 		Marker: "test",
 	}
 
-	script, err := Parse(`Segments[0].Origin == "MOW" && Passengers.Adults == 2 && Marker == "test"`)
+	script, err := expr.Parse(`Segments[0].Origin == "MOW" && Passengers.Adults == 2 && Marker == "test"`)
 	if err != nil {
 		b.Fatal(err)
 	}
 
 	for n := 0; n < b.N; n++ {
-		Run(script, r)
+		expr.Run(script, r)
 	}
 }
 

doc.go

@@ -42,10 +42,10 @@ For example you can pass nested structures without any modification or preparati
 		Cookies   []Cookie
 	}
 	type Request struct {
-		User user
+		User *user
 	}
 
-	req := Request{User{
+	req := Request{&User{
 		Cookies:   []Cookie{{"origin", "www"}},
 		UserAgent: "Firefox",
 	}}
@@ -71,39 +71,53 @@ You can also pass functions into the expression:
 	ok, err := expr.Eval(`"www" in Values(Request.User.Cookies)`, data)
 
 
-Caching
+Parsing and caching
 
-If you planning to execute some expression lots times, it's good to compile it first and only one time:
+If you planning to execute some expression lots times, it's good to parse it first and only one time:
+
+	// Parse expression to AST.
+	ast, err := expr.Parse(expression)
+
+	// Run given AST
+	ok, err := expr.Run(ast, data)
 
-	// Precompile
-	node, err := expr.Parse(expression)
 
-	// Run
-	ok, err := expr.Run(node, data)
+Strict mode
 
+Expr package support strict parse mode in which some type checks performed during parsing.
+To parse expression in strict mode, define all of used variables:
 
-Checking variables and functions
 
-It is possible to check used variables and functions during parsing of the expression.
+	expression := `Request.User.UserAgent matches "Firefox"`
+	node, err := expr.Parse(expression, expr.Define("Request", request{}))
 
 
-	expression := `Request.User.UserAgent matches "Firefox" && "www" in Values(Request.User.Cookies)`
+Parse function will check used variables, accessed filed, logical operators and some other type checks.
 
-	node, err := expr.Parse(expression, expr.Names("Request"), expr.Funcs("Values"))
+If you try to use some undeclared variables, or access unknown field, an error will be returned during paring:
 
+	expression := `Request.User.Cookies[0].Timestamp`
+	node, err := expr.Parse(expression, expr.Define("Request", request{}))
 
-Only `Request` and `Values` will be available inside expression, otherwise parse error.
+	// err: Request.User.Cookies[0].Timestamp undefined (type expr_test.cookie has no field Timestamp)
 
-If you try to use some undeclared variables or functions, an error will be returned during compilation:
+Also it's possible to define all used variables and functions using expr.With and struct:
+
+	type payload struct {
+		Request *Request
+		Values  func(xs []Cookie) []string
+	}
 
-	expression := `Unknown(Request.User.UserAgent)`
-	node, err := expr.Parse(expression, expr.Names("Request"), expr.Funcs("Values"))
+	node, err := expr.Parse(expression, expr.With(payload{}))
 
-	// err.Error():
+Or with map:
+
+	data := map[string]interface{}{
+		"Request": req,
+		"Values": func(xs []Cookie) []string {...},
+	}
 
-	unknown func Unknown
-			Unknown(Request.User.UserAgent)
-			-------^
+	node, err := expr.Parse(expression, expr.With(data))
 
 
 Printing

doc_test.go

@@ -16,6 +16,7 @@ func ExampleEval() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: hello world
 }
 
@@ -36,6 +37,7 @@ func ExampleEval_map() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: hello user
 }
 
@@ -54,6 +56,7 @@ func ExampleEval_struct() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: 42
 }
 
@@ -66,6 +69,7 @@ func ExampleEval_error() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: err: unclosed "("
 	//(boo + bar]
 	//----------^
@@ -80,6 +84,7 @@ func ExampleEval_matches() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: err: error parsing regexp: missing closing ): `a(`
 	//"a" matches "a("
 	//----------------^
@@ -106,6 +111,7 @@ func ExampleParse() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: true
 }
 
@@ -130,33 +136,76 @@ func ExampleRun() {
 	}
 
 	fmt.Printf("%v", output)
+
 	// Output: false
 }
 
-func ExampleNames() {
-	_, err := expr.Parse("foo + bar + baz", expr.Names("foo", "bar"))
+func ExampleDefine() {
+	var foo, bar int
+	_, err := expr.Parse("foo + bar + baz", expr.Define("foo", foo), expr.Define("bar", bar))
 
 	if err != nil {
 		fmt.Printf("err: %v", err)
 		return
 	}
 
 	// Output: err: unknown name baz
-	//foo + bar + baz
-	//------------^
+}
+
+func ExampleWith() {
+	type segment struct {
+		Origin string
+	}
+	type passengers struct {
+		Adults int
+	}
+	type request struct {
+		Segments   []*segment
+		Passengers *passengers
+		Marker     string
+		Meta       map[string]interface{}
+	}
+
+	code := `Segments[0].Origin == "MOW" && Passengers.Adults == 2 && Marker == "test" && Meta["accept"]`
+	ast, err := expr.Parse(code, expr.With(&request{}))
+
+	if err != nil {
+		fmt.Printf("err: %v", err)
+		return
+	}
+
+	r := &request{
+		Segments: []*segment{
+			{Origin: "MOW"},
+		},
+		Passengers: &passengers{
+			Adults: 2,
+		},
+		Marker: "test",
+		Meta:   map[string]interface{}{"accept": true},
+	}
+	output, err := expr.Run(ast, r)
+
+	if err != nil {
+		fmt.Printf("err: %v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+
+	// Output: true
 }
 
 func ExampleFuncs() {
-	_, err := expr.Parse("foo(bar(baz()))", expr.Funcs("foo", "bar"))
+	var foo, bar func()
+	_, err := expr.Parse("foo(bar(baz()))", expr.Define("foo", foo), expr.Define("bar", bar))
 
 	if err != nil {
 		fmt.Printf("err: %v", err)
 		return
 	}
 
-	// Output: err: unknown func baz
-	//foo(bar(baz()))
-	//--------^
+	// Output: err: unknown func baz()
 }
 
 func ExampleNode() {
@@ -168,5 +217,6 @@ func ExampleNode() {
 	}
 
 	fmt.Printf("%v", node)
+
 	// Output: foo.bar
 }