feat: support 'range' tpl function #12

Change-Id: I0999d3942850bbe1e1e07841c0a71e9ef31793a2

Author: andeya

README.md

@@ -139,6 +139,7 @@ NOTE: **The `exprName` under the same struct field cannot be the same！**
 |`regexp('^\\w*$', (X)$)`|Regular match the struct field X, return boolean|
 |`regexp('^\\w*$')`|Regular match the current struct field, return boolean|
 |`sprintf('X value: %v', (X)$)`|`fmt.Sprintf`, format the value of struct field X|
+|`range(KvExpr, forEachExpr)`|Iterate over an array, slice, or dictionary <br> - `#k` is the element key var <br> - `#v` is the element value var <br> - `##` is the number of elements <br> - e.g. [example](spec_range_test.go)|
 
 <!-- |`(X)$k`|Traverse each element key of the struct field X(type: map, slice, array)|
 |`(X)$v`|Traverse each element value of the struct field X(type: map, slice, array)| -->

expr.go

@@ -15,6 +15,7 @@
 package tagexpr
 
 import (
+	"context"
 	"fmt"
 )
 
@@ -44,7 +45,7 @@ func parseExpr(expr string) (*Expr, error) {
 
 // run calculates the value of expression.
 func (p *Expr) run(field string, tagExpr *TagExpr) interface{} {
-	return p.expr.Run(field, tagExpr)
+	return p.expr.Run(context.Background(), field, tagExpr)
 }
 
 func (p *Expr) parseOperand(expr *string) (e ExprNode) {
@@ -130,15 +131,18 @@ func (p *Expr) parseExprNode(expr *string, e ExprNode) (ExprNode, error) {
 	}
 	operand := p.readSelectorExprNode(expr)
 	if operand == nil {
-		var subExprNode *string
-		operand, subExprNode = readGroupExprNode(expr)
-		if operand != nil {
-			_, err := p.parseExprNode(subExprNode, operand)
-			if err != nil {
-				return nil, err
+		operand = p.readRangeKvExprNode(expr)
+		if operand == nil {
+			var subExprNode *string
+			operand, subExprNode = readGroupExprNode(expr)
+			if operand != nil {
+				_, err := p.parseExprNode(subExprNode, operand)
+				if err != nil {
+					return nil, err
+				}
+			} else {
+				operand = p.parseOperand(expr)
 			}
-		} else {
-			operand = p.parseOperand(expr)
 		}
 	}
 	if operand == nil {
@@ -252,7 +256,7 @@ type ExprNode interface {
 	RightOperand() ExprNode
 	SetLeftOperand(ExprNode)
 	SetRightOperand(ExprNode)
-	Run(string, *TagExpr) interface{}
+	Run(context.Context, string, *TagExpr) interface{}
 }
 
 var _ ExprNode = new(exprBackground)
@@ -287,4 +291,4 @@ func (eb *exprBackground) SetRightOperand(right ExprNode) {
 	eb.rightOperand = right
 }
 
-func (*exprBackground) Run(string, *TagExpr) interface{} { return nil }
+func (*exprBackground) Run(context.Context, string, *TagExpr) interface{} { return nil }

expr_test.go

@@ -67,13 +67,13 @@ func TestExpr(t *testing.T) {
 		{expr: "20%(7%5)", val: 0.0},
 		// Relational operator
 		{expr: "50 == 5", val: false},
-		{expr: "'50'==50", val: false},
+		{expr: "'50'==50", val: true},
 		{expr: "'50'=='50'", val: true},
 		{expr: "'50' =='5' == true", val: false},
 		{expr: "50== 50 == false", val: false},
 		{expr: "50== 50 == true ==true==true", val: true},
 		{expr: "50 != 5", val: true},
-		{expr: "'50'!=50", val: true},
+		{expr: "'50'!=50", val: false},
 		{expr: "'50'!= '50'", val: false},
 		{expr: "'50' !='5' != true", val: false},
 		{expr: "50!= 50 == false", val: true},
@@ -166,7 +166,7 @@ func TestBuiltInFunc(t *testing.T) {
 	}{
 		{expr: "len('abc')", val: 3.0},
 		{expr: "len('abc')+2*2/len('cd')", val: 5.0},
-		{expr: "len(0)", val: 0},
+		{expr: "len(0)", val: 0.0},
 
 		{expr: "regexp('a\\d','a0')", val: true},
 		{expr: "regexp('^a\\d$','a0')", val: true},

spec_func.go

@@ -15,6 +15,7 @@
 package tagexpr
 
 import (
+	"context"
 	"fmt"
 	"reflect"
 	"regexp"
@@ -44,44 +45,54 @@ func RegFunc(funcName string, fn func(...interface{}) interface{}, force ...bool
 	return nil
 }
 
-func newFunc(funcName string, fn func(...interface{}) interface{}) func(*Expr, *string) ExprNode {
+func (p *Expr) parseFuncSign(funcName string, expr *string) (boolOpposite *bool, signOpposite *bool, args []ExprNode, found bool) {
 	prefix := funcName + "("
 	length := len(funcName)
-	return func(p *Expr, expr *string) ExprNode {
-		last, boolOpposite := getBoolOpposite(expr)
-		if !strings.HasPrefix(last, prefix) {
-			return nil
+	last, boolOpposite, signOpposite := getBoolAndSignOpposite(expr)
+	if !strings.HasPrefix(last, prefix) {
+		return
+	}
+	*expr = last[length:]
+	lastStr := *expr
+	subExprNode := readPairedSymbol(expr, '(', ')')
+	if subExprNode == nil {
+		return
+	}
+	*subExprNode = "," + *subExprNode
+	for {
+		if strings.HasPrefix(*subExprNode, ",") {
+			*subExprNode = (*subExprNode)[1:]
+			operand := newGroupExprNode()
+			_, err := p.parseExprNode(trimLeftSpace(subExprNode), operand)
+			if err != nil {
+				*expr = lastStr
+				return
+			}
+			sortPriority(operand.RightOperand())
+			args = append(args, operand)
+		} else {
+			*expr = lastStr
+			return
+		}
+		trimLeftSpace(subExprNode)
+		if len(*subExprNode) == 0 {
+			found = true
+			return
 		}
-		*expr = last[length:]
-		lastStr := *expr
-		subExprNode := readPairedSymbol(expr, '(', ')')
-		if subExprNode == nil {
+	}
+}
+
+func newFunc(funcName string, fn func(...interface{}) interface{}) func(*Expr, *string) ExprNode {
+	return func(p *Expr, expr *string) ExprNode {
+		boolOpposite, signOpposite, args, found := p.parseFuncSign(funcName, expr)
+		if !found {
 			return nil
 		}
-		f := &funcExprNode{
+		return &funcExprNode{
 			fn:           fn,
 			boolOpposite: boolOpposite,
-		}
-		*subExprNode = "," + *subExprNode
-		for {
-			if strings.HasPrefix(*subExprNode, ",") {
-				*subExprNode = (*subExprNode)[1:]
-				operand := newGroupExprNode()
-				_, err := p.parseExprNode(trimLeftSpace(subExprNode), operand)
-				if err != nil {
-					*expr = lastStr
-					return nil
-				}
-				sortPriority(operand.RightOperand())
-				f.args = append(f.args, operand)
-			} else {
-				*expr = lastStr
-				return nil
-			}
-			trimLeftSpace(subExprNode)
-			if len(*subExprNode) == 0 {
-				return f
-			}
+			signOpposite: signOpposite,
+			args:         args,
 		}
 	}
 }
@@ -91,23 +102,25 @@ type funcExprNode struct {
 	args         []ExprNode
 	fn           func(...interface{}) interface{}
 	boolOpposite *bool
+	signOpposite *bool
 }
 
-func (f *funcExprNode) Run(currField string, tagExpr *TagExpr) interface{} {
+func (f *funcExprNode) Run(ctx context.Context, currField string, tagExpr *TagExpr) interface{} {
 	var args []interface{}
 	if n := len(f.args); n > 0 {
 		args = make([]interface{}, n)
 		for k, v := range f.args {
-			args[k] = v.Run(currField, tagExpr)
+			args[k] = v.Run(ctx, currField, tagExpr)
 		}
 	}
-	return realValue(f.fn(args...), f.boolOpposite)
+	return realValue(f.fn(args...), f.boolOpposite, f.signOpposite)
 }
 
 // --------------------------- Built-in function ---------------------------
 func init() {
 	funcList["regexp"] = readRegexpFuncExprNode
 	funcList["sprintf"] = readSprintfFuncExprNode
+	funcList["range"] = readRangeFuncExprNode
 	err := RegFunc("len", func(args ...interface{}) (n interface{}) {
 		if len(args) != 1 {
 			return 0
@@ -159,7 +172,7 @@ type regexpFuncExprNode struct {
 }
 
 func readRegexpFuncExprNode(p *Expr, expr *string) ExprNode {
-	last, boolOpposite := getBoolOpposite(expr)
+	last, boolOpposite, _ := getBoolAndSignOpposite(expr)
 	if !strings.HasPrefix(last, "regexp(") {
 		return nil
 	}
@@ -207,8 +220,8 @@ func readRegexpFuncExprNode(p *Expr, expr *string) ExprNode {
 	return e
 }
 
-func (re *regexpFuncExprNode) Run(currField string, tagExpr *TagExpr) interface{} {
-	param := re.rightOperand.Run(currField, tagExpr)
+func (re *regexpFuncExprNode) Run(ctx context.Context, currField string, tagExpr *TagExpr) interface{} {
+	param := re.rightOperand.Run(ctx, currField, tagExpr)
 	switch v := param.(type) {
 	case string:
 		bol := re.re.MatchString(v)
@@ -276,12 +289,12 @@ func readSprintfFuncExprNode(p *Expr, expr *string) ExprNode {
 	}
 }
 
-func (se *sprintfFuncExprNode) Run(currField string, tagExpr *TagExpr) interface{} {
+func (se *sprintfFuncExprNode) Run(ctx context.Context, currField string, tagExpr *TagExpr) interface{} {
 	var args []interface{}
 	if n := len(se.args); n > 0 {
 		args = make([]interface{}, n)
 		for i, e := range se.args {
-			args[i] = e.Run(currField, tagExpr)
+			args[i] = e.Run(ctx, currField, tagExpr)
 		}
 	}
 	return fmt.Sprintf(se.format, args...)