Initial QSfera import
This commit is contained in:
Курнат Андрей
+280
@@ -0,0 +1,280 @@
|
||||
// Copyright 2016 Qiang Xue. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package validation provides configurable and extensible rules for validating data of various types.
|
||||
package validation
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type (
|
||||
// Validatable is the interface indicating the type implementing it supports data validation.
|
||||
Validatable interface {
|
||||
// Validate validates the data and returns an error if validation fails.
|
||||
Validate() error
|
||||
}
|
||||
|
||||
// ValidatableWithContext is the interface indicating the type implementing it supports context-aware data validation.
|
||||
ValidatableWithContext interface {
|
||||
// ValidateWithContext validates the data with the given context and returns an error if validation fails.
|
||||
ValidateWithContext(ctx context.Context) error
|
||||
}
|
||||
|
||||
// Rule represents a validation rule.
|
||||
Rule interface {
|
||||
// Validate validates a value and returns a value if validation fails.
|
||||
Validate(value interface{}) error
|
||||
}
|
||||
|
||||
// RuleWithContext represents a context-aware validation rule.
|
||||
RuleWithContext interface {
|
||||
// ValidateWithContext validates a value and returns a value if validation fails.
|
||||
ValidateWithContext(ctx context.Context, value interface{}) error
|
||||
}
|
||||
|
||||
// RuleFunc represents a validator function.
|
||||
// You may wrap it as a Rule by calling By().
|
||||
RuleFunc func(value interface{}) error
|
||||
|
||||
// RuleWithContextFunc represents a validator function that is context-aware.
|
||||
// You may wrap it as a Rule by calling WithContext().
|
||||
RuleWithContextFunc func(ctx context.Context, value interface{}) error
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrorTag is the struct tag name used to customize the error field name for a struct field.
|
||||
ErrorTag = "json"
|
||||
|
||||
// Skip is a special validation rule that indicates all rules following it should be skipped.
|
||||
Skip = skipRule{skip: true}
|
||||
|
||||
validatableType = reflect.TypeOf((*Validatable)(nil)).Elem()
|
||||
validatableWithContextType = reflect.TypeOf((*ValidatableWithContext)(nil)).Elem()
|
||||
)
|
||||
|
||||
// Validate validates the given value and returns the validation error, if any.
|
||||
//
|
||||
// Validate performs validation using the following steps:
|
||||
// 1. For each rule, call its `Validate()` to validate the value. Return if any error is found.
|
||||
// 2. If the value being validated implements `Validatable`, call the value's `Validate()`.
|
||||
// Return with the validation result.
|
||||
// 3. If the value being validated is a map/slice/array, and the element type implements `Validatable`,
|
||||
// for each element call the element value's `Validate()`. Return with the validation result.
|
||||
func Validate(value interface{}, rules ...Rule) error {
|
||||
for _, rule := range rules {
|
||||
if s, ok := rule.(skipRule); ok && s.skip {
|
||||
return nil
|
||||
}
|
||||
if err := rule.Validate(value); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
rv := reflect.ValueOf(value)
|
||||
if (rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface) && rv.IsNil() {
|
||||
return nil
|
||||
}
|
||||
|
||||
if v, ok := value.(Validatable); ok {
|
||||
return v.Validate()
|
||||
}
|
||||
|
||||
switch rv.Kind() {
|
||||
case reflect.Map:
|
||||
if rv.Type().Elem().Implements(validatableType) {
|
||||
return validateMap(rv)
|
||||
}
|
||||
case reflect.Slice, reflect.Array:
|
||||
if rv.Type().Elem().Implements(validatableType) {
|
||||
return validateSlice(rv)
|
||||
}
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
return Validate(rv.Elem().Interface())
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// ValidateWithContext validates the given value with the given context and returns the validation error, if any.
|
||||
//
|
||||
// ValidateWithContext performs validation using the following steps:
|
||||
// 1. For each rule, call its `ValidateWithContext()` to validate the value if the rule implements `RuleWithContext`.
|
||||
// Otherwise call `Validate()` of the rule. Return if any error is found.
|
||||
// 2. If the value being validated implements `ValidatableWithContext`, call the value's `ValidateWithContext()`
|
||||
// and return with the validation result.
|
||||
// 3. If the value being validated implements `Validatable`, call the value's `Validate()`
|
||||
// and return with the validation result.
|
||||
// 4. If the value being validated is a map/slice/array, and the element type implements `ValidatableWithContext`,
|
||||
// for each element call the element value's `ValidateWithContext()`. Return with the validation result.
|
||||
// 5. If the value being validated is a map/slice/array, and the element type implements `Validatable`,
|
||||
// for each element call the element value's `Validate()`. Return with the validation result.
|
||||
func ValidateWithContext(ctx context.Context, value interface{}, rules ...Rule) error {
|
||||
for _, rule := range rules {
|
||||
if s, ok := rule.(skipRule); ok && s.skip {
|
||||
return nil
|
||||
}
|
||||
if rc, ok := rule.(RuleWithContext); ok {
|
||||
if err := rc.ValidateWithContext(ctx, value); err != nil {
|
||||
return err
|
||||
}
|
||||
} else if err := rule.Validate(value); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
rv := reflect.ValueOf(value)
|
||||
if (rv.Kind() == reflect.Ptr || rv.Kind() == reflect.Interface) && rv.IsNil() {
|
||||
return nil
|
||||
}
|
||||
|
||||
if v, ok := value.(ValidatableWithContext); ok {
|
||||
return v.ValidateWithContext(ctx)
|
||||
}
|
||||
|
||||
if v, ok := value.(Validatable); ok {
|
||||
return v.Validate()
|
||||
}
|
||||
|
||||
switch rv.Kind() {
|
||||
case reflect.Map:
|
||||
if rv.Type().Elem().Implements(validatableWithContextType) {
|
||||
return validateMapWithContext(ctx, rv)
|
||||
}
|
||||
if rv.Type().Elem().Implements(validatableType) {
|
||||
return validateMap(rv)
|
||||
}
|
||||
case reflect.Slice, reflect.Array:
|
||||
if rv.Type().Elem().Implements(validatableWithContextType) {
|
||||
return validateSliceWithContext(ctx, rv)
|
||||
}
|
||||
if rv.Type().Elem().Implements(validatableType) {
|
||||
return validateSlice(rv)
|
||||
}
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
return ValidateWithContext(ctx, rv.Elem().Interface())
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// validateMap validates a map of validatable elements
|
||||
func validateMap(rv reflect.Value) error {
|
||||
errs := Errors{}
|
||||
for _, key := range rv.MapKeys() {
|
||||
if mv := rv.MapIndex(key).Interface(); mv != nil {
|
||||
if err := mv.(Validatable).Validate(); err != nil {
|
||||
errs[fmt.Sprintf("%v", key.Interface())] = err
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(errs) > 0 {
|
||||
return errs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// validateMapWithContext validates a map of validatable elements with the given context.
|
||||
func validateMapWithContext(ctx context.Context, rv reflect.Value) error {
|
||||
errs := Errors{}
|
||||
for _, key := range rv.MapKeys() {
|
||||
if mv := rv.MapIndex(key).Interface(); mv != nil {
|
||||
if err := mv.(ValidatableWithContext).ValidateWithContext(ctx); err != nil {
|
||||
errs[fmt.Sprintf("%v", key.Interface())] = err
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(errs) > 0 {
|
||||
return errs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// validateSlice validates a slice/array of validatable elements
|
||||
func validateSlice(rv reflect.Value) error {
|
||||
errs := Errors{}
|
||||
l := rv.Len()
|
||||
for i := 0; i < l; i++ {
|
||||
v := rv.Index(i)
|
||||
if v.Kind() == reflect.Ptr && v.IsNil() {
|
||||
continue
|
||||
}
|
||||
if ev := v.Interface(); ev != nil {
|
||||
if err := ev.(Validatable).Validate(); err != nil {
|
||||
errs[strconv.Itoa(i)] = err
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(errs) > 0 {
|
||||
return errs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// validateSliceWithContext validates a slice/array of validatable elements with the given context.
|
||||
func validateSliceWithContext(ctx context.Context, rv reflect.Value) error {
|
||||
errs := Errors{}
|
||||
l := rv.Len()
|
||||
for i := 0; i < l; i++ {
|
||||
v := rv.Index(i)
|
||||
if v.Kind() == reflect.Ptr && v.IsNil() {
|
||||
continue
|
||||
}
|
||||
if ev := v.Interface(); ev != nil {
|
||||
if err := ev.(ValidatableWithContext).ValidateWithContext(ctx); err != nil {
|
||||
errs[strconv.Itoa(i)] = err
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(errs) > 0 {
|
||||
return errs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type skipRule struct {
|
||||
skip bool
|
||||
}
|
||||
|
||||
func (r skipRule) Validate(interface{}) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// When determines if all rules following it should be skipped.
|
||||
func (r skipRule) When(condition bool) skipRule {
|
||||
r.skip = condition
|
||||
return r
|
||||
}
|
||||
|
||||
type inlineRule struct {
|
||||
f RuleFunc
|
||||
fc RuleWithContextFunc
|
||||
}
|
||||
|
||||
func (r *inlineRule) Validate(value interface{}) error {
|
||||
if r.f == nil {
|
||||
return r.fc(context.Background(), value)
|
||||
}
|
||||
return r.f(value)
|
||||
}
|
||||
|
||||
func (r *inlineRule) ValidateWithContext(ctx context.Context, value interface{}) error {
|
||||
if r.fc == nil {
|
||||
return r.f(value)
|
||||
}
|
||||
return r.fc(ctx, value)
|
||||
}
|
||||
|
||||
// By wraps a RuleFunc into a Rule.
|
||||
func By(f RuleFunc) Rule {
|
||||
return &inlineRule{f: f}
|
||||
}
|
||||
|
||||
// WithContext wraps a RuleWithContextFunc into a context-aware Rule.
|
||||
func WithContext(f RuleWithContextFunc) Rule {
|
||||
return &inlineRule{fc: f}
|
||||
}
|
||||
Reference in New Issue
Block a user