feat: Update *TagExpr.Range method and fix *Validator.Validate method

Change-Id: I96d0823e593c7f2878a93b2aaa5c7edda8e6de90

Author: andeya

fieldhandler.go

@@ -0,0 +1,129 @@
+package tagexpr
+
+import "reflect"
+
+// FieldHandler field handler
+type FieldHandler struct {
+	selector string
+	field    *fieldVM
+	expr     *TagExpr
+}
+
+func newFieldHandler(expr *TagExpr, fieldSelector string, field *fieldVM) *FieldHandler {
+	return &FieldHandler{
+		selector: fieldSelector,
+		field:    field,
+		expr:     expr,
+	}
+}
+
+// StringSelector returns the field selector of string type.
+func (f *FieldHandler) StringSelector() string {
+	return f.selector
+}
+
+// FieldSelector returns the field selector of FieldSelector type.
+func (f *FieldHandler) FieldSelector() FieldSelector {
+	return FieldSelector(f.selector)
+}
+
+// Value returns the field value.
+// NOTE:
+//  If initZero==true, initialize nil pointer to zero value
+func (f *FieldHandler) Value(initZero bool) reflect.Value {
+	return f.field.reflectValueGetter(f.expr.ptr, initZero)
+}
+
+// EvalFuncs returns the tag expression eval functions.
+func (f *FieldHandler) EvalFuncs() map[ExprSelector]func() interface{} {
+	targetTagExpr, _ := f.expr.checkout(f.selector)
+	evals := make(map[ExprSelector]func() interface{}, len(f.field.exprs))
+	for k, v := range f.field.exprs {
+		expr := v
+		exprSelector := ExprSelector(k)
+		evals[exprSelector] = func() interface{} {
+			return expr.run(exprSelector.Name(), targetTagExpr)
+		}
+	}
+	return evals
+}
+
+// StructField returns the field StructField object.
+func (f *FieldHandler) StructField() reflect.StructField {
+	return f.field.structField
+}
+
+// ExprHandler expr handler
+type ExprHandler struct {
+	base       string
+	path       string
+	selector   string
+	expr       *TagExpr
+	targetExpr *TagExpr
+}
+
+func newExprHandler(te, tte *TagExpr, base, es string) *ExprHandler {
+	return &ExprHandler{
+		base:       base,
+		selector:   es,
+		expr:       te,
+		targetExpr: tte,
+	}
+}
+
+// TagExpr returns the *TagExpr.
+func (e *ExprHandler) TagExpr() *TagExpr {
+	return e.expr
+}
+
+// StringSelector returns the expression selector of string type.
+func (e *ExprHandler) StringSelector() string {
+	return e.selector
+}
+
+// ExprSelector returns the expression selector of ExprSelector type.
+func (e *ExprHandler) ExprSelector() ExprSelector {
+	return ExprSelector(e.selector)
+}
+
+// Path returns the path description of the expression.
+func (e *ExprHandler) Path() string {
+	if e.path == "" {
+		if e.targetExpr.path == "" {
+			e.path = e.selector
+		} else {
+			e.path = e.targetExpr.path + FieldSeparator + e.selector
+		}
+	}
+	return e.path
+}
+
+// Eval evaluate the value of the struct tag expression.
+// NOTE:
+//  result types: float64, string, bool, nil
+func (e *ExprHandler) Eval() interface{} {
+	return e.expr.s.exprs[e.selector].run(e.base, e.targetExpr)
+}
+
+// EvalFloat evaluates the value of the struct tag expression.
+// NOTE:
+//  If the expression value type is not float64, return 0.
+func (e *ExprHandler) EvalFloat() float64 {
+	r, _ := e.Eval().(float64)
+	return r
+}
+
+// EvalString evaluates the value of the struct tag expression.
+// NOTE:
+//  If the expression value type is not string, return "".
+func (e *ExprHandler) EvalString() string {
+	r, _ := e.Eval().(string)
+	return r
+}
+
+// EvalBool evaluates the value of the struct tag expression.
+// NOTE:
+//  If the expression value is not 0, '' or nil, return true.
+func (e *ExprHandler) EvalBool() bool {
+	return FakeBool(e.Eval())
+}

handler.go

@@ -659,23 +659,23 @@ type TagExpr struct {
 	path string
 }
 
-// EvalFloat evaluate the value of the struct tag expression by the selector expression.
+// EvalFloat evaluates the value of the struct tag expression by the selector expression.
 // NOTE:
 //  If the expression value type is not float64, return 0.
 func (t *TagExpr) EvalFloat(exprSelector string) float64 {
 	r, _ := t.Eval(exprSelector).(float64)
 	return r
 }
 
-// EvalString evaluate the value of the struct tag expression by the selector expression.
+// EvalString evaluates the value of the struct tag expression by the selector expression.
 // NOTE:
 //  If the expression value type is not string, return "".
 func (t *TagExpr) EvalString(exprSelector string) string {
 	r, _ := t.Eval(exprSelector).(string)
 	return r
 }
 
-// EvalBool evaluate the value of the struct tag expression by the selector expression.
+// EvalBool evaluates the value of the struct tag expression by the selector expression.
 // NOTE:
 //  If the expression value is not 0, '' or nil, return true.
 func (t *TagExpr) EvalBool(exprSelector string) bool {
@@ -721,7 +721,7 @@ func (t *TagExpr) RangeFields(fn func(*FieldHandler) bool) bool {
 	return true
 }
 
-// Eval evaluate the value of the struct tag expression by the selector expression.
+// Eval evaluates the value of the struct tag expression by the selector expression.
 // NOTE:
 //  format: fieldName, fieldName.exprName, fieldName1.fieldName2.exprName1
 //  result types: float64, string, bool, nil
@@ -752,25 +752,16 @@ func (t *TagExpr) Eval(exprSelector string) interface{} {
 // When fn returns false, interrupt traversal and return false.
 // NOTE:
 //  eval result types: float64, string, bool, nil
-func (t *TagExpr) Range(fn func(path string, es ExprSelector, eval func() interface{}) error) error {
+func (t *TagExpr) Range(fn func(*ExprHandler) error) error {
 	var err error
 	if list := t.s.exprSelectorList; len(list) > 0 {
-		exprs := t.s.exprs
 		for _, es := range list {
 			dir, base := splitFieldSelector(es)
 			targetTagExpr, err := t.checkout(dir)
 			if err != nil {
 				continue
 			}
-			var path string
-			if targetTagExpr.path == "" {
-				path = es
-			} else {
-				path = targetTagExpr.path + FieldSeparator + es
-			}
-			err = fn(path, ExprSelector(es), func() interface{} {
-				return exprs[es].run(base, targetTagExpr)
-			})
+			err = fn(newExprHandler(t, targetTagExpr, base, es))
 			if err != nil {
 				return err
 			}
@@ -866,7 +857,7 @@ func (t *TagExpr) Range(fn func(path string, es ExprSelector, eval func() interf
 	return nil
 }
 
-func (t *TagExpr) subRange(omitNil bool, path string, value reflect.Value, fn func(string, ExprSelector, func() interface{}) error) error {
+func (t *TagExpr) subRange(omitNil bool, path string, value reflect.Value, fn func(*ExprHandler) error) error {
 	return t.s.vm.subRunAll(omitNil, path, value, func(te *TagExpr, err error) error {
 		if err != nil {
 			return err

tagexpr.go

@@ -226,10 +226,11 @@ func Test(t *testing.T) {
 				t.Fatalf("Eval Serial: %d, selector: %q, got: %v, expect: %v", i, selector, val, value)
 			}
 		}
-		tagExpr.Range(func(path string, es ExprSelector, eval func() interface{}) error {
+		tagExpr.Range(func(eh *ExprHandler) error {
+			es := eh.ExprSelector()
 			t.Logf("Range selector: %s, field: %q exprName: %q", es, es.Field(), es.Name())
 			value := c.tests[es.String()]
-			val := eval()
+			val := eh.Eval()
 			if !reflect.DeepEqual(val, value) {
 				t.Fatalf("Range NO: %d, selector: %q, got: %v, expect: %v", i, es, val, value)
 			}
@@ -542,10 +543,11 @@ func TestOperator(t *testing.T) {
 				t.Fatalf("Eval NO: %d, selector: %q, got: %v, expect: %v", i, selector, val, value)
 			}
 		}
-		tagExpr.Range(func(path string, es ExprSelector, eval func() interface{}) error {
+		tagExpr.Range(func(eh *ExprHandler) error {
+			es := eh.ExprSelector()
 			t.Logf("Range selector: %s, field: %q exprName: %q", es, es.Field(), es.Name())
 			value := c.tests[es.String()]
-			val := eval()
+			val := eh.Eval()
 			if !reflect.DeepEqual(val, value) {
 				t.Fatalf("Range NO: %d, selector: %q, got: %v, expect: %v", i, es, val, value)
 			}
@@ -575,9 +577,10 @@ func TestStruct(t *testing.T) {
 	assert.Equal(t, "xxx", expr.EvalString("B.C3"))
 	assert.Equal(t, "xxx", expr.EvalString("B.C"))
 	assert.Equal(t, "xxx", expr.EvalString("B.C.D.X"))
-	expr.Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		t.Logf("Range selector: %s, field: %q exprName: %q", path, es.Field(), es.Name())
-		if eval().(string) != "xxx" {
+	expr.Range(func(eh *ExprHandler) error {
+		es := eh.ExprSelector()
+		t.Logf("Range selector: %s, field: %q exprName: %q", es, es.Field(), es.Name())
+		if eh.Eval().(string) != "xxx" {
 			t.FailNow()
 		}
 		return nil
@@ -669,8 +672,9 @@ func TestStruct3(t *testing.T) {
 	if expr.EvalString("XBlock.BlockType") != "BlockType" {
 		t.Fatal(expr.EvalString("XBlock.BlockType"))
 	}
-	err := expr.Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		t.Logf("Range selector: %s, field: %q exprName: %q, eval: %v", path, es.Field(), es.Name(), eval())
+	err := expr.Range(func(eh *ExprHandler) error {
+		es := eh.ExprSelector()
+		t.Logf("Range selector: %s, field: %q exprName: %q, eval: %v", eh.Path(), es.Field(), es.Name(), eh.Eval())
 		return nil
 	})
 	assert.NoError(t, err)
@@ -685,10 +689,10 @@ func TestNilField(t *testing.T) {
 	}
 	vm := New("tagexpr")
 	te := vm.MustRun(P{})
-	te.Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		r := eval()
+	te.Range(func(eh *ExprHandler) error {
+		r := eh.Eval()
 		if r != nil {
-			t.Fatal(path, r)
+			t.Fatal(eh.Path(), r)
 		}
 		return nil
 	})
@@ -701,10 +705,10 @@ func TestNilField(t *testing.T) {
 		Nil1: new(int),
 		Nil2: new(int),
 	}
-	vm.MustRun(g).Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		r, ok := eval().(bool)
+	vm.MustRun(g).Range(func(eh *ExprHandler) error {
+		r, ok := eh.Eval().(bool)
 		if !ok || !r {
-			t.Fatal(path, r)
+			t.Fatal(eh.Path(), r)
 		}
 		return nil
 	})
@@ -733,12 +737,12 @@ func TestNilField(t *testing.T) {
 		SI: []interface{}{&M{X: "nn"}},
 	}
 	var cnt int
-	vm.MustRun(n).Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		r, ok := eval().(bool)
+	vm.MustRun(n).Range(func(eh *ExprHandler) error {
+		r, ok := eh.Eval().(bool)
 		if !ok || !r {
-			t.Fatal(path, r)
+			t.Fatal(eh.Path(), r)
 		}
-		t.Log("path:", path, "es:", es, "val:", r)
+		t.Log("path:", eh.Path(), "es:", eh.ExprSelector(), "val:", r)
 		cnt++
 		return nil
 	})
@@ -781,11 +785,11 @@ func TestDeepNested(t *testing.T) {
 	expectValue := [...]interface{}{"I:address", nil, "A:address", nil, "X:address"}
 	var i int
 	vm := New("tagexpr")
-	vm.MustRun(data).Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		assert.Equal(t, expectKey[i], path)
-		assert.Equal(t, expectValue[i], eval())
+	vm.MustRun(data).Range(func(eh *ExprHandler) error {
+		assert.Equal(t, expectKey[i], eh.Path())
+		assert.Equal(t, expectValue[i], eh.Eval())
 		i++
-		t.Log(path, es, eval())
+		t.Log(eh.Path(), eh.ExprSelector(), eh.Eval())
 		return nil
 	})
 	assert.Equal(t, 5, i)
@@ -809,16 +813,16 @@ func TestIssue3(t *testing.T) {
 		},
 	}
 	vm := New("vd")
-	err := vm.MustRun(a).Range(func(path string, es ExprSelector, eval func() interface{}) error {
-		switch path {
+	err := vm.MustRun(a).Range(func(eh *ExprHandler) error {
+		switch eh.Path() {
 		case "F1.Index":
-			assert.Equal(t, float64(1), eval(), path)
+			assert.Equal(t, float64(1), eh.Eval(), eh.Path())
 		case "F2.Index":
-			assert.Equal(t, nil, eval(), path)
+			assert.Equal(t, nil, eh.Eval(), eh.Path())
 		case "F1.P":
-			assert.Equal(t, true, eval(), path)
+			assert.Equal(t, true, eh.Eval(), eh.Path())
 		case "F2.P":
-			assert.Equal(t, false, eval(), path)
+			assert.Equal(t, false, eh.Eval(), eh.Path())
 		}
 		return nil
 	})