a463dfbba9906d64fb4b5e18ef91b58ea23d5b31

prepare for release v1.1.3

Author: lvan100

conf/bind.go

@@ -25,7 +25,7 @@ import (
 
 	"github.com/go-spring/spring-base/code"
 	"github.com/go-spring/spring-base/util"
-	"github.com/go-spring/spring-core/expr"
+	"github.com/go-spring/spring-core/validate"
 )
 
 var (
@@ -145,23 +145,11 @@ func BindValue(p *Properties, v reflect.Value, t reflect.Type, param BindParam,
 		return nil
 	}
 
-	validate := func(input string, val interface{}) error {
-		if input == "" {
-			return nil
-		}
-		if b, err := expr.Eval(input, val); err != nil {
-			return err
-		} else if !b {
-			return fmt.Errorf("validate failed on %q for value %v", input, val)
-		}
-		return nil
-	}
-
 	switch v.Kind() {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 		var u uint64
 		if u, err = strconv.ParseUint(val, 0, 0); err == nil {
-			if err = validate(param.Validate, u); err != nil {
+			if err = validate.Field(u, param.Validate); err != nil {
 				return err
 			}
 			v.SetUint(u)
@@ -171,7 +159,7 @@ func BindValue(p *Properties, v reflect.Value, t reflect.Type, param BindParam,
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		var i int64
 		if i, err = strconv.ParseInt(val, 0, 0); err == nil {
-			if err = validate(param.Validate, i); err != nil {
+			if err = validate.Field(i, param.Validate); err != nil {
 				return err
 			}
 			v.SetInt(i)
@@ -181,7 +169,7 @@ func BindValue(p *Properties, v reflect.Value, t reflect.Type, param BindParam,
 	case reflect.Float32, reflect.Float64:
 		var f float64
 		if f, err = strconv.ParseFloat(val, 64); err == nil {
-			if err = validate(param.Validate, f); err != nil {
+			if err = validate.Field(f, param.Validate); err != nil {
 				return err
 			}
 			v.SetFloat(f)
@@ -191,15 +179,15 @@ func BindValue(p *Properties, v reflect.Value, t reflect.Type, param BindParam,
 	case reflect.Bool:
 		var b bool
 		if b, err = strconv.ParseBool(val); err == nil {
-			if err = validate(param.Validate, b); err != nil {
+			if err = validate.Field(b, param.Validate); err != nil {
 				return err
 			}
 			v.SetBool(b)
 			return nil
 		}
 		return util.Wrapf(err, code.FileLine(), "bind %s error", param.Path)
 	case reflect.String:
-		if err = validate(param.Validate, val); err != nil {
+		if err = validate.Field(val, param.Validate); err != nil {
 			return err
 		}
 		v.SetString(val)
@@ -357,8 +345,8 @@ func bindStruct(p *Properties, v reflect.Value, t reflect.Type, param BindParam,
 		}
 
 		if tag, ok := ft.Tag.Lookup("value"); ok {
-			validate, _ := ft.Tag.Lookup("validate")
-			if err := subParam.BindTag(tag, validate); err != nil {
+			validateTag, _ := ft.Tag.Lookup(validate.TagName())
+			if err := subParam.BindTag(tag, validateTag); err != nil {
 				return util.Wrapf(err, code.FileLine(), "bind %s error", param.Path)
 			}
 			if filter != nil {

conf/bind_test.go

@@ -26,7 +26,7 @@ import (
 )
 
 type DB struct {
-	UserName string `value:"${username}" validate:"len($)>=4"`
+	UserName string `value:"${username}" expr:"len($)>=4"`
 	Password string `value:"${password}"`
 	Url      string `value:"${url}"`
 	Port     string `value:"${port}"`
@@ -216,14 +216,3 @@ func TestProperties_Bind(t *testing.T) {
 		assert.Equal(t, s.M, map[string]string{})
 	})
 }
-
-func TestProperties_Validate(t *testing.T) {
-	t.Run("", func(t *testing.T) {
-		p := conf.New()
-		v := &struct {
-			V int `value:"${:=3}" validate:"$<3"`
-		}{}
-		err := p.Bind(v)
-		assert.Error(t, err, "validate failed on \"\\$<3\" for value 3")
-	})
-}

conf/conf.go

@@ -91,7 +91,7 @@ func RegisterSplitter(name string, fn Splitter) {
 // time.Time, time.Duration, or other user-defined value type.
 func RegisterConverter(fn util.Converter) {
 	t := reflect.TypeOf(fn)
-	if !util.IsValidConverter(t) {
+	if !util.IsConverter(t) {
 		panic(errors.New("converter should be func(string)(type,error)"))
 	}
 	converters[t.Out(0)] = fn
@@ -110,14 +110,14 @@ func RegisterConverter(fn util.Converter) {
 // but it costs more CPU time when getting properties because it reads property node
 // by node. So `conf` uses a tree to strictly verify and a flat map to store.
 type Properties struct {
-	storage internal.Storage
+	storage *internal.Storage
 }
 
 // New creates empty *Properties.
 func New() *Properties {
-	p := &Properties{}
-	p.storage.Init()
-	return p
+	return &Properties{
+		storage: internal.NewStorage(),
+	}
 }
 
 // Map creates *Properties from map.
@@ -195,6 +195,12 @@ func (p *Properties) Bytes(b []byte, ext string) error {
 	return nil
 }
 
+func (p *Properties) Copy() *Properties {
+	return &Properties{
+		storage: p.storage.Copy(),
+	}
+}
+
 // Keys returns all sorted keys.
 func (p *Properties) Keys() []string {
 	return p.storage.Keys()
@@ -231,7 +237,7 @@ func (p *Properties) Get(key string, opts ...GetOption) string {
 	return arg.def
 }
 
-func flatten(key string, val interface{}, result map[string]string) error {
+func Flatten(key string, val interface{}, result map[string]string) error {
 	switch v := reflect.ValueOf(val); v.Kind() {
 	case reflect.Map:
 		if v.Len() == 0 {
@@ -241,7 +247,7 @@ func flatten(key string, val interface{}, result map[string]string) error {
 		for _, k := range v.MapKeys() {
 			mapKey := cast.ToString(k.Interface())
 			mapValue := v.MapIndex(k).Interface()
-			err := flatten(key+"."+mapKey, mapValue, result)
+			err := Flatten(key+"."+mapKey, mapValue, result)
 			if err != nil {
 				return err
 			}
@@ -254,7 +260,7 @@ func flatten(key string, val interface{}, result map[string]string) error {
 		for i := 0; i < v.Len(); i++ {
 			subKey := fmt.Sprintf("%s[%d]", key, i)
 			subValue := v.Index(i).Interface()
-			err := flatten(subKey, subValue, result)
+			err := Flatten(subKey, subValue, result)
 			if err != nil {
 				return err
 			}
@@ -272,8 +278,11 @@ func flatten(key string, val interface{}, result map[string]string) error {
 // when it doesn't exist in the slice or map even they share a same
 // prefix path.
 func (p *Properties) Set(key string, val interface{}) error {
+	if key == "" {
+		return nil
+	}
 	m := make(map[string]string)
-	err := flatten(key, val, m)
+	err := Flatten(key, val, m)
 	if err != nil {
 		return err
 	}

conf/conf_test.go

@@ -345,7 +345,7 @@ func TestBindMap(t *testing.T) {
 		})
 		assert.Nil(t, err)
 		err = p.Bind(&r)
-		assert.Error(t, err, ".*bind.go:.* bind S error; .*bind.go:.* bind S.A error; property \"a\" isn't map")
+		assert.Error(t, err, ".*bind.go:.* bind S error; .*bind.go:.* bind S.A error; property 'a' is value")
 	})
 
 	t.Run("", func(t *testing.T) {
@@ -410,10 +410,10 @@ func TestProperties_Set(t *testing.T) {
 		assert.Equal(t, p.Keys(), []string{"m.a"})
 
 		err = p.Set("m", 1)
-		assert.Error(t, err, "property \"m\" is a map but \"m\" wants other type")
+		assert.Error(t, err, "property 'm' is a map but 'm' wants other type")
 
 		err = p.Set("m", []string{"b"})
-		assert.Error(t, err, "property \"m\" is a map but \"m\\[0]\" wants other type")
+		assert.Error(t, err, "property 'm' is a map but 'm\\[0]' wants other type")
 	})
 
 	t.Run("map empty", func(t *testing.T) {

conf/internal/path.go

@@ -18,105 +18,110 @@ package internal
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 )
 
 type PathType int
 
 const (
-	PathTypeKey PathType = iota
-	PathTypeIndex
+	PathTypeKey   PathType = iota // PathTypeKey is map key like a/b in a[0][1].b
+	PathTypeIndex                 // PathTypeIndex is array index like 0/1 in a[0][1].b
 )
 
 type Path struct {
 	Type PathType
 	Elem string
 }
 
-// SplitPath splits the key into individual parts.
+// JoinPath joins path elements into a single path.
+func JoinPath(path []Path) string {
+	var s strings.Builder
+	for i, p := range path {
+		switch p.Type {
+		case PathTypeKey:
+			if i > 0 {
+				s.WriteString(".")
+			}
+			s.WriteString(p.Elem)
+		case PathTypeIndex:
+			s.WriteString("[")
+			s.WriteString(p.Elem)
+			s.WriteString("]")
+		}
+	}
+	return s.String()
+}
+
+// SplitPath splits key into individual path elements.
 func SplitPath(key string) ([]Path, error) {
 	if key == "" {
 		return nil, nil
 	}
 	var (
 		path        []Path
+		lastPos     int
 		lastChar    int32
-		lastIndex   int
-		leftBracket bool
+		openBracket bool
 	)
 	for i, c := range key {
 		switch c {
 		case ' ':
 			return nil, fmt.Errorf("invalid key '%s'", key)
 		case '.':
-			if leftBracket {
+			if openBracket {
 				return nil, fmt.Errorf("invalid key '%s'", key)
 			}
 			if lastChar == ']' {
-				lastIndex = i + 1
+				lastPos = i + 1
 				lastChar = c
 				continue
 			}
-			if lastIndex == i {
+			if lastPos == i {
 				return nil, fmt.Errorf("invalid key '%s'", key)
 			}
-			path = append(path, Path{PathTypeKey, key[lastIndex:i]})
-			lastIndex = i + 1
+			path = append(path, Path{PathTypeKey, key[lastPos:i]})
+			lastPos = i + 1
 			lastChar = c
 		case '[':
-			if leftBracket {
+			if openBracket {
 				return nil, fmt.Errorf("invalid key '%s'", key)
 			}
 			if i == 0 || lastChar == ']' {
-				lastIndex = i + 1
-				leftBracket = true
+				lastPos = i + 1
+				openBracket = true
 				lastChar = c
 				continue
 			}
-			if lastChar == '.' || lastIndex == i {
+			if lastChar == '.' || lastPos == i {
 				return nil, fmt.Errorf("invalid key '%s'", key)
 			}
-			path = append(path, Path{PathTypeKey, key[lastIndex:i]})
-			lastIndex = i + 1
-			leftBracket = true
+			path = append(path, Path{PathTypeKey, key[lastPos:i]})
+			lastPos = i + 1
+			openBracket = true
 			lastChar = c
 		case ']':
-			if !leftBracket || lastIndex == i {
+			if !openBracket || lastPos == i {
+				return nil, fmt.Errorf("invalid key '%s'", key)
+			}
+			s := key[lastPos:i]
+			_, err := strconv.ParseUint(s, 10, 64)
+			if err != nil {
 				return nil, fmt.Errorf("invalid key '%s'", key)
 			}
-			path = append(path, Path{PathTypeIndex, key[lastIndex:i]})
-			lastIndex = i + 1
-			leftBracket = false
+			path = append(path, Path{PathTypeIndex, s})
+			lastPos = i + 1
+			openBracket = false
 			lastChar = c
 		default:
 			lastChar = c
 		}
 	}
-	if leftBracket || lastChar == '.' {
+	if openBracket || lastChar == '.' {
 		return nil, fmt.Errorf("invalid key '%s'", key)
 	}
 	if lastChar != ']' {
-		path = append(path, Path{PathTypeKey, key[lastIndex:]})
+		path = append(path, Path{PathTypeKey, key[lastPos:]})
 	}
 	return path, nil
 }
-
-func GenPath(path []Path) string {
-	var s strings.Builder
-	for i, p := range path {
-		if p.Type == PathTypeKey {
-			if i > 0 {
-				s.WriteString(".")
-			}
-			s.WriteString(p.Elem)
-			continue
-		}
-		if p.Type == PathTypeIndex {
-			s.WriteString("[")
-			s.WriteString(p.Elem)
-			s.WriteString("]")
-			continue
-		}
-	}
-	return s.String()
-}

conf/internal/path_test.go

@@ -146,7 +146,7 @@ func TestSplitPath(t *testing.T) {
 		assert.Equal(t, err, c.Err, fmt.Sprintf("index: %d key: %q", i, c.Key))
 		assert.Equal(t, p, c.Path, fmt.Sprintf("index:%d key: %q", i, c.Key))
 		if err == nil {
-			s := internal.GenPath(p)
+			s := internal.JoinPath(p)
 			assert.Equal(t, s, c.Key, fmt.Sprintf("index:%d key: %q", i, c.Key))
 		}
 	}