fix: fixed 'rang($, in(#v, ...))'

Change-Id: I309dd275c2cff690356e0de1440c7c11d781bbd1

Author: andeya

README.md

@@ -140,6 +140,7 @@ NOTE: **The `exprName` under the same struct field cannot be the same！**
 |`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)|
+|`in((X)$, enum_1, ...enum_n)`|Check if the first parameter is one of the enumerated parameters|
 
 <!-- |`(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)| -->

spec_func.go

@@ -28,12 +28,28 @@ import (
 
 var funcList = map[string]func(p *Expr, expr *string) ExprNode{}
 
+// MustRegFunc registers function expression.
+// NOTE:
+//
+//	example: len($), regexp("\\d") or regexp("\\d",$);
+//	If @force=true, allow to cover the existed same @funcName;
+//	The go number types always are float64;
+//	The go string types always are string;
+//	Panic if there is an error.
+func MustRegFunc(funcName string, fn func(...interface{}) interface{}, force ...bool) {
+	err := RegFunc(funcName, fn, force...)
+	if err != nil {
+		panic(err)
+	}
+}
+
 // RegFunc registers function expression.
 // NOTE:
-//  example: len($), regexp("\\d") or regexp("\\d",$);
-//  If @force=true, allow to cover the existed same @funcName;
-//  The go number types always are float64;
-//  The go string types always are string.
+//
+//	example: len($), regexp("\\d") or regexp("\\d",$);
+//	If @force=true, allow to cover the existed same @funcName;
+//	The go number types always are float64;
+//	The go string types always are string.
 func RegFunc(funcName string, fn func(...interface{}) interface{}, force ...bool) error {
 	if len(force) == 0 || !force[0] {
 		_, ok := funcList[funcName]
@@ -125,7 +141,8 @@ func init() {
 	funcList["regexp"] = readRegexpFuncExprNode
 	funcList["sprintf"] = readSprintfFuncExprNode
 	funcList["range"] = readRangeFuncExprNode
-	err := RegFunc("len", func(args ...interface{}) (n interface{}) {
+	// len: Built-in function len, the length of struct field X
+	MustRegFunc("len", func(args ...interface{}) (n interface{}) {
 		if len(args) != 1 {
 			return 0
 		}
@@ -143,10 +160,8 @@ func init() {
 		}()
 		return float64(reflect.ValueOf(v).Len())
 	}, true)
-	if err != nil {
-		panic(err)
-	}
-	err = RegFunc("mblen", func(args ...interface{}) (n interface{}) {
+	// mblen: get the length of string field X (character number)
+	MustRegFunc("mblen", func(args ...interface{}) (n interface{}) {
 		if len(args) != 1 {
 			return 0
 		}
@@ -164,9 +179,25 @@ func init() {
 		}()
 		return float64(reflect.ValueOf(v).Len())
 	}, true)
-	if err != nil {
-		panic(err)
-	}
+
+	// in: Check if the first parameter is one of the enumerated parameters
+	MustRegFunc("in", func(args ...interface{}) interface{} {
+		switch len(args) {
+		case 0:
+			return true
+		case 1:
+			return false
+		default:
+			elem := args[0]
+			set := args[1:]
+			for _, e := range set {
+				if elem == e {
+					return true
+				}
+			}
+			return false
+		}
+	}, true)
 }
 
 type regexpFuncExprNode struct {

spec_func_test.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	"github.com/bytedance/go-tagexpr/v2"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFunc(t *testing.T) {
@@ -83,5 +84,17 @@ func TestFunc(t *testing.T) {
 			t.Fatalf("string: %v, expect: %v, but got: %v", lenCase.str, lenCase.expect, got)
 		}
 	}
+}
 
+func TestRangeIn(t *testing.T) {
+	var vm = tagexpr.New("te")
+	type S struct {
+		F []string `te:"range($, in(#v, '', 'ttp', 'euttp'))"`
+	}
+	a := []string{"ttp", "", "euttp"}
+	r := vm.MustRun(S{
+		F: a,
+		// F: b,
+	})
+	assert.Equal(t, []interface{}{true, true, true}, r.Eval("F"))
 }

validator/README.md

@@ -179,9 +179,9 @@ type T struct {
 |`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)|
+|`in((X)$, enum_1, ...enum_n)`|Check if the first parameter is one of the enumerated parameters|
 |`email((X)$)`|Regular match the struct field X, return true if it is email|
 |`phone((X)$,<'defaultRegion'>)`|Regular match the struct field X, return true if it is phone|
-|`in((X)$, enum_1, ...enum_n)`|Check if the first parameter is one of the enumerated parameters|
 
 <!-- |`(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)| -->

validator/func.go

@@ -2,24 +2,24 @@ package validator
 
 import (
 	"errors"
-	"fmt"
 	"regexp"
 
 	"github.com/nyaruka/phonenumbers"
 
-	tagexpr "github.com/bytedance/go-tagexpr/v2"
+	"github.com/bytedance/go-tagexpr/v2"
 )
 
 // ErrInvalidWithoutMsg verification error without error message.
 var ErrInvalidWithoutMsg = errors.New("")
 
 // MustRegFunc registers validator function expression.
 // NOTE:
-//  panic if exist error;
-//  example: phone($) or phone($,'CN');
-//  If @force=true, allow to cover the existed same @funcName;
-//  The go number types always are float64;
-//  The go string types always are string.
+//
+//	panic if exist error;
+//	example: phone($) or phone($,'CN');
+//	If @force=true, allow to cover the existed same @funcName;
+//	The go number types always are float64;
+//	The go string types always are string.
 func MustRegFunc(funcName string, fn func(args ...interface{}) error, force ...bool) {
 	err := RegFunc(funcName, fn, force...)
 	if err != nil {
@@ -29,10 +29,11 @@ func MustRegFunc(funcName string, fn func(args ...interface{}) error, force ...b
 
 // RegFunc registers validator function expression.
 // NOTE:
-//  example: phone($) or phone($,'CN');
-//  If @force=true, allow to cover the existed same @funcName;
-//  The go number types always are float64;
-//  The go string types always are string.
+//
+//	example: phone($) or phone($,'CN');
+//	If @force=true, allow to cover the existed same @funcName;
+//	The go number types always are float64;
+//	The go string types always are string.
 func RegFunc(funcName string, fn func(args ...interface{}) error, force ...bool) error {
 	return tagexpr.RegFunc(funcName, func(args ...interface{}) interface{} {
 		err := fn(args...)
@@ -99,24 +100,3 @@ func init() {
 		return nil
 	}, true)
 }
-
-func init() {
-	// in: Check if the first parameter is one of the enumerated parameters
-	MustRegFunc("in", func(args ...interface{}) error {
-		switch len(args) {
-		case 0:
-			return nil
-		case 1:
-			return errors.New("input parameters of the in function are at least two")
-		default:
-			elem := args[0]
-			set := args[1:]
-			for _, e := range set {
-				if elem == e {
-					return nil
-				}
-			}
-			return fmt.Errorf("%#v is not in the list %+v", elem, set)
-		}
-	}, true)
-}

validator/validator_test.go

@@ -183,10 +183,10 @@ func TestIn(t *testing.T) {
 	v := vd.New("vd")
 	data := &T{}
 	err := v.Validate(data)
-	assert.EqualError(t, err, "\"\" is not in the list [a b c]")
+	assert.EqualError(t, err, "invalid parameter: A")
 	data.A = "b"
 	err = v.Validate(data)
-	assert.EqualError(t, err, "0 is not in the list [1 2 3]")
+	assert.EqualError(t, err, "invalid parameter: B")
 	data.B = 2
 	err = v.Validate(data)
 	assert.NoError(t, err)
@@ -196,14 +196,14 @@ func TestIn(t *testing.T) {
 	}
 	data2 := &T2{}
 	err = v.Validate(data2)
-	assert.EqualError(t, err, "input parameters of the in function are at least two")
+	assert.EqualError(t, err, "invalid parameter: C")
 
 	type T3 struct {
 		C string `vd:"in($,1)"`
 	}
 	data3 := &T3{}
 	err = v.Validate(data3)
-	assert.EqualError(t, err, "\"\" is not in the list [1]")
+	assert.EqualError(t, err, "invalid parameter: C")
 }
 
 type (
@@ -309,3 +309,17 @@ func TestRegexp(t *testing.T) {
 	assert.EqualError(t, vd.Validate(&TStruct{A: "abc1"}), "invalid parameter: A")
 	assert.EqualError(t, vd.Validate(&TStruct{A: "0?0?0?0"}), "invalid parameter: A")
 }
+
+func TestRangeIn(t *testing.T) {
+	type S struct {
+		F []string `vd:"range($, in(#v, '', 'ttp', 'euttp'))"`
+	}
+	err := vd.Validate(S{
+		F: []string{"ttp", "", "euttp"},
+	})
+	assert.NoError(t, err)
+	err = vd.Validate(S{
+		F: []string{"ttp", "?", "euttp"},
+	})
+	assert.EqualError(t, err, "invalid parameter: F")
+}