Merge pull request #4 from go-spring/develop

Develop

Author: lvan100

conf/bind.go

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2024 the original author or authors.
+ * Copyright 2024 The Go-Spring Authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@ import (
 	"strings"
 
 	"github.com/go-spring/spring-core/util"
-	"github.com/go-spring/spring-core/util/macro"
+	"github.com/go-spring/spring-core/util/errutil"
 )
 
 var (
@@ -94,22 +94,27 @@ type BindParam struct {
 }
 
 func (param *BindParam) BindTag(tag string, validate reflect.StructTag) error {
+	param.Validate = validate
 	parsedTag, err := ParseTag(tag)
 	if err != nil {
 		return err
 	}
+	if parsedTag.Key == "" { // ${:=} 默认值语法
+		if parsedTag.HasDef {
+			param.Tag = parsedTag
+			return nil
+		}
+		return fmt.Errorf("xxxx") // todo
+	}
 	if parsedTag.Key == "ROOT" {
 		parsedTag.Key = ""
-	} else if parsedTag.Key == "" {
-		parsedTag.Key = "ANONYMOUS"
 	}
-	param.Tag = parsedTag
 	if param.Key == "" {
 		param.Key = parsedTag.Key
 	} else if parsedTag.Key != "" {
 		param.Key = param.Key + "." + parsedTag.Key
 	}
-	param.Validate = validate
+	param.Tag = parsedTag
 	return nil
 }
 
@@ -118,11 +123,11 @@ type Filter interface {
 }
 
 // BindValue binds properties to a value.
-func BindValue(p readOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) (RetErr error) {
+func BindValue(p ReadOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) (RetErr error) {
 
-	if !util.IsValueType(t) {
+	if !util.IsPropBindingTarget(t) {
 		err := errors.New("target should be value type")
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return fmt.Errorf("bind path=%s type=%s error: %w", param.Path, v.Type().String(), err)
 	}
 
 	defer func() {
@@ -144,29 +149,29 @@ func BindValue(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bind
 		return bindSlice(p, v, t, param, filter)
 	case reflect.Array:
 		err := errors.New("use slice instead of array")
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return fmt.Errorf("bind path=%s type=%s error: %w", param.Path, v.Type().String(), err)
 	default: // for linter
 	}
 
 	fn := converters[t]
 	if fn == nil && v.Kind() == reflect.Struct {
 		if err := bindStruct(p, v, t, param, filter); err != nil {
-			return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+			return err // no wrap
 		}
 		return nil
 	}
 
 	val, err := resolve(p, param)
 	if err != nil {
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	if fn != nil {
 		fnValue := reflect.ValueOf(fn)
 		out := fnValue.Call([]reflect.Value{reflect.ValueOf(val)})
 		if !out[1].IsNil() {
 			err = out[1].Interface().(error)
-			return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+			return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 		}
 		v.Set(out[0])
 		return nil
@@ -179,45 +184,45 @@ func BindValue(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bind
 			v.SetUint(u)
 			return nil
 		}
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		var i int64
 		if i, err = strconv.ParseInt(val, 0, 0); err == nil {
 			v.SetInt(i)
 			return nil
 		}
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Float32, reflect.Float64:
 		var f float64
 		if f, err = strconv.ParseFloat(val, 64); err == nil {
 			v.SetFloat(f)
 			return nil
 		}
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Bool:
 		var b bool
 		if b, err = strconv.ParseBool(val); err == nil {
 			v.SetBool(b)
 			return nil
 		}
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.String:
 		v.SetString(val)
 		return nil
 	default: // for linter
 	}
 
-	err = fmt.Errorf("unsupported bind type %q", t.String())
-	return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+	err = errors.New("unsupported bind type")
+	return fmt.Errorf("bind path=%s type=%s error: %w", param.Path, v.Type().String(), err)
 }
 
 // bindSlice binds properties to a slice value.
-func bindSlice(p readOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
+func bindSlice(p ReadOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
 
 	et := t.Elem()
 	p, err := getSlice(p, et, param)
 	if err != nil {
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	slice := reflect.MakeSlice(t, 0, 0)
@@ -238,14 +243,14 @@ func bindSlice(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bind
 			break
 		}
 		if err != nil {
-			return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+			return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 		}
 		slice = reflect.Append(slice, e)
 	}
 	return nil
 }
 
-func getSlice(p readOnlyProperties, et reflect.Type, param BindParam) (readOnlyProperties, error) {
+func getSlice(p ReadOnlyProperties, et reflect.Type, param BindParam) (ReadOnlyProperties, error) {
 
 	// properties that defined as list.
 	if p.Has(param.Key + "[0]") {
@@ -259,13 +264,13 @@ func getSlice(p readOnlyProperties, et reflect.Type, param BindParam) (readOnlyP
 			strVal = p.Get(param.Key)
 		} else {
 			if !param.Tag.HasDef {
-				return nil, fmt.Errorf("%s: property %q %w", macro.FileLine(), param.Key, ErrNotExist)
+				return nil, fmt.Errorf("property %q %w", param.Key, ErrNotExist)
 			}
 			if param.Tag.Def == "" {
 				return nil, nil
 			}
 			if !util.IsPrimitiveValueType(et) && converters[et] == nil {
-				return nil, fmt.Errorf("%s: can't find converter for %s", macro.FileLine(), et.String())
+				return nil, fmt.Errorf("can't find converter for %s", et.String())
 			}
 			strVal = param.Tag.Def
 		}
@@ -286,35 +291,44 @@ func getSlice(p readOnlyProperties, et reflect.Type, param BindParam) (readOnlyP
 		}
 	} else if fn, ok := splitters[s]; ok && fn != nil {
 		if arrVal, err = fn(strVal); err != nil {
-			return nil, fmt.Errorf("%s: split error: %w, value: %q", macro.FileLine(), err, strVal)
+			return nil, fmt.Errorf("split error: %w, value: %q", err, strVal)
 		}
 	} else {
-		return nil, fmt.Errorf("%s: unknown splitter %q", macro.FileLine(), s)
+		return nil, fmt.Errorf("unknown splitter %q", s)
 	}
 
 	r := New()
 	for i, s := range arrVal {
 		k := fmt.Sprintf("%s[%d]", param.Key, i)
-		_ = r.storage.Set(k, s)
+		if err = r.storage.Set(k, s); err != nil {
+			return nil, err
+		}
 	}
 	return r, nil
 }
 
 // bindMap binds properties to a map value.
-func bindMap(p readOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
+func bindMap(p ReadOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
 
 	if param.Tag.HasDef && param.Tag.Def != "" {
 		err := errors.New("map can't have a non-empty default value")
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return fmt.Errorf("bind path=%s type=%s error: %w", param.Path, v.Type().String(), err)
 	}
 
 	et := t.Elem()
 	ret := reflect.MakeMap(t)
 	defer func() { v.Set(ret) }()
 
+	// 当成默认值处理
+	if param.Tag.Key == "" {
+		if param.Tag.HasDef {
+			return nil
+		}
+	}
+
 	keys, err := p.SubKeys(param.Key)
 	if err != nil {
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	for _, key := range keys {
@@ -327,21 +341,20 @@ func bindMap(p readOnlyProperties, v reflect.Value, t reflect.Type, param BindPa
 			Key:  subKey,
 			Path: param.Path,
 		}
-		err = BindValue(p, e, et, subParam, filter)
-		if err != nil {
-			return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		if err = BindValue(p, e, et, subParam, filter); err != nil {
+			return err // no wrap
 		}
 		ret.SetMapIndex(reflect.ValueOf(key), e)
 	}
 	return nil
 }
 
 // bindStruct binds properties to a struct value.
-func bindStruct(p readOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
+func bindStruct(p ReadOnlyProperties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
 
 	if param.Tag.HasDef && param.Tag.Def != "" {
 		err := errors.New("struct can't have a non-empty default value")
-		return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+		return fmt.Errorf("bind path=%s type=%s error: %w", param.Path, v.Type().String(), err)
 	}
 
 	for i := 0; i < t.NumField(); i++ {
@@ -359,7 +372,7 @@ func bindStruct(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bin
 
 		if tag, ok := ft.Tag.Lookup("value"); ok {
 			if err := subParam.BindTag(tag, ft.Tag); err != nil {
-				return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+				return errutil.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 			}
 			if filter != nil {
 				ret, err := filter.Do(fv.Addr().Interface(), subParam)
@@ -371,7 +384,7 @@ func bindStruct(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bin
 				}
 			}
 			if err := BindValue(p, fv, ft.Type, subParam, filter); err != nil {
-				return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+				return err // no wrap
 			}
 			continue
 		}
@@ -382,12 +395,12 @@ func bindStruct(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bin
 				continue
 			}
 			if err := bindStruct(p, fv, ft.Type, subParam, filter); err != nil {
-				return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+				return err // no wrap
 			}
 			continue
 		}
 
-		if util.IsValueType(ft.Type) {
+		if util.IsPropBindingTarget(ft.Type) {
 			if subParam.Key == "" {
 				subParam.Key = ft.Name
 			} else {
@@ -396,33 +409,31 @@ func bindStruct(p readOnlyProperties, v reflect.Value, t reflect.Type, param Bin
 			subParam.Key = strings.ToLower(subParam.Key)
 			subParam.Key = strings.ReplaceAll(subParam.Key, "_", ".")
 			if err := BindValue(p, fv, ft.Type, subParam, filter); err != nil {
-				return fmt.Errorf("%s: bind %s error, %w", macro.FileLine(), param.Path, err)
+				return err // no wrap
 			}
 		}
 	}
 	return nil
 }
 
 // resolve returns property references processed property value.
-func resolve(p readOnlyProperties, param BindParam) (string, error) {
+func resolve(p ReadOnlyProperties, param BindParam) (string, error) {
 	const defVal = "@@def@@"
-	val := p.Get(param.Key, Def(defVal))
+	val := p.Get(param.Key, defVal)
 	if val != defVal {
 		return resolveString(p, val)
 	}
 	if p.Has(param.Key) {
-		err := fmt.Errorf("property %q isn't simple value", param.Key)
-		return "", fmt.Errorf("%s: resolve property %q error, %w", macro.FileLine(), param.Key, err)
+		return "", fmt.Errorf("property key=%s isn't simple value", param.Key)
 	}
 	if param.Tag.HasDef {
 		return resolveString(p, param.Tag.Def)
 	}
-	err := fmt.Errorf("property %q %w", param.Key, ErrNotExist)
-	return "", fmt.Errorf("%s: resolve property %q error, %w", macro.FileLine(), param.Key, err)
+	return "", fmt.Errorf("property key=%s %w", param.Key, ErrNotExist)
 }
 
 // resolveString returns property references processed string.
-func resolveString(p readOnlyProperties, s string) (string, error) {
+func resolveString(p ReadOnlyProperties, s string) (string, error) {
 
 	var (
 		length = len(s)
@@ -456,20 +467,20 @@ func resolveString(p readOnlyProperties, s string) (string, error) {
 
 	if end < 0 || count > 0 {
 		err := ErrInvalidSyntax
-		return "", fmt.Errorf("%s: resolve string %q error, %w", macro.FileLine(), s, err)
+		return "", fmt.Errorf("resolve string %q error: %w", s, err)
 	}
 
 	var param BindParam
 	_ = param.BindTag(s[start:end+1], "")
 
 	s1, err := resolve(p, param)
 	if err != nil {
-		return "", fmt.Errorf("%s: resolve string %q error, %w", macro.FileLine(), s, err)
+		return "", errutil.WrapError(err, "resolve string %q error", s)
 	}
 
 	s2, err := resolveString(p, s[end+1:])
 	if err != nil {
-		return "", fmt.Errorf("%s: resolve string %q error, %w", macro.FileLine(), s, err)
+		return "", errutil.WrapError(err, "resolve string %q error", s)
 	}
 
 	return s[:start] + s1 + s2, nil