niki/vendor/github.com/go-ozzo/ozzo-validation/v4/map.go

package validation

import (
	"context"
	"errors"
	"fmt"
	"reflect"
)

var (

	// ErrNotMap is the error that the value being validated is not a map.

	ErrNotMap = errors.New("only a map can be validated")

	// ErrKeyWrongType is the error returned in case of an incorrect key type.

	ErrKeyWrongType = NewError("validation_key_wrong_type", "key not the correct type")

	// ErrKeyMissing is the error returned in case of a missing key.

	ErrKeyMissing = NewError("validation_key_missing", "required key is missing")

	// ErrKeyUnexpected is the error returned in case of an unexpected key.

	ErrKeyUnexpected = NewError("validation_key_unexpected", "key not expected")
)

type (

	// MapRule represents a rule set associated with a map.

	MapRule struct {
		keys []*KeyRules

		allowExtraKeys bool
	}

	// KeyRules represents a rule set associated with a map key.

	KeyRules struct {
		key interface{}

		optional bool

		rules []Rule
	}
)

// Map returns a validation rule that checks the keys and values of a map.

// This rule should only be used for validating maps, or a validation error will be reported.

// Use Key() to specify map keys that need to be validated. Each Key() call specifies a single key which can

// be associated with multiple rules.

// For example,

//

//	validation.Map(

//	    validation.Key("Name", validation.Required),

//	    validation.Key("Value", validation.Required, validation.Length(5, 10)),

//	)

//

// A nil value is considered valid. Use the Required rule to make sure a map value is present.

func Map(keys ...*KeyRules) MapRule {

	return MapRule{keys: keys}

}

// AllowExtraKeys configures the rule to ignore extra keys.

func (r MapRule) AllowExtraKeys() MapRule {

	r.allowExtraKeys = true

	return r

}

// Validate checks if the given value is valid or not.

func (r MapRule) Validate(m interface{}) error {

	return r.ValidateWithContext(nil, m)

}

// ValidateWithContext checks if the given value is valid or not.

func (r MapRule) ValidateWithContext(ctx context.Context, m interface{}) error {

	value := reflect.ValueOf(m)

	if value.Kind() == reflect.Ptr {

		value = value.Elem()

	}

	if value.Kind() != reflect.Map {

		// must be a map

		return NewInternalError(ErrNotMap)

	}

	if value.IsNil() {

		// treat a nil map as valid

		return nil

	}

	errs := Errors{}

	kt := value.Type().Key()

	var extraKeys map[interface{}]bool

	if !r.allowExtraKeys {

		extraKeys = make(map[interface{}]bool, value.Len())

		for _, k := range value.MapKeys() {

			extraKeys[k.Interface()] = true

		}

	}

	for _, kr := range r.keys {

		var err error

		if kv := reflect.ValueOf(kr.key); !kt.AssignableTo(kv.Type()) {

			err = ErrKeyWrongType

		} else if vv := value.MapIndex(kv); !vv.IsValid() {

			if !kr.optional {

				err = ErrKeyMissing

			}

		} else if ctx == nil {

			err = Validate(vv.Interface(), kr.rules...)

		} else {

			err = ValidateWithContext(ctx, vv.Interface(), kr.rules...)

		}

		if err != nil {

			if ie, ok := err.(InternalError); ok && ie.InternalError() != nil {

				return err

			}

			errs[getErrorKeyName(kr.key)] = err

		}

		if !r.allowExtraKeys {

			delete(extraKeys, kr.key)

		}

	}

	if !r.allowExtraKeys {

		for key := range extraKeys {

			errs[getErrorKeyName(key)] = ErrKeyUnexpected

		}

	}

	if len(errs) > 0 {

		return errs

	}

	return nil

}

// Key specifies a map key and the corresponding validation rules.

func Key(key interface{}, rules ...Rule) *KeyRules {

	return &KeyRules{

		key: key,

		rules: rules,
	}

}

// Optional configures the rule to ignore the key if missing.

func (r *KeyRules) Optional() *KeyRules {

	r.optional = true

	return r

}

// getErrorKeyName returns the name that should be used to represent the validation error of a map key.

func getErrorKeyName(key interface{}) string {

	return fmt.Sprintf("%v", key)

}