refactor: have script tokens compile expression

update expression, script, and filter tokens to compile
expression when created and not runtime

Author: evilmonkeyinc

token/expression.go

@@ -7,18 +7,23 @@ import (
 	"github.com/evilmonkeyinc/jsonpath/script"
 )
 
-func newExpressionToken(expression string, engine script.Engine, options *option.QueryOptions) *expressionToken {
-	return &expressionToken{
-		expression: expression,
-		engine:     engine,
-		options:    options,
+func newExpressionToken(expression string, engine script.Engine, options *option.QueryOptions) (*expressionToken, error) {
+	compiledExpression, err := engine.Compile(expression, options)
+	if err != nil {
+		return nil, err
 	}
+
+	return &expressionToken{
+		expression:         expression,
+		compiledExpression: compiledExpression,
+		options:            options,
+	}, nil
 }
 
 type expressionToken struct {
-	expression string
-	engine     script.Engine
-	options    *option.QueryOptions
+	expression         string
+	compiledExpression script.CompiledExpression
+	options            *option.QueryOptions
 }
 
 func (token *expressionToken) String() string {
@@ -34,7 +39,7 @@ func (token *expressionToken) Apply(root, current interface{}, next []Token) (in
 		return nil, getInvalidExpressionEmptyError()
 	}
 
-	value, err := token.engine.Evaluate(root, current, token.expression, token.options)
+	value, err := token.compiledExpression.Evaluate(root, current)
 	if err != nil {
 		return nil, getInvalidExpressionError(err)
 	}

token/expression_test.go

@@ -36,7 +36,16 @@ func (engine *testCompiledExpression) Evaluate(root, current interface{}) (inter
 var _ Token = &expressionToken{}
 
 func Test_newExpressionToken(t *testing.T) {
-	assert.IsType(t, &expressionToken{}, newExpressionToken("", nil, nil))
+	t.Run("success", func(t *testing.T) {
+		actual, err := newExpressionToken("", &testEngine{}, nil)
+		assert.Nil(t, err)
+		assert.IsType(t, &expressionToken{}, actual)
+	})
+	t.Run("fail", func(t *testing.T) {
+		actual, err := newExpressionToken("", &testEngine{err: fmt.Errorf("fail")}, nil)
+		assert.EqualError(t, err, "fail")
+		assert.Nil(t, actual)
+	})
 }
 
 func Test_ExpressionToken_String(t *testing.T) {
@@ -75,8 +84,8 @@ func Test_ExpressionToken_Apply(t *testing.T) {
 		},
 		{
 			token: &expressionToken{
-				expression: "any",
-				engine:     &testEngine{err: fmt.Errorf("engine error")},
+				expression:         "any",
+				compiledExpression: &testCompiledExpression{err: fmt.Errorf("engine error")},
 			},
 			input: input{},
 			expected: expected{
@@ -85,8 +94,8 @@ func Test_ExpressionToken_Apply(t *testing.T) {
 		},
 		{
 			token: &expressionToken{
-				expression: "any",
-				engine:     &testEngine{response: true},
+				expression:         "any",
+				compiledExpression: &testCompiledExpression{response: true},
 			},
 			input: input{},
 			expected: expected{
@@ -95,8 +104,8 @@ func Test_ExpressionToken_Apply(t *testing.T) {
 		},
 		{
 			token: &expressionToken{
-				expression: "any",
-				engine:     &testEngine{response: false},
+				expression:         "any",
+				compiledExpression: &testCompiledExpression{response: false},
 			},
 			input: input{
 				tokens: []Token{&currentToken{}},

token/filter.go

@@ -9,14 +9,22 @@ import (
 	"github.com/evilmonkeyinc/jsonpath/script"
 )
 
-func newFilterToken(expression string, engine script.Engine, options *option.QueryOptions) *filterToken {
-	return &filterToken{expression: expression, engine: engine, options: options}
+func newFilterToken(expression string, engine script.Engine, options *option.QueryOptions) (*filterToken, error) {
+	compiledExpression, err := engine.Compile(expression, options)
+	if err != nil {
+		return nil, err
+	}
+	return &filterToken{
+		expression:         expression,
+		compiledExpression: compiledExpression,
+		options:            options,
+	}, nil
 }
 
 type filterToken struct {
-	expression string
-	engine     script.Engine
-	options    *option.QueryOptions
+	expression         string
+	compiledExpression script.CompiledExpression
+	options            *option.QueryOptions
 }
 
 func (token *filterToken) String() string {
@@ -69,11 +77,6 @@ func (token *filterToken) Apply(root, current interface{}, next []Token) (interf
 		return nil, getInvalidTokenTargetNilError(token.Type(), reflect.Array, reflect.Map, reflect.Slice)
 	}
 
-	compiledExpression, err := token.engine.Compile(token.expression, token.options)
-	if err != nil {
-		return nil, getInvalidExpressionError(err)
-	}
-
 	switch objType.Kind() {
 	case reflect.Map:
 		keys := objVal.MapKeys()
@@ -82,7 +85,7 @@ func (token *filterToken) Apply(root, current interface{}, next []Token) (interf
 		for _, kv := range keys {
 			element := objVal.MapIndex(kv).Interface()
 
-			evaluation, err := compiledExpression.Evaluate(root, element)
+			evaluation, err := token.compiledExpression.Evaluate(root, element)
 			if err != nil {
 				// we ignore errors, it has failed evaluation
 				evaluation = nil
@@ -98,7 +101,7 @@ func (token *filterToken) Apply(root, current interface{}, next []Token) (interf
 		for i := 0; i < length; i++ {
 			element := objVal.Index(i).Interface()
 
-			evaluation, err := compiledExpression.Evaluate(root, element)
+			evaluation, err := token.compiledExpression.Evaluate(root, element)
 			if err != nil {
 				// we ignore errors, it has failed evaluation
 				evaluation = nil