feat: support index slice, map and array

Change-Id: I4c4717f00d743d1330b147d6525f3cb41ed202e9

Author: andeya

README.md

@@ -12,11 +12,10 @@ In development
 type T struct {
 	A int              `tagexpr:"$<0||$>=100"`
 	B string           `tagexpr:"len($)>1 || regexp('^\\w*$')"`
-	C bool             `tagexpr:"{expr1:(G)$['J']>0 && $}{expr2:'C must be true when T.G.J>0'}"`
+	C bool             `tagexpr:"{expr1:(F.G)$>0 && $}{expr2:'C must be true when T.F.G>0'}"`
 	D []string         `tagexpr:"{expr1:len($)>0 && $[0]=='D'} {expr2:sprintf('Invalid D:%s',$)}"`
-	E map[string]int   `tagexpr:"{expr1:$k!='' && $v>0}{expr2:$['E']>0}"`
-	F map[string][]int `tagexpr:"$$v>0 && len($['F'])>0 && $['F'][0]>1"`
-	G struct{ J int }
+	E map[string]int   `tagexpr:"len($)"`
+	F struct{ G int }
 }
 ```
 
@@ -56,17 +55,19 @@ NOTE: **The `exprName` under the same struct field cannot be the same！**
 |`\|\|`|Logic `or`|
 |`()`|Expression group|
 |`(X)$`|Struct field value named X|
+|`(X.Y)$`|Struct field value named X.Y|
 |`$`|Shorthand for `(X)$`, omit `(X)` to indicate current struct field value|
-|`(X)$['A']`|Map or struct field value with name A in the struct field X|
+|`(X)$['A']`|Map value with key A in the struct field X|
 |`(X)$[0]`|The 0th element of the struct field X(type: map, slice, array)|
-|`(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)|
 |`len((X)$)`|Built-in function `len`, the length of struct field X|
 |`len()`|Built-in function `len`, the length of the current struct field|
 |`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|
 
+<!-- |`(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)| -->
+
 <!-- |`&`|Integer bitwise `and`|
 |`\|`|Integer bitwise `or`|
 |`^`|Integer bitwise `not` or `xor`|

expr_test.go

@@ -152,7 +152,6 @@ 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: nil},
-		{expr: "len()", val: nil},
 
 		{expr: "regexp('a\\d','a0')", val: true},
 		{expr: "regexp('^a\\d$','a0')", val: true},

spec_selector.go

@@ -33,34 +33,31 @@ func (p *Expr) readSelectorExprNode(expr *string) ExprNode {
 	return operand
 }
 
-var selectorRegexp = regexp.MustCompile(`^(\([ \t]*[a-zA-Z_]{1}\w*[ \t]*\))?(\$[kv]?)(\[[ \t]*\S+[ \t]*\])*([\+\-\*\/%><\|&!=\^ \t\\]|$)`)
+var selectorRegexp = regexp.MustCompile(`^(\([ \t]*[A-Za-z_]+[A-Za-z0-9_\.]*[ \t]*\))?(\$)([\[\+\-\*\/%><\|&!=\^ \t\\]|$)`)
 
 func findSelector(expr *string) (field string, name string, subSelector []string, found bool) {
-	a := selectorRegexp.FindAllStringSubmatch(*expr, -1)
+	raw := *expr
+	a := selectorRegexp.FindAllStringSubmatch(raw, -1)
 	if len(a) != 1 {
 		return
 	}
-	length := len(a[0][0])
 	r := a[0]
 	if s0 := r[1]; len(s0) > 0 {
 		field = strings.TrimSpace(s0[1 : len(s0)-1])
 	}
 	name = r[2]
-	s := r[3]
+	*expr = (*expr)[len(a[0][0])-len(r[3]):]
 	for {
-		sub := readPairedSymbol(&s, '[', ']')
+		sub := readPairedSymbol(expr, '[', ']')
 		if sub == nil {
 			break
 		}
 		if *sub == "" || (*sub)[0] == '[' {
+			*expr = raw
 			return "", "", nil, false
 		}
 		subSelector = append(subSelector, strings.TrimSpace(*sub))
 	}
-	if len(r[4]) == 1 {
-		length--
-	}
-	*expr = (*expr)[length:]
 	found = true
 	return
 }

tagexpr.go

@@ -306,6 +306,11 @@ type TagExpr struct {
 // Eval evaluate the value of the struct tag expression by the selector expression.
 // format: fieldName, fieldName.exprName, fieldName1.fieldName2.exprName1
 func (t *TagExpr) Eval(selector string) interface{} {
+	defer func() {
+		if recover() != nil {
+			// fmt.Println(goutil.BytesToString(goutil.PanicTrace(1)))
+		}
+	}()
 	expr, ok := t.s.exprs[selector]
 	if !ok {
 		return nil
@@ -315,6 +320,11 @@ func (t *TagExpr) Eval(selector string) interface{} {
 
 // Range loop through each tag expression
 func (t *TagExpr) Range(fn func(selector string, eval func() interface{})) {
+	defer func() {
+		if recover() != nil {
+			// fmt.Println(goutil.BytesToString(goutil.PanicTrace(1)))
+		}
+	}()
 	for selector, expr := range t.s.exprs {
 		fn(selector, func() interface{} {
 			return expr.run(getFieldSelector(selector), t)
@@ -327,13 +337,62 @@ func (t *TagExpr) getValue(field string, subFields []interface{}) (v interface{}
 	if !ok {
 		return nil
 	}
-	_ = subFields // TODO
 	if f.valueGetter == nil {
 		return nil
 	}
-	return f.valueGetter(t.ptr)
+	v = f.valueGetter(t.ptr)
+	if len(subFields) == 0 {
+		return v
+	}
+	vv := reflect.ValueOf(v)
+	fmt.Println("=======", subFields, vv.Kind(), vv.Interface())
+	// if len(subFields) == 0 {
+	// 	return v
+	// }
+	for _, k := range subFields {
+		for vv.Kind() == reflect.Ptr {
+			vv = vv.Elem()
+		}
+		switch vv.Kind() {
+		case reflect.Slice, reflect.Array, reflect.String:
+			if float, ok := k.(float64); ok {
+				idx := int(float)
+				if idx >= vv.Len() {
+					return nil
+				}
+				vv = vv.Index(idx)
+			} else {
+				return nil
+			}
+		case reflect.Map:
+			vv = vv.MapIndex(reflect.ValueOf(k).Convert(vv.Type().Key()))
+		default:
+			return nil
+		}
+	}
+	for vv.Kind() == reflect.Ptr {
+		vv = vv.Elem()
+	}
+	switch vv.Kind() {
+	default:
+		if vv.CanInterface() {
+			return vv.Interface()
+		}
+		return nil
+	case reflect.String:
+		return vv.String()
+	case reflect.Bool:
+		return vv.Bool()
+	case reflect.Float32, reflect.Float64:
+		return vv.Float()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return vv.Convert(float64Type).Float()
+	}
 }
 
+var float64Type = reflect.TypeOf(float64(0))
+
 func getFieldSelector(selector string) string {
 	idx := strings.LastIndex(selector, ".")
 	if idx == -1 {

tagexpr_test.go

@@ -8,8 +8,14 @@ import (
 func TestVMFunc(t *testing.T) {
 	g := &struct {
 		_ int
-		h bool `tagexpr:"$"`
-	}{h: true}
+		h string `tagexpr:"$"`
+		s []string
+		m map[string][]string
+	}{
+		h: "haha",
+		s: []string{"1"},
+		m: map[string][]string{"0": {"2"}},
+	}
 	d := "ddd"
 	e := new(int)
 	*e = 3
@@ -21,13 +27,15 @@ func TestVMFunc(t *testing.T) {
 		{
 			tagName: "tagexpr",
 			structure: &struct {
-				A int     `tagexpr:"$>0&&$<10"`
-				b string  `tagexpr:"{is:$=='test'}{msg:sprintf('want: test, but got: %s',$)}"`
-				c float32 `tagexpr:"(A)$+$"`
-				d *string `tagexpr:"$"`
-				e **int   `tagexpr:"$"`
-				f *[3]int `tagexpr:"{x:len($)}{y:len()}"`
-				g string  `tagexpr:"{x:regexp('g\\d{3}$',$)}{y:regexp('g\\d{3}$')}"`
+				A int            `tagexpr:"$>0&&$<10"`
+				b string         `tagexpr:"{is:$=='test'}{msg:sprintf('want: test, but got: %s',$)}"`
+				c float32        `tagexpr:"(A)$+$"`
+				d *string        `tagexpr:"$"`
+				e **int          `tagexpr:"$"`
+				f *[3]int        `tagexpr:"{x:len($)}{y:len()}"`
+				g string         `tagexpr:"{x:regexp('g\\d{3}$',$)}{y:regexp('g\\d{3}$')}"`
+				h []string       `tagexpr:"{x:$[1]}{y:$[10]}"`
+				i map[string]int `tagexpr:"{x:$['a']}{y:$[0]}"`
 			}{
 				A: 5.0,
 				b: "x",
@@ -36,6 +44,8 @@ func TestVMFunc(t *testing.T) {
 				e: &e,
 				f: new([3]int),
 				g: "g123",
+				h: []string{"", "hehe"},
+				i: map[string]int{"a": 7},
 			},
 			tests: map[string]interface{}{
 				"A.$":   true,
@@ -48,6 +58,10 @@ func TestVMFunc(t *testing.T) {
 				"f.y":   float64(3),
 				"g.x":   true,
 				"g.y":   true,
+				"h.x":   "hehe",
+				"h.y":   nil,
+				"i.x":   7.0,
+				"i.y":   nil,
 			},
 		},
 		{
@@ -65,8 +79,11 @@ func TestVMFunc(t *testing.T) {
 				}
 				g **struct {
 					_ int
-					h bool `tagexpr:"$"`
-				}
+					h string `tagexpr:"$"`
+					s []string
+					m map[string][]string
+				} `tagexpr:"$['h']"`
+				i string `tagexpr:"(g.s)$[0]+(g.m)$['0'][0]==$"`
 			}{
 				A: 5.0,
 				b: "x",
@@ -79,14 +96,16 @@ func TestVMFunc(t *testing.T) {
 					f bool `tagexpr:"$"`
 				}{f: true},
 				g: &g,
+				i: "12",
 			},
 			tests: map[string]interface{}{
 				"A.$":   true,
 				"b.is":  false,
 				"b.msg": "want: test, but got: x",
 				"c.d.$": true,
 				"e.f.$": true,
-				"g.h.$": true,
+				"g.h.$": "haha",
+				"i.$":   true,
 			},
 		},
 	}