chore: rename some func, add more unit tests and more

- update readme
- add more validator alias

Author: inhere

README.md

@@ -596,7 +596,7 @@ validator/aliases | description
 `intEq/intEqual`  |  Check value is int and equals to the given value.
 `len/length`  |  Check value length is equals to the given size(use for `string` `array` `slice` `map`).
 `regex/regexp`  |  Check if the value can pass the regular verification
-`arr/array/isArray`  |   Check value is array type
+`arr/list/array/isArray`  |   Check value is array, slice type
 `map/isMap`  |  Check value is a MAP type
 `strings/isStrings`  |  Check value is string slice type(only allow `[]string`).
 `ints/isInts`  |  Check value is int slice type(only allow `[]int`).

README.zh-CN.md

@@ -528,7 +528,7 @@ func main()  {
 `max_len/maxLen/maxLength`  |  检查值的最大长度是给定大小
 `email/isEmail`  |   检查值是Email地址字符串
 `regex/regexp`  |  检查该值是否可以通过正则验证
-`arr/array/isArray`  |  检查值是数组`array`类型
+`arr/list/array/isArray`  |  检查值是 `array` 或者 `slice`类型
 `map/isMap`  |  检查值是 `map` 类型
 `strings/isStrings`  |  检查值是字符串切片类型(`[]string`)
 `ints/isInts`  |  检查值是`int` slice类型(only allow `[]int`)

cache.go

@@ -1,10 +1,5 @@
 package validate
 
-import (
-	"database/sql/driver"
-	"fmt"
-)
-
 /*
 // TODO: idea for optimize ...
 // - use pool for Validation
@@ -46,8 +41,29 @@ func (f *factory) put(v *Validation) {
 }
 */
 
-func test() {
-	i32 := driver.Int32
+// func test() {
+// 	i32 := driver.Int32
+// 	fmt.Println(i32)
+// }
 
-	fmt.Println(i32)
+/*
+// TODO cache struct reflect value, tags and more
+type structMeta struct {
 }
+
+type cache struct {
+	m sync.Map
+	// m atomic.Value
+	// map[reflect.Type]*cStruct
+}
+
+func (c *cache) get(rt reflect.Type) *structMeta {
+	// key := rt.PkgPath() + rt.Name()
+	return c.m.Load(rt)
+}
+
+func (c *cache) set(rt reflect.Type, meta structMeta)  {
+	// key := rt.PkgPath() + rt.Name()
+	c.m.Store(rt, data)
+}
+*/

data_source.go

@@ -635,7 +635,7 @@ func (d *StructData) Set(field string, val interface{}) (newVal interface{}, err
 		return nil, err
 	}
 
-	newVal, err = convertType(val, srcKind, fv.Kind())
+	newVal, err = convTypeByBaseKind(val, srcKind, fv.Kind())
 	if err != nil {
 		return nil, err
 	}

register.go

@@ -126,21 +126,26 @@ var validatorAliases = map[string]string{
 	"integer":   "isInt",
 	"uint":      "isUint",
 	"bool":      "isBool",
+	"boolean":   "isBool",
 	"float":     "isFloat",
 	"map":       "isMap",
 	"ints":      "isInts", // []int
 	"int_slice": "isInts",
+	"int_list":  "isInts",
 	"str":       "isString",
 	"string":    "isString",
 	"strings":   "isStrings", // []string
+	"str_list":  "isStrings",
 	"str_slice": "isStrings",
 	"arr":       "isArray",
+	"list":      "isArray",
 	"array":     "isArray",
 	"slice":     "isSlice",
 	// val
 	"regex":  "regexp",
 	"eq":     "isEqual",
 	"equal":  "isEqual",
+	"equals": "isEqual",
 	"intEq":  "intEqual",
 	"int_eq": "intEqual",
 	"ne":     "notEqual",

util.go

@@ -310,25 +310,6 @@ func parseArgString(argStr string) (ss []string) {
 	return stringSplit(argStr, ",")
 }
 
-func toInt64Slice(enum interface{}) (ret []int64, ok bool) {
-	rv := reflect.ValueOf(enum)
-	if rv.Kind() != reflect.Slice {
-		return
-	}
-
-	for i := 0; i < rv.Len(); i++ {
-		i64, err := mathutil.ToInt64(rv.Index(i).Interface())
-		if err != nil {
-			return []int64{}, false
-		}
-
-		ret = append(ret, i64)
-	}
-
-	ok = true
-	return
-}
-
 func getVariadicKind(typString string) reflect.Kind {
 	switch typString {
 	case "[]int":
@@ -359,8 +340,8 @@ func getVariadicKind(typString string) reflect.Kind {
 	return reflect.Invalid
 }
 
-// convertType use basic kind
-func convertType(srcVal interface{}, srcKind kind, dstType reflect.Kind) (interface{}, error) {
+// convTypeByBaseKind convert value type by base kind
+func convTypeByBaseKind(srcVal interface{}, srcKind kind, dstType reflect.Kind) (interface{}, error) {
 	switch srcKind {
 	case stringKind:
 		switch dstType {
@@ -377,7 +358,6 @@ func convertType(srcVal interface{}, srcKind kind, dstType reflect.Kind) (interf
 		case reflect.Int64:
 			return i64, nil
 		case reflect.String:
-			// fmt is slow : return fmt.Sprint(i64), nil
 			return strutil.ToString(srcVal)
 		}
 	default:
@@ -389,6 +369,24 @@ func convertType(srcVal interface{}, srcKind kind, dstType reflect.Kind) (interf
 	return nil, ErrConvertFail
 }
 
+// convert custom type to generic basic int, string, unit.
+// returns string, int64 or error
+func convToBasicType(val interface{}) (value interface{}, err error) {
+	v := reflect.ValueOf(val)
+
+	switch v.Kind() {
+	case reflect.String:
+		value = v.String()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		value = v.Int()
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		value = v.Int() // always return int64
+	default:
+		err = ErrConvertFail
+	}
+	return
+}
+
 func panicf(format string, args ...interface{}) {
 	panic("validate: " + fmt.Sprintf(format, args...))
 }
@@ -424,7 +422,7 @@ func checkValidatorFunc(name string, fn interface{}) reflect.Value {
 
 func checkFilterFunc(name string, fn interface{}) reflect.Value {
 	if !goodName(name) {
-		panic(fmt.Errorf("filter name %s is not a valid identifier", name))
+		panicf("filter name %s is not a valid identifier", name)
 	}
 
 	fv := reflect.ValueOf(fn)
@@ -473,32 +471,6 @@ func goodName(name string) bool {
 	return true
 }
 
-// ---- From package "text/template" -> text/template/exec.go
-// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
-// func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
-// 	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
-// 		if v.IsNil() {
-// 			return v, true
-// 		}
-// 	}
-// 	return v, false
-// }
-
-// indirectInterface returns the concrete value in an interface value,
-// or else the zero reflect.Value.
-// That is, if v represents the interface value x, the result is the same as reflect.ValueOf(x):
-// the fact that x was an interface value is forgotten.
-func indirectInterface(v reflect.Value) reflect.Value {
-	if v.Kind() != reflect.Interface {
-		return v
-	}
-
-	if v.IsNil() {
-		return emptyValue
-	}
-	return v.Elem()
-}
-
 /*************************************************************
  * Comparison:
  * From package "text/template" -> text/template/funcs.go
@@ -514,6 +486,7 @@ var (
 
 type kind int
 
+// base kinds
 const (
 	invalidKind kind = iota
 	boolKind
@@ -524,10 +497,6 @@ const (
 	uintKind
 )
 
-func basicKind(v reflect.Value) (kind, error) {
-	return basicKindV2(v.Kind())
-}
-
 func basicKindV2(kind reflect.Kind) (kind, error) {
 	switch kind {
 	case reflect.Bool:
@@ -640,6 +609,7 @@ func includeElement(list, element interface{}) (ok, found bool) {
 
 // IsZero reports whether v is the zero value for its type.
 // It panics if the argument is invalid.
+//
 // NOTICE: this built-in method in reflect/value.go since go 1.13
 func IsZero(v reflect.Value) bool {
 	switch v.Kind() {
@@ -696,3 +666,30 @@ func removeValuePtr(t reflect.Value) reflect.Value {
 	}
 	return t
 }
+
+// ---- From package "text/template" -> text/template/exec.go
+
+// indirect returns the item at the end of indirection, and a bool to indicate if it's nil.
+// func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
+// 	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
+// 		if v.IsNil() {
+// 			return v, true
+// 		}
+// 	}
+// 	return v, false
+// }
+
+// indirectInterface returns the concrete value in an interface value,
+// or else the zero reflect.Value.
+// That is, if v represents the interface value x, the result is the same as reflect.ValueOf(x):
+// the fact that x was an interface value is forgotten.
+func indirectInterface(v reflect.Value) reflect.Value {
+	if v.Kind() != reflect.Interface {
+		return v
+	}
+
+	if v.IsNil() {
+		return emptyValue
+	}
+	return v.Elem()
+}

validate_test.go

@@ -82,18 +82,21 @@ func TestUtil_Func_goodName(t *testing.T) {
 }
 
 func Test_Util_Func_convertType(t *testing.T) {
-	nVal, err := convertType(23, intKind, reflect.String)
+	nVal, err := convTypeByBaseKind(23, intKind, reflect.String)
 	assert.NoError(t, err)
 	assert.Equal(t, "23", nVal)
 
-	nVal, err = convertType(uint(23), uintKind, reflect.String)
+	nVal, err = convTypeByBaseKind(uint(23), uintKind, reflect.String)
 	assert.NoError(t, err)
 	assert.Equal(t, "23", nVal)
 }
 
 func Test_IsZero(t *testing.T) {
 	assert.True(t, IsZero(reflect.ValueOf([2]int{})))
 	assert.True(t, IsZero(reflect.ValueOf(false)))
+	assert.Panics(t, func() {
+		IsZero(reflect.ValueOf(nil))
+	})
 }
 
 func TestMS_String(t *testing.T) {

validation.go

@@ -3,6 +3,7 @@ package validate
 import (
 	"fmt"
 	"reflect"
+	"strings"
 )
 
 // some default value settings.
@@ -379,12 +380,17 @@ func (v *Validation) RawVal(key string) interface{} {
 	return val
 }
 
-// Get value by key
+// Get value by key.
 func (v *Validation) Get(key string) (interface{}, bool) {
 	if v.data == nil { // check input data
 		return nil, false
 	}
 
+	// if end withs: .*, return the parent value
+	if strings.HasSuffix(key, ".*") {
+		key = key[0 : len(key)-2]
+	}
+
 	// find from filtered data.
 	if val, ok := v.filteredData[key]; ok {
 		return val, true
@@ -395,6 +401,8 @@ func (v *Validation) Get(key string) (interface{}, bool) {
 		return val, true
 	}
 
+	// TODO add cache data v.caches[key]
+
 	// get from source data
 	return v.data.Get(key)
 }