Merge branch 'expr-lang:master' into master

Author: zhuliquan

.gitattributes

@@ -0,0 +1 @@
+*\[generated\].go linguist-language=txt

.github/scripts/coverage.mjs

@@ -2,13 +2,15 @@
 
 const expected = 90
 const exclude = [
-  'expr/test',
-  'checker/mock',
-  'vm/func_types',
-  'vm/runtime/helpers',
-  'internal/difflib',
-  'internal/spew',
-  'internal/testify',
+  'expr/test', // We do not need to test the test package.
+  'checker/mock', // Mocks only used for testing.
+  'vm/func_types', // Generated files.
+  'vm/runtime/helpers', // Generated files.
+  'internal/difflib', // Test dependency. This is vendored dependency, and ideally we also have good tests for it.
+  'internal/spew', // Test dependency.
+  'internal/testify', // Test dependency.
+  'patcher/value', // Contains a lot of repeating code. Ideally we should have a test for it.
+  'pro', // Expr Pro is not a part of the main codebase.
 ]
 
 cd(path.resolve(__dirname, '..', '..'))

.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.22' ]
+        go-versions: [ '1.18', '1.22', '1.24' ]
         go-arch: [ '386' ]
     steps:
       - uses: actions/checkout@v3

.github/workflows/diff.yml

@@ -13,7 +13,9 @@ jobs:
         with:
           go-version: 1.18
       - name: Install benchstat
-        run: go install golang.org/x/perf/cmd/benchstat@latest
+        # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref
+        # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292
+        run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d
 
       - uses: actions/checkout@v3
       - name: Benchmark new code

.github/workflows/fuzz.yml

@@ -21,14 +21,14 @@ jobs:
           fuzz-seconds: 600
           output-sarif: true
       - name: Upload Crash
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         if: failure() && steps.build.outcome == 'success'
         with:
           name: artifacts
           path: ./out/artifacts
       - name: Upload Sarif
         if: always() && steps.build.outcome == 'success'
-        uses: github/codeql-action/upload-sarif@v2
+        uses: github/codeql-action/upload-sarif@v3
         with:
           # Path to SARIF file relative to the root of the repository
           sarif_file: cifuzz-sarif/results.sarif

.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}

README.md

@@ -162,9 +162,14 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
-* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
+* [Span Digital](https://spandigital.com/) uses Expr in its Knowledge Management products.
 * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery.
 * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language.
+* [Tork](https://www.tork.run/) integrates Expr into its workflow execution.
+* [Critical Moments](https://criticalmoments.io) uses Expr for its mobile realtime conditional targeting system.
+* [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate).
+* [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system.
+* [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

ast/find.go

@@ -0,0 +1,18 @@
+package ast
+
+func Find(node Node, fn func(node Node) bool) Node {
+	v := &finder{fn: fn}
+	Walk(&node, v)
+	return v.node
+}
+
+type finder struct {
+	node Node
+	fn   func(node Node) bool
+}
+
+func (f *finder) Visit(node *Node) {
+	if f.fn(*node) {
+		f.node = *node
+	}
+}

ast/find_test.go

@@ -0,0 +1,31 @@
+package ast_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr/internal/testify/require"
+
+	"github.com/expr-lang/expr/ast"
+)
+
+func TestFind(t *testing.T) {
+	left := &ast.IdentifierNode{
+		Value: "a",
+	}
+	var root ast.Node = &ast.BinaryNode{
+		Operator: "+",
+		Left:     left,
+		Right: &ast.IdentifierNode{
+			Value: "b",
+		},
+	}
+
+	x := ast.Find(root, func(node ast.Node) bool {
+		if n, ok := node.(*ast.IdentifierNode); ok {
+			return n.Value == "a"
+		}
+		return false
+	})
+
+	require.Equal(t, left, x)
+}

ast/node.go

@@ -216,6 +216,13 @@ type VariableDeclaratorNode struct {
 	Expr  Node   // Expression of the variable. Like "foo + 1" in "let foo = 1; foo + 1".
 }
 
+// SequenceNode represents a sequence of nodes separated by semicolons.
+// All nodes are executed, only the last node will be returned.
+type SequenceNode struct {
+	base
+	Nodes []Node
+}
+
 // ArrayNode represents an array.
 type ArrayNode struct {
 	base

ast/print.go

@@ -50,8 +50,13 @@ func (n *UnaryNode) String() string {
 		op = fmt.Sprintf("%s ", n.Operator)
 	}
 	wrap := false
-	switch n.Node.(type) {
-	case *BinaryNode, *ConditionalNode:
+	switch b := n.Node.(type) {
+	case *BinaryNode:
+		if operator.Binary[b.Operator].Precedence <
+			operator.Unary[n.Operator].Precedence {
+			wrap = true
+		}
+	case *ConditionalNode:
 		wrap = true
 	}
 	if wrap {
@@ -68,10 +73,21 @@ func (n *BinaryNode) String() string {
 	var lhs, rhs string
 	var lwrap, rwrap bool
 
+	if l, ok := n.Left.(*UnaryNode); ok {
+		if operator.Unary[l.Operator].Precedence <
+			operator.Binary[n.Operator].Precedence {
+			lwrap = true
+		}
+	}
 	if lb, ok := n.Left.(*BinaryNode); ok {
 		if operator.Less(lb.Operator, n.Operator) {
 			lwrap = true
 		}
+		if operator.Binary[lb.Operator].Precedence ==
+			operator.Binary[n.Operator].Precedence &&
+			operator.Binary[n.Operator].Associativity == operator.Right {
+			lwrap = true
+		}
 		if lb.Operator == "??" {
 			lwrap = true
 		}
@@ -83,6 +99,11 @@ func (n *BinaryNode) String() string {
 		if operator.Less(rb.Operator, n.Operator) {
 			rwrap = true
 		}
+		if operator.Binary[rb.Operator].Precedence ==
+			operator.Binary[n.Operator].Precedence &&
+			operator.Binary[n.Operator].Associativity == operator.Left {
+			rwrap = true
+		}
 		if operator.IsBoolean(rb.Operator) && n.Operator != rb.Operator {
 			rwrap = true
 		}
@@ -177,6 +198,14 @@ func (n *VariableDeclaratorNode) String() string {
 	return fmt.Sprintf("let %s = %s; %s", n.Name, n.Value.String(), n.Expr.String())
 }
 
+func (n *SequenceNode) String() string {
+	nodes := make([]string, len(n.Nodes))
+	for i, node := range n.Nodes {
+		nodes[i] = node.String()
+	}
+	return strings.Join(nodes, "; ")
+}
+
 func (n *ConditionalNode) String() string {
 	var cond, exp1, exp2 string
 	if _, ok := n.Cond.(*ConditionalNode); ok {

ast/print_test.go

@@ -78,6 +78,12 @@ func TestPrint(t *testing.T) {
 		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 		{`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`},
 		{`not (a == 1 ? b > 1 : b < 2)`, `not (a == 1 ? b > 1 : b < 2)`},
+		{`(-(1+1)) ** 2`, `(-(1 + 1)) ** 2`},
+		{`2 ** (-(1+1))`, `2 ** -(1 + 1)`},
+		{`(2 ** 2) ** 3`, `(2 ** 2) ** 3`},
+		{`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`},
+		{`(-(1+1)) == 2`, `-(1 + 1) == 2`},
+		{`if true { 1 } else { 2 }`, `true ? 1 : 2`},
 	}
 
 	for _, tt := range tests {

ast/visitor.go

@@ -51,6 +51,10 @@ func Walk(node *Node, v Visitor) {
 	case *VariableDeclaratorNode:
 		Walk(&n.Value, v)
 		Walk(&n.Expr, v)
+	case *SequenceNode:
+		for i := range n.Nodes {
+			Walk(&n.Nodes[i], v)
+		}
 	case *ConditionalNode:
 		Walk(&n.Cond, v)
 		Walk(&n.Exp1, v)

builtin/builtin.go

@@ -830,6 +830,57 @@ var Builtins = []*Function{
 			}
 		},
 	},
+
+	{
+		Name: "uniq",
+		Func: func(args ...any) (any, error) {
+			if len(args) != 1 {
+				return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			v := reflect.ValueOf(deref.Deref(args[0]))
+			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
+				return nil, fmt.Errorf("cannot uniq %s", v.Kind())
+			}
+
+			size := v.Len()
+			ret := []any{}
+
+			eq := func(i int) bool {
+				for _, r := range ret {
+					if runtime.Equal(v.Index(i).Interface(), r) {
+						return true
+					}
+				}
+
+				return false
+			}
+
+			for i := 0; i < size; i += 1 {
+				if eq(i) {
+					continue
+				}
+
+				ret = append(ret, v.Index(i).Interface())
+			}
+
+			return ret, nil
+		},
+
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			switch kind(args[0]) {
+			case reflect.Interface, reflect.Slice, reflect.Array:
+				return arrayType, nil
+			default:
+				return anyType, fmt.Errorf("cannot uniq %s", args[0])
+			}
+		},
+	},
+
 	{
 		Name: "concat",
 		Safe: func(args ...any) (any, uint, error) {
@@ -873,6 +924,37 @@ var Builtins = []*Function{
 			return arrayType, nil
 		},
 	},
+	{
+		Name: "flatten",
+		Safe: func(args ...any) (any, uint, error) {
+			var size uint
+			if len(args) != 1 {
+				return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+			v := reflect.ValueOf(deref.Deref(args[0]))
+			if v.Kind() != reflect.Array && v.Kind() != reflect.Slice {
+				return nil, size, fmt.Errorf("cannot flatten %s", v.Kind())
+			}
+			ret := flatten(v)
+			size = uint(len(ret))
+			return ret, size, nil
+		},
+		Validate: func(args []reflect.Type) (reflect.Type, error) {
+			if len(args) != 1 {
+				return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args))
+			}
+
+			for _, arg := range args {
+				switch kind(deref.Type(arg)) {
+				case reflect.Interface, reflect.Slice, reflect.Array:
+				default:
+					return anyType, fmt.Errorf("cannot flatten %s", arg)
+				}
+			}
+
+			return arrayType, nil
+		},
+	},
 	{
 		Name: "sort",
 		Safe: func(args ...any) (any, uint, error) {

builtin/builtin_test.go

@@ -152,6 +152,11 @@ func TestBuiltin(t *testing.T) {
 		{`reduce([], 5, 0)`, 0},
 		{`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}},
 		{`concat(PtrArrayWithNil, [nil])`, []any{42, nil}},
+		{`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}},
+		{`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}},
+		{`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}},
+		{`uniq([1, 15, "a", 2, 3, 5, 2, "a", 2, "b"])`, []any{1, 15, "a", 2, 3, 5, "b"}},
+		{`uniq([[1, 2], "a", 2, 3, [1, 2], [1, 3]])`, []any{[]any{1, 2}, "a", 2, 3, []any{1, 3}}},
 	}
 
 	for _, test := range tests {
@@ -236,6 +241,8 @@ func TestBuiltin_errors(t *testing.T) {
 		{`now(nil)`, "invalid number of arguments (expected 0, got 1)"},
 		{`date(nil)`, "interface {} is nil, not string (1:1)"},
 		{`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
+		{`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"},
+		{`flatten(1)`, "cannot flatten int"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {

builtin/lib.go

@@ -5,15 +5,18 @@ import (
 	"math"
 	"reflect"
 	"strconv"
+	"unicode/utf8"
 
 	"github.com/expr-lang/expr/internal/deref"
 )
 
 func Len(x any) any {
 	v := reflect.ValueOf(x)
 	switch v.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+	case reflect.Array, reflect.Slice, reflect.Map:
 		return v.Len()
+	case reflect.String:
+		return utf8.RuneCountInString(v.String())
 	default:
 		panic(fmt.Sprintf("invalid argument for len (type %T)", x))
 	}
@@ -359,3 +362,17 @@ func median(args ...any) ([]float64, error) {
 	}
 	return values, nil
 }
+
+func flatten(arg reflect.Value) []any {
+	ret := []any{}
+	for i := 0; i < arg.Len(); i++ {
+		v := deref.Value(arg.Index(i))
+		if v.Kind() == reflect.Array || v.Kind() == reflect.Slice {
+			x := flatten(v)
+			ret = append(ret, x...)
+		} else {
+			ret = append(ret, v.Interface())
+		}
+	}
+	return ret
+}