feat: improve defaut compiler

Signed-off-by: Charles-Edouard Brétéché <charles.edouard@nirmata.com>

pkg/apis/policy/v1alpha1/assertion_tree.go

@@ -22,8 +22,8 @@ func NewAssertionTree(value any) AssertionTree {
 	}
 }
 
-func (t *AssertionTree) Compile(compiler func(string, any) (assertion.Assertion, error)) (assertion.Assertion, error) {
-	return compiler(t._hash, t._tree)
+func (t *AssertionTree) Compile(compiler func(string, any, string) (assertion.Assertion, error), defaultCompiler string) (assertion.Assertion, error) {
+	return compiler(t._hash, t._tree, defaultCompiler)
 }
 
 func (a *AssertionTree) MarshalJSON() ([]byte, error) {

pkg/core/assertion/assertion.go

@@ -19,14 +19,14 @@ type Assertion interface {
 	Assert(*field.Path, any, binding.Bindings) (field.ErrorList, error)
 }
 
-func Parse(assertion any, compiler compilers.Compilers) (node, error) {
+func Parse(assertion any, compiler compilers.Compilers, defaultCompiler string) (node, error) {
 	switch reflectutils.GetKind(assertion) {
 	case reflect.Slice:
-		return parseSlice(assertion, compiler)
+		return parseSlice(assertion, compiler, defaultCompiler)
 	case reflect.Map:
-		return parseMap(assertion, compiler)
+		return parseMap(assertion, compiler, defaultCompiler)
 	default:
-		return parseScalar(assertion, compiler)
+		return parseScalar(assertion, compiler, defaultCompiler)
 	}
 }
 
@@ -40,11 +40,11 @@ func (n node) Assert(path *field.Path, value any, bindings binding.Bindings) (fi
 // parseSlice is the assertion represented by a slice.
 // it first compares the length of the analysed resource with the length of the descendants.
 // if lengths match all descendants are evaluated with their corresponding items.
-func parseSlice(assertion any, compiler compilers.Compilers) (node, error) {
+func parseSlice(assertion any, compiler compilers.Compilers, defaultCompiler string) (node, error) {
 	var assertions []node
 	valueOf := reflect.ValueOf(assertion)
 	for i := 0; i < valueOf.Len(); i++ {
-		sub, err := Parse(valueOf.Index(i).Interface(), compiler)
+		sub, err := Parse(valueOf.Index(i).Interface(), compiler, defaultCompiler)
 		if err != nil {
 			return nil, err
 		}
@@ -76,7 +76,7 @@ func parseSlice(assertion any, compiler compilers.Compilers) (node, error) {
 
 // parseMap is the assertion represented by a map.
 // it is responsible for projecting the analysed resource and passing the result to the descendant
-func parseMap(assertion any, compiler compilers.Compilers) (node, error) {
+func parseMap(assertion any, compiler compilers.Compilers, defaultCompiler string) (node, error) {
 	assertions := map[any]struct {
 		projection.Projection
 		node
@@ -85,13 +85,13 @@ func parseMap(assertion any, compiler compilers.Compilers) (node, error) {
 	for iter.Next() {
 		key := iter.Key().Interface()
 		value := iter.Value().Interface()
-		assertion, err := Parse(value, compiler)
+		assertion, err := Parse(value, compiler, defaultCompiler)
 		if err != nil {
 			return nil, err
 		}
 		entry := assertions[key]
 		entry.node = assertion
-		entry.Projection = projection.Parse(key, compiler)
+		entry.Projection = projection.Parse(key, compiler, defaultCompiler)
 		assertions[key] = entry
 	}
 	return func(path *field.Path, value any, bindings binding.Bindings) (field.ErrorList, error) {
@@ -161,21 +161,20 @@ func parseMap(assertion any, compiler compilers.Compilers) (node, error) {
 // parseScalar is the assertion represented by a leaf.
 // it receives a value and compares it with an expected value.
 // the expected value can be the result of an expression.
-func parseScalar(assertion any, compiler compilers.Compilers) (node, error) {
+func parseScalar(assertion any, compiler compilers.Compilers, defaultCompiler string) (node, error) {
 	var project func(value any, bindings binding.Bindings) (any, error)
 	switch typed := assertion.(type) {
 	case string:
-		expr := expression.Parse(typed)
+		expr := expression.Parse(defaultCompiler, typed)
 		if expr.Foreach {
 			return nil, errors.New("foreach is not supported on the RHS")
 		}
 		if expr.Binding != "" {
 			return nil, errors.New("binding is not supported on the RHS")
 		}
-		switch expr.Engine {
-		case expression.EngineJP:
+		if compiler := compiler.Compiler(expr.Compiler); compiler != nil {
 			parse := sync.OnceValues(func() (compilers.Program, error) {
-				return compiler.Jp.Compile(expr.Statement)
+				return compiler.Compile(expr.Statement)
 			})
 			project = func(value any, bindings binding.Bindings) (any, error) {
 				program, err := parse()
@@ -184,15 +183,7 @@ func parseScalar(assertion any, compiler compilers.Compilers) (node, error) {
 				}
 				return program(value, bindings)
 			}
-		case expression.EngineCEL:
-			project = func(value any, bindings binding.Bindings) (any, error) {
-				program, err := compiler.Cel.Compile(expr.Statement)
-				if err != nil {
-					return nil, err
-				}
-				return program(value, bindings)
-			}
-		default:
+		} else {
 			assertion = expr.Statement
 		}
 	}

pkg/core/assertion/assertion_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/jmespath-community/go-jmespath/pkg/binding"
 	"github.com/kyverno/kyverno-json/pkg/core/compilers"
+	"github.com/kyverno/kyverno-json/pkg/core/expression"
 	tassert "github.com/stretchr/testify/assert"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 )
@@ -49,7 +50,7 @@ func TestAssert(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			compiler := compilers.DefaultCompiler
-			parsed, err := Parse(tt.assertion, compiler)
+			parsed, err := Parse(tt.assertion, compiler, expression.CompilerJP)
 			tassert.NoError(t, err)
 			got, err := parsed.Assert(nil, tt.value, tt.bindings)
 			if tt.wantErr {

pkg/core/compilers/compiler.go

@@ -1,5 +1,19 @@
 package compilers
 
+import (
+	"github.com/jmespath-community/go-jmespath/pkg/binding"
+)
+
+type Program = func(any, binding.Bindings) (any, error)
+
 type Compiler interface {
 	Compile(string) (Program, error)
 }
+
+func Execute(statement string, value any, bindings binding.Bindings, compiler Compiler) (any, error) {
+	program, err := compiler.Compile(statement)
+	if err != nil {
+		return nil, err
+	}
+	return program(value, bindings)
+}

pkg/core/compilers/compilers.go

@@ -20,27 +20,40 @@ type Compilers struct {
 	Cel cel.Compiler
 }
 
-func (c Compilers) NewBinding(path *field.Path, value any, bindings binding.Bindings, template any) binding.Binding {
+func (c Compilers) Compiler(compiler string) Compiler {
+	switch compiler {
+	case "":
+		return nil
+	case expression.CompilerJP:
+		return c.Jp
+	case expression.CompilerCEL:
+		return c.Cel
+	default:
+		return c.Jp
+	}
+}
+
+func (c Compilers) NewBinding(path *field.Path, value any, bindings binding.Bindings, template any, compiler string) binding.Binding {
 	return binding.NewDelegate(
 		sync.OnceValues(
 			func() (any, error) {
 				switch typed := template.(type) {
 				case string:
-					expr := expression.Parse(typed)
+					expr := expression.Parse(compiler, typed)
 					if expr.Foreach {
 						return nil, field.Invalid(path.Child("variable"), typed, "foreach is not supported in context")
 					}
 					if expr.Binding != "" {
 						return nil, field.Invalid(path.Child("variable"), typed, "binding is not supported in context")
 					}
-					switch expr.Engine {
-					case expression.EngineJP:
+					switch expr.Compiler {
+					case expression.CompilerJP:
 						projected, err := Execute(expr.Statement, value, bindings, c.Jp)
 						if err != nil {
 							return nil, field.InternalError(path.Child("variable"), err)
 						}
 						return projected, nil
-					case expression.EngineCEL:
+					case expression.CompilerCEL:
 						projected, err := Execute(expr.Statement, value, bindings, c.Cel)
 						if err != nil {
 							return nil, field.InternalError(path.Child("variable"), err)

pkg/core/expression/expression.go

@@ -4,28 +4,27 @@ import (
 	"regexp"
 )
 
-var (
-	foreachRegex = regexp.MustCompile(`^~(\w+)?\.(.*)`)
-	bindingRegex = regexp.MustCompile(`(.*)\s*->\s*(\w+)$`)
-	escapeRegex  = regexp.MustCompile(`^\\(.+)\\$`)
-	engineRegex  = regexp.MustCompile(`^\((?:(\w+);)?(.+)\)$`)
+const (
+	CompilerJP  = "jp"
+	CompilerCEL = "cel"
 )
 
-const (
-	EngineJP      = "jp"
-	EngineCEL     = "cel"
-	EngineDefault = EngineJP
+var (
+	foreachRegex  = regexp.MustCompile(`^~(\w+)?\.(.*)`)
+	bindingRegex  = regexp.MustCompile(`(.*)\s*->\s*(\w+)$`)
+	escapeRegex   = regexp.MustCompile(`^\\(.+)\\$`)
+	compilerRegex = regexp.MustCompile(`^\((?:(\w+);)?(.+)\)$`)
 )
 
 type Expression struct {
 	Foreach     bool
 	ForeachName string
 	Statement   string
 	Binding     string
-	Engine      string
+	Compiler    string
 }
 
-func Parse(in string) (expression Expression) {
+func Parse(compiler string, in string) (expression Expression) {
 	// 1. match foreach
 	if match := foreachRegex.FindStringSubmatch(in); match != nil {
 		expression.Foreach = true
@@ -41,11 +40,11 @@ func Parse(in string) (expression Expression) {
 	if match := escapeRegex.FindStringSubmatch(in); match != nil {
 		in = match[1]
 	} else {
-		if match := engineRegex.FindStringSubmatch(in); match != nil {
-			expression.Engine = match[1]
+		if match := compilerRegex.FindStringSubmatch(in); match != nil {
+			expression.Compiler = match[1]
 			// account for default engine
-			if expression.Engine == "" {
-				expression.Engine = EngineDefault
+			if expression.Compiler == "" {
+				expression.Compiler = compiler
 			}
 			in = match[2]
 		}

pkg/core/expression/expression_test.go

@@ -30,7 +30,7 @@ func TestParse(t *testing.T) {
 			Foreach:     false,
 			ForeachName: "",
 			Statement:   "test",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "nested field",
@@ -47,7 +47,7 @@ func TestParse(t *testing.T) {
 			Foreach:     false,
 			ForeachName: "",
 			Statement:   "test.test",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "Foreach simple field",
@@ -64,7 +64,7 @@ func TestParse(t *testing.T) {
 			Foreach:     true,
 			ForeachName: "",
 			Statement:   "test",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "Foreach nested field",
@@ -73,7 +73,7 @@ func TestParse(t *testing.T) {
 			Foreach:     true,
 			ForeachName: "",
 			Statement:   "test.test",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "binding",
@@ -92,7 +92,7 @@ func TestParse(t *testing.T) {
 			ForeachName: "",
 			Statement:   "test",
 			Binding:     "foo",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "Foreach and binding",
@@ -111,7 +111,7 @@ func TestParse(t *testing.T) {
 			ForeachName: "",
 			Statement:   "test",
 			Binding:     "foo",
-			Engine:      EngineDefault,
+			Compiler:    CompilerJP,
 		},
 	}, {
 		name: "escape",
@@ -170,7 +170,7 @@ func TestParse(t *testing.T) {
 	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := Parse(tt.in)
+			got := Parse(CompilerJP, tt.in)
 			assert.Equal(t, tt.want, got)
 		})
 	}

pkg/core/projection/projection.go

@@ -24,23 +24,22 @@ type Projection struct {
 	Handler
 }
 
-func Parse(in any, compiler compilers.Compilers) (projection Projection) {
+func Parse(in any, compiler compilers.Compilers, defaultCompiler string) (projection Projection) {
 	switch typed := in.(type) {
 	case string:
 		// 1. if we have a string, parse the expression
-		expr := expression.Parse(typed)
+		expr := expression.Parse(defaultCompiler, typed)
 		// 2. record projection infos
 		projection.Foreach = expr.Foreach
 		projection.ForeachName = expr.ForeachName
 		projection.Binding = expr.Binding
 		// 3. compute the projection func
-		switch expr.Engine {
-		case expression.EngineJP:
-			parse := sync.OnceValues(func() (compilers.Program, error) {
-				return compiler.Jp.Compile(expr.Statement)
+		if compiler := compiler.Compiler(expr.Compiler); compiler != nil {
+			compile := sync.OnceValues(func() (compilers.Program, error) {
+				return compiler.Compile(expr.Statement)
 			})
 			projection.Handler = func(value any, bindings binding.Bindings) (any, bool, error) {
-				program, err := parse()
+				program, err := compile()
 				if err != nil {
 					return nil, false, err
 				}
@@ -50,19 +49,7 @@ func Parse(in any, compiler compilers.Compilers) (projection Projection) {
 				}
 				return projected, true, err
 			}
-		case expression.EngineCEL:
-			projection.Handler = func(value any, bindings binding.Bindings) (any, bool, error) {
-				program, err := compiler.Cel.Compile(expr.Statement)
-				if err != nil {
-					return nil, false, err
-				}
-				projected, err := program(value, bindings)
-				if err != nil {
-					return nil, false, err
-				}
-				return projected, true, nil
-			}
-		default:
+		} else {
 			projection.Handler = func(value any, bindings binding.Bindings) (any, bool, error) {
 				if value == nil {
 					return nil, false, nil