Merge pull request #228 from joeybloggs/v8-development

Add FieldNamespace and NameNamespace + string comparison optimizations
pull/229/head
Dean Karn 9 years ago
commit b737e38edb
  1. 60
      README.md
  2. 2
      baked_in.go
  3. 11
      util.go
  4. 242
      validator.go
  5. 116
      validator_test.go

@ -308,38 +308,38 @@ func validateStruct() {
Benchmarks Benchmarks
------ ------
###### Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go 1.5.1 ###### Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go version go1.5.2 darwin/amd64
```go ```go
$ go test -cpu=4 -bench=. -benchmem=true go test -cpu=4 -bench=. -benchmem=true
PASS PASS
BenchmarkFieldSuccess-4 10000000 162 ns/op 0 B/op 0 allocs/op BenchmarkFieldSuccess-4 10000000 176 ns/op 0 B/op 0 allocs/op
BenchmarkFieldFailure-4 2000000 678 ns/op 400 B/op 4 allocs/op BenchmarkFieldFailure-4 2000000 727 ns/op 432 B/op 4 allocs/op
BenchmarkFieldDiveSuccess-4 500000 3079 ns/op 480 B/op 27 allocs/op BenchmarkFieldDiveSuccess-4 500000 3220 ns/op 480 B/op 27 allocs/op
BenchmarkFieldDiveFailure-4 300000 3584 ns/op 880 B/op 31 allocs/op BenchmarkFieldDiveFailure-4 500000 3823 ns/op 912 B/op 31 allocs/op
BenchmarkFieldCustomTypeSuccess-4 5000000 345 ns/op 32 B/op 2 allocs/op BenchmarkFieldCustomTypeSuccess-4 5000000 368 ns/op 32 B/op 2 allocs/op
BenchmarkFieldCustomTypeFailure-4 2000000 650 ns/op 400 B/op 4 allocs/op BenchmarkFieldCustomTypeFailure-4 2000000 699 ns/op 432 B/op 4 allocs/op
BenchmarkFieldOrTagSuccess-4 1000000 1188 ns/op 16 B/op 1 allocs/op BenchmarkFieldOrTagSuccess-4 1000000 1265 ns/op 16 B/op 1 allocs/op
BenchmarkFieldOrTagFailure-4 1000000 1088 ns/op 432 B/op 6 allocs/op BenchmarkFieldOrTagFailure-4 1000000 1182 ns/op 464 B/op 6 allocs/op
BenchmarkStructLevelValidationSuccess-4 2000000 689 ns/op 160 B/op 6 allocs/op BenchmarkStructLevelValidationSuccess-4 2000000 739 ns/op 176 B/op 6 allocs/op
BenchmarkStructLevelValidationFailure-4 1000000 1290 ns/op 592 B/op 11 allocs/op BenchmarkStructLevelValidationFailure-4 1000000 1368 ns/op 640 B/op 11 allocs/op
BenchmarkStructSimpleCustomTypeSuccess-4 2000000 911 ns/op 80 B/op 5 allocs/op BenchmarkStructSimpleCustomTypeSuccess-4 2000000 965 ns/op 80 B/op 5 allocs/op
BenchmarkStructSimpleCustomTypeFailure-4 1000000 1446 ns/op 624 B/op 11 allocs/op BenchmarkStructSimpleCustomTypeFailure-4 1000000 1561 ns/op 688 B/op 11 allocs/op
BenchmarkStructPartialSuccess-4 1000000 1221 ns/op 384 B/op 10 allocs/op BenchmarkStructPartialSuccess-4 1000000 1285 ns/op 384 B/op 10 allocs/op
BenchmarkStructPartialFailure-4 1000000 1764 ns/op 800 B/op 15 allocs/op BenchmarkStructPartialFailure-4 1000000 1879 ns/op 832 B/op 15 allocs/op
BenchmarkStructExceptSuccess-4 2000000 941 ns/op 336 B/op 7 allocs/op BenchmarkStructExceptSuccess-4 2000000 1038 ns/op 336 B/op 7 allocs/op
BenchmarkStructExceptFailure-4 1000000 1237 ns/op 384 B/op 10 allocs/op BenchmarkStructExceptFailure-4 1000000 1330 ns/op 384 B/op 10 allocs/op
BenchmarkStructSimpleCrossFieldSuccess-4 2000000 970 ns/op 128 B/op 6 allocs/op BenchmarkStructSimpleCrossFieldSuccess-4 1000000 1081 ns/op 128 B/op 6 allocs/op
BenchmarkStructSimpleCrossFieldFailure-4 1000000 1560 ns/op 560 B/op 11 allocs/op BenchmarkStructSimpleCrossFieldFailure-4 1000000 1737 ns/op 592 B/op 11 allocs/op
BenchmarkStructSimpleCrossStructCrossFieldSuccess-4 1000000 1542 ns/op 176 B/op 9 allocs/op BenchmarkStructSimpleCrossStructCrossFieldSuccess-4 1000000 1790 ns/op 192 B/op 10 allocs/op
BenchmarkStructSimpleCrossStructCrossFieldFailure-4 1000000 2147 ns/op 608 B/op 14 allocs/op BenchmarkStructSimpleCrossStructCrossFieldFailure-4 500000 2431 ns/op 656 B/op 15 allocs/op
BenchmarkStructSimpleSuccess-4 2000000 847 ns/op 48 B/op 3 allocs/op BenchmarkStructSimpleSuccess-4 2000000 950 ns/op 48 B/op 3 allocs/op
BenchmarkStructSimpleFailure-4 1000000 1497 ns/op 624 B/op 11 allocs/op BenchmarkStructSimpleFailure-4 1000000 1672 ns/op 688 B/op 11 allocs/op
BenchmarkStructSimpleSuccessParallel-4 5000000 257 ns/op 48 B/op 3 allocs/op BenchmarkStructSimpleSuccessParallel-4 5000000 271 ns/op 48 B/op 3 allocs/op
BenchmarkStructSimpleFailureParallel-4 2000000 586 ns/op 624 B/op 11 allocs/op BenchmarkStructSimpleFailureParallel-4 2000000 670 ns/op 688 B/op 11 allocs/op
BenchmarkStructComplexSuccess-4 300000 5104 ns/op 496 B/op 29 allocs/op BenchmarkStructComplexSuccess-4 300000 5828 ns/op 544 B/op 32 allocs/op
BenchmarkStructComplexFailure-4 200000 9840 ns/op 3400 B/op 71 allocs/op BenchmarkStructComplexFailure-4 200000 11382 ns/op 3912 B/op 77 allocs/op
BenchmarkStructComplexSuccessParallel-4 1000000 1540 ns/op 496 B/op 29 allocs/op BenchmarkStructComplexSuccessParallel-4 1000000 1739 ns/op 544 B/op 32 allocs/op
BenchmarkStructComplexFailureParallel-4 500000 3478 ns/op 3400 B/op 71 allocs/op BenchmarkStructComplexFailureParallel-4 300000 4682 ns/op 3912 B/op 77 allocs/op
``` ```
How to Contribute How to Contribute

@ -756,7 +756,7 @@ func IsURL(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Va
return false return false
} }
if len(url.Scheme) == 0 { if url.Scheme == blank {
return false return false
} }

@ -8,6 +8,7 @@ import (
) )
const ( const (
dash = "-"
blank = "" blank = ""
namespaceSeparator = "." namespaceSeparator = "."
leftBracket = "[" leftBracket = "["
@ -86,7 +87,7 @@ func (v *Validate) GetStructFieldOK(current reflect.Value, namespace string) (re
return current, kind, false return current, kind, false
} }
if len(namespace) == 0 { if namespace == blank {
return current, kind, true return current, kind, true
} }
@ -262,7 +263,7 @@ func (v *Validate) parseStruct(current reflect.Value, sName string) *cachedStruc
fld = typ.Field(i) fld = typ.Field(i)
if len(fld.PkgPath) != 0 { if fld.PkgPath != blank {
continue continue
} }
@ -273,7 +274,7 @@ func (v *Validate) parseStruct(current reflect.Value, sName string) *cachedStruc
} }
customName = fld.Name customName = fld.Name
if len(v.fieldNameTag) != 0 { if v.fieldNameTag != blank {
name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0] name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0]
@ -309,7 +310,7 @@ func (v *Validate) parseTags(tag, fieldName string) *cachedTag {
func (v *Validate) parseTagsRecursive(cTag *cachedTag, tag, fieldName, alias string, isAlias bool) bool { func (v *Validate) parseTagsRecursive(cTag *cachedTag, tag, fieldName, alias string, isAlias bool) bool {
if len(tag) == 0 { if tag == blank {
return true return true
} }
@ -365,7 +366,7 @@ func (v *Validate) parseTagsRecursive(cTag *cachedTag, tag, fieldName, alias str
tagVal.tag = alias tagVal.tag = alias
} }
if len(key) == 0 { if key == blank {
panic(strings.TrimSpace(fmt.Sprintf(invalidValidation, fieldName))) panic(strings.TrimSpace(fmt.Sprintf(invalidValidation, fieldName)))
} }

@ -52,6 +52,7 @@ type StructLevel struct {
TopStruct reflect.Value TopStruct reflect.Value
CurrentStruct reflect.Value CurrentStruct reflect.Value
errPrefix string errPrefix string
nsPrefix string
errs ValidationErrors errs ValidationErrors
v *Validate v *Validate
} }
@ -60,9 +61,29 @@ type StructLevel struct {
// Example: had a triple nested struct User, ContactInfo, Country and ran errs := validate.Struct(country) // Example: had a triple nested struct User, ContactInfo, Country and ran errs := validate.Struct(country)
// from within a User struct level validation would call this method like so: // from within a User struct level validation would call this method like so:
// ReportValidationErrors("ContactInfo.", errs) // ReportValidationErrors("ContactInfo.", errs)
// NOTE: relativeKey can contain both the Field Relative and Custom name relative paths
// i.e. ReportValidationErrors("ContactInfo.|cInfo", errs) where cInfo represents say the JSON name of
// the relative path; this will be split into 2 variables in the next valiator version.
func (sl *StructLevel) ReportValidationErrors(relativeKey string, errs ValidationErrors) { func (sl *StructLevel) ReportValidationErrors(relativeKey string, errs ValidationErrors) {
for _, e := range errs { for _, e := range errs {
sl.errs[sl.errPrefix+relativeKey+e.Field] = e
idx := strings.Index(relativeKey, "|")
var rel string
var cRel string
if idx != -1 {
rel = relativeKey[:idx]
cRel = relativeKey[idx+1:]
} else {
rel = relativeKey
}
key := sl.errPrefix + rel + e.Field
e.FieldNamespace = key
e.NameNamespace = sl.nsPrefix + cRel + e.Name
sl.errs[key] = e
} }
} }
@ -73,38 +94,44 @@ func (sl *StructLevel) ReportError(field reflect.Value, fieldName string, custom
field, kind := sl.v.ExtractType(field) field, kind := sl.v.ExtractType(field)
if len(fieldName) == 0 { if fieldName == blank {
panic(fieldNameRequired) panic(fieldNameRequired)
} }
if len(customName) == 0 { if customName == blank {
customName = fieldName customName = fieldName
} }
if len(tag) == 0 { if tag == blank {
panic(tagRequired) panic(tagRequired)
} }
ns := sl.errPrefix + fieldName
switch kind { switch kind {
case reflect.Invalid: case reflect.Invalid:
sl.errs[sl.errPrefix+fieldName] = &FieldError{ sl.errs[ns] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: fieldName, NameNamespace: sl.nsPrefix + customName,
Tag: tag, Name: customName,
ActualTag: tag, Field: fieldName,
Param: blank, Tag: tag,
Kind: kind, ActualTag: tag,
Param: blank,
Kind: kind,
} }
default: default:
sl.errs[sl.errPrefix+fieldName] = &FieldError{ sl.errs[ns] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: fieldName, NameNamespace: sl.nsPrefix + customName,
Tag: tag, Name: customName,
ActualTag: tag, Field: fieldName,
Param: blank, Tag: tag,
Value: field.Interface(), ActualTag: tag,
Kind: kind, Param: blank,
Type: field.Type(), Value: field.Interface(),
Kind: kind,
Type: field.Type(),
} }
} }
} }
@ -178,14 +205,16 @@ func (ve ValidationErrors) Error() string {
// FieldError contains a single field's validation error along // FieldError contains a single field's validation error along
// with other properties that may be needed for error message creation // with other properties that may be needed for error message creation
type FieldError struct { type FieldError struct {
Field string FieldNamespace string
Name string NameNamespace string
Tag string Field string
ActualTag string Name string
Kind reflect.Kind Tag string
Type reflect.Type ActualTag string
Param string Kind reflect.Kind
Value interface{} Type reflect.Type
Param string
Value interface{}
} }
// New creates a new Validate instance for use. // New creates a new Validate instance for use.
@ -241,7 +270,7 @@ func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interfa
func (v *Validate) RegisterValidation(key string, fn Func) error { func (v *Validate) RegisterValidation(key string, fn Func) error {
v.initCheck() v.initCheck()
if len(key) == 0 { if key == blank {
return errors.New("Function Key cannot be empty") return errors.New("Function Key cannot be empty")
} }
@ -306,7 +335,7 @@ func (v *Validate) Field(field interface{}, tag string) error {
errs := v.errsPool.Get().(ValidationErrors) errs := v.errsPool.Get().(ValidationErrors)
fieldVal := reflect.ValueOf(field) fieldVal := reflect.ValueOf(field)
v.traverseField(fieldVal, fieldVal, fieldVal, blank, errs, false, tag, blank, blank, false, false, nil, nil) v.traverseField(fieldVal, fieldVal, fieldVal, blank, blank, errs, false, tag, blank, blank, false, false, nil, nil)
if len(errs) == 0 { if len(errs) == 0 {
v.errsPool.Put(errs) v.errsPool.Put(errs)
@ -326,7 +355,7 @@ func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string
errs := v.errsPool.Get().(ValidationErrors) errs := v.errsPool.Get().(ValidationErrors)
topVal := reflect.ValueOf(val) topVal := reflect.ValueOf(val)
v.traverseField(topVal, topVal, reflect.ValueOf(field), blank, errs, false, tag, blank, blank, false, false, nil, nil) v.traverseField(topVal, topVal, reflect.ValueOf(field), blank, blank, errs, false, tag, blank, blank, false, false, nil, nil)
if len(errs) == 0 { if len(errs) == 0 {
v.errsPool.Put(errs) v.errsPool.Put(errs)
@ -384,7 +413,7 @@ func (v *Validate) StructPartial(current interface{}, fields ...string) error {
errs := v.errsPool.Get().(ValidationErrors) errs := v.errsPool.Get().(ValidationErrors)
v.tranverseStruct(sv, sv, sv, blank, errs, true, len(m) != 0, false, m, false) v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, false, m, false)
if len(errs) == 0 { if len(errs) == 0 {
v.errsPool.Put(errs) v.errsPool.Put(errs)
@ -406,12 +435,12 @@ func (v *Validate) StructExcept(current interface{}, fields ...string) error {
m := map[string]*struct{}{} m := map[string]*struct{}{}
for _, key := range fields { for _, key := range fields {
m[name+"."+key] = emptyStructPtr m[name+namespaceSeparator+key] = emptyStructPtr
} }
errs := v.errsPool.Get().(ValidationErrors) errs := v.errsPool.Get().(ValidationErrors)
v.tranverseStruct(sv, sv, sv, blank, errs, true, len(m) != 0, true, m, false) v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, true, m, false)
if len(errs) == 0 { if len(errs) == 0 {
v.errsPool.Put(errs) v.errsPool.Put(errs)
@ -430,7 +459,7 @@ func (v *Validate) Struct(current interface{}) error {
errs := v.errsPool.Get().(ValidationErrors) errs := v.errsPool.Get().(ValidationErrors)
sv := reflect.ValueOf(current) sv := reflect.ValueOf(current)
v.tranverseStruct(sv, sv, sv, blank, errs, true, false, false, nil, false) v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, false, false, nil, false)
if len(errs) == 0 { if len(errs) == 0 {
v.errsPool.Put(errs) v.errsPool.Put(errs)
@ -441,7 +470,7 @@ func (v *Validate) Struct(current interface{}) error {
} }
// tranverseStruct traverses a structs fields and then passes them to be validated by traverseField // tranverseStruct traverses a structs fields and then passes them to be validated by traverseField
func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]*struct{}, isStructOnly bool) { func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]*struct{}, isStructOnly bool) {
if current.Kind() == reflect.Ptr && !current.IsNil() { if current.Kind() == reflect.Ptr && !current.IsNil() {
current = current.Elem() current = current.Elem()
@ -457,7 +486,11 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
sName := typ.Name() sName := typ.Name()
if useStructName { if useStructName {
errPrefix += sName + "." errPrefix += sName + namespaceSeparator
if v.fieldNameTag != blank {
nsPrefix += sName + namespaceSeparator
}
} }
// structonly tag present don't tranverseFields // structonly tag present don't tranverseFields
@ -469,7 +502,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
// is anonymous struct, cannot parse or cache as // is anonymous struct, cannot parse or cache as
// it has no name to index by // it has no name to index by
if len(sName) == 0 { if sName == blank {
var customName string var customName string
var ok bool var ok bool
@ -479,7 +512,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
fld = typ.Field(i) fld = typ.Field(i)
if len(fld.PkgPath) != 0 { if fld.PkgPath != blank {
continue continue
} }
@ -493,17 +526,18 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
} }
customName = fld.Name customName = fld.Name
if v.fieldNameTag != "" {
if v.fieldNameTag != blank {
name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0] name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0]
// dash check is for json "-" means don't output in json // dash check is for json "-" means don't output in json
if name != "" && name != "-" { if name != blank && name != dash {
customName = name customName = name
} }
} }
v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, errs, true, fld.Tag.Get(v.tagName), fld.Name, customName, partial, exclude, includeExclude, nil) v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, nsPrefix, errs, true, fld.Tag.Get(v.tagName), fld.Name, customName, partial, exclude, includeExclude, nil)
} }
} else { } else {
s, ok := v.structCache.Get(typ) s, ok := v.structCache.Get(typ)
@ -523,7 +557,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
} }
fld = typ.Field(i) fld = typ.Field(i)
v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, errs, true, f.CachedTag.tag, fld.Name, f.AltName, partial, exclude, includeExclude, f.CachedTag) v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, nsPrefix, errs, true, f.CachedTag.tag, fld.Name, f.AltName, partial, exclude, includeExclude, f.CachedTag)
} }
} }
} }
@ -531,13 +565,13 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec
// check if any struct level validations, after all field validations already checked. // check if any struct level validations, after all field validations already checked.
if v.hasStructLevelFuncs { if v.hasStructLevelFuncs {
if fn, ok := v.structLevelFuncs[current.Type()]; ok { if fn, ok := v.structLevelFuncs[current.Type()]; ok {
fn(v, &StructLevel{v: v, TopStruct: topStruct, CurrentStruct: current, errPrefix: errPrefix, errs: errs}) fn(v, &StructLevel{v: v, TopStruct: topStruct, CurrentStruct: current, errPrefix: errPrefix, nsPrefix: nsPrefix, errs: errs})
} }
} }
} }
// traverseField validates any field, be it a struct or single field, ensures it's validity and passes it along to be validated via it's tag options // traverseField validates any field, be it a struct or single field, ensures it's validity and passes it along to be validated via it's tag options
func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, isStructField bool, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, isStructField bool, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) {
if tag == skipValidationTag { if tag == skipValidationTag {
return return
@ -561,29 +595,35 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
return return
} }
if len(tag) > 0 { if tag != blank {
ns := errPrefix + name
if kind == reflect.Invalid { if kind == reflect.Invalid {
errs[errPrefix+name] = &FieldError{ errs[ns] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: name, NameNamespace: nsPrefix + customName,
Tag: cTag.tags[0].tag, Name: customName,
ActualTag: cTag.tags[0].tagVals[0][0], Field: name,
Param: cTag.tags[0].tagVals[0][1], Tag: cTag.tags[0].tag,
Kind: kind, ActualTag: cTag.tags[0].tagVals[0][0],
Param: cTag.tags[0].tagVals[0][1],
Kind: kind,
} }
return return
} }
errs[errPrefix+name] = &FieldError{ errs[ns] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: name, NameNamespace: nsPrefix + customName,
Tag: cTag.tags[0].tag, Name: customName,
ActualTag: cTag.tags[0].tagVals[0][0], Field: name,
Param: cTag.tags[0].tagVals[0][1], Tag: cTag.tags[0].tag,
Value: current.Interface(), ActualTag: cTag.tags[0].tagVals[0][0],
Kind: kind, Param: cTag.tags[0].tagVals[0][1],
Type: current.Type(), Value: current.Interface(),
Kind: kind,
Type: current.Type(),
} }
return return
@ -603,12 +643,12 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
return return
} }
v.tranverseStruct(topStruct, current, current, errPrefix+name+".", errs, false, partial, exclude, includeExclude, cTag.isStructOnly) v.tranverseStruct(topStruct, current, current, errPrefix+name+namespaceSeparator, nsPrefix+customName+namespaceSeparator, errs, false, partial, exclude, includeExclude, cTag.isStructOnly)
return return
} }
} }
if len(tag) == 0 { if tag == blank {
return return
} }
@ -637,7 +677,7 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
continue continue
} }
if v.validateField(topStruct, currentStruct, current, typ, kind, errPrefix, errs, valTag, name, customName) { if v.validateField(topStruct, currentStruct, current, typ, kind, errPrefix, nsPrefix, errs, valTag, name, customName) {
return return
} }
} }
@ -647,9 +687,9 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
// or panic ;) // or panic ;)
switch kind { switch kind {
case reflect.Slice, reflect.Array: case reflect.Slice, reflect.Array:
v.traverseSlice(topStruct, currentStruct, current, errPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) v.traverseSlice(topStruct, currentStruct, current, errPrefix, nsPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil)
case reflect.Map: case reflect.Map:
v.traverseMap(topStruct, currentStruct, current, errPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) v.traverseMap(topStruct, currentStruct, current, errPrefix, nsPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil)
default: default:
// throw error, if not a slice or map then should not have gotten here // throw error, if not a slice or map then should not have gotten here
// bad dive tag // bad dive tag
@ -659,23 +699,23 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
} }
// traverseSlice traverses a Slice or Array's elements and passes them to traverseField for validation // traverseSlice traverses a Slice or Array's elements and passes them to traverseField for validation
func (v *Validate) traverseSlice(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { func (v *Validate) traverseSlice(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) {
for i := 0; i < current.Len(); i++ { for i := 0; i < current.Len(); i++ {
v.traverseField(topStruct, currentStruct, current.Index(i), errPrefix, errs, false, tag, fmt.Sprintf(arrayIndexFieldName, name, i), fmt.Sprintf(arrayIndexFieldName, customName, i), partial, exclude, includeExclude, cTag) v.traverseField(topStruct, currentStruct, current.Index(i), errPrefix, nsPrefix, errs, false, tag, fmt.Sprintf(arrayIndexFieldName, name, i), fmt.Sprintf(arrayIndexFieldName, customName, i), partial, exclude, includeExclude, cTag)
} }
} }
// traverseMap traverses a map's elements and passes them to traverseField for validation // traverseMap traverses a map's elements and passes them to traverseField for validation
func (v *Validate) traverseMap(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { func (v *Validate) traverseMap(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) {
for _, key := range current.MapKeys() { for _, key := range current.MapKeys() {
v.traverseField(topStruct, currentStruct, current.MapIndex(key), errPrefix, errs, false, tag, fmt.Sprintf(mapIndexFieldName, name, key.Interface()), fmt.Sprintf(mapIndexFieldName, customName, key.Interface()), partial, exclude, includeExclude, cTag) v.traverseField(topStruct, currentStruct, current.MapIndex(key), errPrefix, nsPrefix, errs, false, tag, fmt.Sprintf(mapIndexFieldName, name, key.Interface()), fmt.Sprintf(mapIndexFieldName, customName, key.Interface()), partial, exclude, includeExclude, cTag)
} }
} }
// validateField validates a field based on the provided tag's key and param values and returns true if there is an error or false if all ok // validateField validates a field based on the provided tag's key and param values and returns true if there is an error or false if all ok
func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, currentType reflect.Type, currentKind reflect.Kind, errPrefix string, errs ValidationErrors, valTag *tagVals, name, customName string) bool { func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, currentType reflect.Type, currentKind reflect.Kind, errPrefix string, nsPrefix string, errs ValidationErrors, valTag *tagVals, name, customName string) bool {
var valFunc Func var valFunc Func
var ok bool var ok bool
@ -698,25 +738,31 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.
errTag += orSeparator + val[0] errTag += orSeparator + val[0]
} }
ns := errPrefix + name
if valTag.isAlias { if valTag.isAlias {
errs[errPrefix+name] = &FieldError{ errs[ns] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: name, NameNamespace: nsPrefix + customName,
Tag: valTag.tag, Name: customName,
ActualTag: errTag[1:], Field: name,
Value: current.Interface(), Tag: valTag.tag,
Type: currentType, ActualTag: errTag[1:],
Kind: currentKind, Value: current.Interface(),
Type: currentType,
Kind: currentKind,
} }
} else { } else {
errs[errPrefix+name] = &FieldError{ errs[errPrefix+name] = &FieldError{
Name: customName, FieldNamespace: ns,
Field: name, NameNamespace: nsPrefix + customName,
Tag: errTag[1:], Name: customName,
ActualTag: errTag[1:], Field: name,
Value: current.Interface(), Tag: errTag[1:],
Type: currentType, ActualTag: errTag[1:],
Kind: currentKind, Value: current.Interface(),
Type: currentType,
Kind: currentKind,
} }
} }
@ -732,15 +778,19 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.
return false return false
} }
errs[errPrefix+name] = &FieldError{ ns := errPrefix + name
Name: customName,
Field: name, errs[ns] = &FieldError{
Tag: valTag.tag, FieldNamespace: ns,
ActualTag: valTag.tagVals[0][0], NameNamespace: nsPrefix + customName,
Value: current.Interface(), Name: customName,
Param: valTag.tagVals[0][1], Field: name,
Type: currentType, Tag: valTag.tag,
Kind: currentKind, ActualTag: valTag.tagVals[0][0],
Value: current.Interface(),
Param: valTag.tagVals[0][1],
Type: currentType,
Kind: currentKind,
} }
return true return true

@ -284,8 +284,20 @@ func StructValidationTestStructReturnValidationErrors(v *Validate, structLevel *
structLevel.ReportValidationErrors("Inner1.", errs.(ValidationErrors)) structLevel.ReportValidationErrors("Inner1.", errs.(ValidationErrors))
} }
func StructValidationTestStructReturnValidationErrors2(v *Validate, structLevel *StructLevel) {
s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors)
errs := v.Struct(s.Inner1.Inner2)
if errs == nil {
return
}
structLevel.ReportValidationErrors("Inner1.|Inner1JSON.", errs.(ValidationErrors))
}
type TestStructReturnValidationErrorsInner2 struct { type TestStructReturnValidationErrorsInner2 struct {
String string `validate:"required"` String string `validate:"required" json:"JSONString"`
} }
type TestStructReturnValidationErrorsInner1 struct { type TestStructReturnValidationErrorsInner1 struct {
@ -293,7 +305,52 @@ type TestStructReturnValidationErrorsInner1 struct {
} }
type TestStructReturnValidationErrors struct { type TestStructReturnValidationErrors struct {
Inner1 *TestStructReturnValidationErrorsInner1 Inner1 *TestStructReturnValidationErrorsInner1 `json:"Inner1JSON"`
}
type Inner2Namespace struct {
String []string `validate:"dive,required" json:"JSONString"`
}
type Inner1Namespace struct {
Inner2 *Inner2Namespace `json:"Inner2JSON"`
}
type Namespace struct {
Inner1 *Inner1Namespace `json:"Inner1JSON"`
}
func TestNameNamespace(t *testing.T) {
config := &Config{
TagName: "validate",
FieldNameTag: "json",
}
v1 := New(config)
i2 := &Inner2Namespace{String: []string{"ok", "ok", "ok"}}
i1 := &Inner1Namespace{Inner2: i2}
ns := &Namespace{Inner1: i1}
errs := v1.Struct(ns)
Equal(t, errs, nil)
i2.String[1] = ""
errs = v1.Struct(ns)
NotEqual(t, errs, nil)
ve := errs.(ValidationErrors)
Equal(t, len(ve), 1)
AssertError(t, errs, "Namespace.Inner1.Inner2.String[1]", "String[1]", "required")
fe, ok := ve["Namespace.Inner1.Inner2.String[1]"]
Equal(t, ok, true)
Equal(t, fe.Field, "String[1]")
Equal(t, fe.FieldNamespace, "Namespace.Inner1.Inner2.String[1]")
Equal(t, fe.Name, "JSONString[1]")
Equal(t, fe.NameNamespace, "Namespace.Inner1JSON.Inner2JSON.JSONString[1]")
} }
func TestAnonymous(t *testing.T) { func TestAnonymous(t *testing.T) {
@ -377,7 +434,62 @@ func TestStructLevelReturnValidationErrors(t *testing.T) {
errs = v1.Struct(val) errs = v1.Struct(val)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required") AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
// this is an extra error reported from struct validation
AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
}
func TestStructLevelReturnValidationErrorsWithJSON(t *testing.T) {
config := &Config{
TagName: "validate",
FieldNameTag: "json",
}
v1 := New(config)
v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors2, TestStructReturnValidationErrors{})
inner2 := &TestStructReturnValidationErrorsInner2{
String: "I'm HERE",
}
inner1 := &TestStructReturnValidationErrorsInner1{
Inner2: inner2,
}
val := &TestStructReturnValidationErrors{
Inner1: inner1,
}
errs := v1.Struct(val)
Equal(t, errs, nil)
inner2.String = ""
errs = v1.Struct(val)
NotEqual(t, errs, nil)
Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
// this is an extra error reported from struct validation, it's a badly formatted one, but on purpose
AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
fe, ok := errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.Inner2.String"]
Equal(t, ok, true)
// check for proper JSON namespace
Equal(t, fe.Field, "String")
Equal(t, fe.Name, "JSONString")
Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.Inner2.String")
Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.Inner2.JSONString")
fe, ok = errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.String"]
Equal(t, ok, true)
// check for proper JSON namespace
Equal(t, fe.Field, "String")
Equal(t, fe.Name, "JSONString")
Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.String")
Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.JSONString")
} }
func TestStructLevelValidations(t *testing.T) { func TestStructLevelValidations(t *testing.T) {

Loading…
Cancel
Save