Browse Source

Add ValidateValuer

master v0.2.0
Nise Void 4 months ago
parent
commit
84ee3011ac
Signed by: NiseVoid GPG Key ID: FBA14AC83EA602F3
2 changed files with 101 additions and 41 deletions
  1. +54
    -27
      validate.go
  2. +47
    -14
      validate_test.go

+ 54
- 27
validate.go View File

@ -7,6 +7,12 @@ import (
"sync"
)
type ValidateValuer interface {
ValidateValue() interface{}
}
var vvType = reflect.TypeOf((*ValidateValuer)(nil)).Elem()
// Validate validates a variable
func Validate(v interface{}) []ValidationError {
rv := reflect.ValueOf(v)
@ -160,7 +166,14 @@ func getRules(rt reflect.Type) []rule {
for i := 0; i < rt.NumField(); i++ {
ft := rt.Field(i)
kind := ft.Type.Kind()
var valuer bool
if ft.Type.Implements(vvType) {
ft.Type = reflect.TypeOf(reflect.New(ft.Type).Interface().(ValidateValuer).ValidateValue())
valuer = true
}
kind := simplifyKind(ft.Type.Kind())
var ptr bool
if kind == reflect.Ptr {
kind = ft.Type.Elem().Kind()
@ -169,9 +182,7 @@ func getRules(rt reflect.Type) []rule {
kind = simplifyKind(kind)
tags := strings.Split(ft.Tag.Get(`validate`), `,`)
rules = append(rules, getTagFuncs(i, ft, kind, tags, ptr)...)
// TODO: Add validator interface
rules = append(rules, getTagFuncs(i, ft, kind, tags, ptr, valuer)...)
switch kind {
case reflect.Slice, reflect.Struct, reflect.Interface:
@ -192,7 +203,7 @@ func nest(ft reflect.StructField) func(reflect.Value) ([]ValidationError, bool)
}
}
func getTagFuncs(i int, ft reflect.StructField, kind reflect.Kind, tags []string, ptr bool) []rule {
func getTagFuncs(i int, ft reflect.StructField, kind reflect.Kind, tags []string, ptr, valuer bool) []rule {
var rules []rule
for _, v := range tags {
if v == `` {
@ -212,46 +223,62 @@ func getTagFuncs(i int, ft reflect.StructField, kind reflect.Kind, tags []string
ptr = false
}
var f validateCheck
if tag == `optional` {
rules = append(rules, rule{i, func(rv reflect.Value) ([]ValidationError, bool) {
f = func(rv reflect.Value) ([]ValidationError, bool) {
check, _ := getTagFunc(`required`, ``, kind)
return nil, check(rv, nil)
}})
continue
}
var not bool
if strings.HasPrefix(tag, `!`) {
not = true
}
check, val := getTagFunc(strings.TrimPrefix(tag, `!`), value, kind)
f := func(rv reflect.Value) ([]ValidationError, bool) {
if check(rv, val) == !not {
return nil, true
}
} else {
var not bool
if strings.HasPrefix(tag, `!`) {
not = true
}
return []ValidationError{{Field: []Field{{nil, &ft}}, Check: tag, Value: value}}, false
}
check, val := getTagFunc(strings.TrimPrefix(tag, `!`), value, kind)
if ptr {
oldF := f
f = func(rv reflect.Value) ([]ValidationError, bool) {
if rv.IsNil() {
return []ValidationError{{Field: []Field{{nil, &ft}}, Check: tag, Value: value}}, false
if check(rv, val) == !not {
return nil, true
}
return oldF(rv.Elem())
return []ValidationError{{Field: []Field{{nil, &ft}}, Check: tag, Value: value}}, false
}
}
if ptr {
f = depointerFunc(f, ft, tag, value)
}
if valuer {
f = valuerFunc(f)
}
rules = append(rules, rule{i, f})
}
return rules
}
type validateCheck = func(rv reflect.Value) ([]ValidationError, bool)
func depointerFunc(f validateCheck, ft reflect.StructField, tag, value string) validateCheck {
return func(rv reflect.Value) ([]ValidationError, bool) {
if rv.IsNil() {
return []ValidationError{{Field: []Field{{nil, &ft}}, Check: tag, Value: value}}, false
}
return f(rv.Elem())
}
}
func valuerFunc(f validateCheck) validateCheck {
return func(rv reflect.Value) ([]ValidationError, bool) {
rv = reflect.ValueOf(rv.Interface().(ValidateValuer).ValidateValue())
return f(rv)
}
}
func getTagFunc(tag, value string, kind reflect.Kind) (ValidationFunc, interface{}) {
tagInfo, ok := funcs[tag]
if !ok {


+ 47
- 14
validate_test.go View File

@ -10,10 +10,10 @@ func TestOptionalMultiple(t *testing.T) {
B int `validate:"gt=3,lt=20"`
}
var pass1 = s{``, 4}
var pass2 = s{`a`, 19}
pass1 := s{``, 4}
pass2 := s{`a`, 19}
var fail = s{`b`, 3}
fail := s{`b`, 3}
check(t, pass1, 0)
check(t, pass2, 0)
@ -34,11 +34,11 @@ func TestNesting(t *testing.T) {
B sb
}
var pass = s{[]sa{{`abc`}}, sb{12}}
pass := s{[]sa{{`abc`}}, sb{12}}
var fail1 = s{nil, sb{12}}
var fail2 = s{[]sa{{``}}, sb{12}}
var fail3 = s{[]sa{{``}}, sb{9}}
fail1 := s{nil, sb{12}}
fail2 := s{[]sa{{``}}, sb{12}}
fail3 := s{[]sa{{``}}, sb{9}}
check(t, pass, 0)
check(t, fail1, 1)
@ -83,10 +83,10 @@ func TestNot(t *testing.T) {
B int `validate:"!eq=3"`
}
var pass1 = s{`ab`, 2}
var pass2 = s{`abcd`, 4}
pass1 := s{`ab`, 2}
pass2 := s{`abcd`, 4}
var fail = s{`abc`, 3}
fail := s{`abc`, 3}
check(t, pass1, 0)
check(t, pass2, 0)
@ -107,14 +107,47 @@ func TestPtr(t *testing.T) {
two := 2
three := 3
var pass1 = s{&three, &three}
var pass2 = s{&three, nil}
pass1 := s{&three, &three}
pass2 := s{&three, nil}
var fail1 = s{&two, &two}
var fail2 = s{nil, nil}
fail1 := s{&two, &two}
fail2 := s{nil, nil}
check(t, pass1, 0)
check(t, pass2, 0)
check(t, fail1, 2)
check(t, fail2, 1)
}
type val struct {
Int int
Valid bool
}
func (v val) ValidateValue() interface{} {
if !v.Valid {
return (*int)(nil)
}
return &v.Int
}
func TestValidateValuer(t *testing.T) {
type s struct {
A val `validate:"required,lt=2"`
B val `validate:"optional,eq=3"`
}
pass1 := s{val{Valid: true}, val{}}
pass2 := s{val{Valid: true}, val{Int: 3, Valid: true}}
fail1 := s{}
fail2 := s{val{Int: 2, Valid: true}, val{}}
fail3 := s{val{Valid: true}, val{Int: 2, Valid: true}}
check(t, pass1, 0)
check(t, pass2, 0)
check(t, fail1, 1)
check(t, fail2, 1)
check(t, fail3, 1)
}

Loading…
Cancel
Save