Struct Validator

pub struct Validator<Value, Key> {
    pub validations: Vec<ValidatorFn<Value, Key>>,
}

Validates a particular type of value, can contain many validation functions. Generally used with a single key for all contained validation functions.

Example

use form_validation::{Validation, ValidationError, Validator};

let v: Validator<i32, String> = Validator::new()
.validation(|value: &i32, key: &String| {
    if value < &0 {
        let value_clone = *value;
        Err(ValidationError::new(key.clone(), "NOT_LESS_THAN_0")
            .with_message(move |key| {
                format!(
                    "The value of {} ({}) cannot be less than 0",
                    key, value_clone
                )
        }).into()) // convert into ValidationErrors
    } else {
        Ok(())
    }
})
.validation(|value: &i32, key: &String| {
    if value > &10 {
        let value_clone = *value;
        Err(ValidationError::new(key.clone(), "NOT_GREATER_THAN_10")
            .with_message(move |key| {
                format!(
                    "The value of {} ({}) cannot be greater than 10",
                    key, value_clone
                )
        }).into())
    } else {
        Ok(())
    }
});

let key = "field1".to_string();

{
    let errors = v.validate_value(&11, &key).unwrap_err();
    assert_eq!(1, errors.len());
    let error = errors.errors.get(0).unwrap();
    assert_eq!("NOT_GREATER_THAN_10", error.type_id);
}
assert!(v.validate_value(&5, &key).is_ok());

{
    let errors = v.validate_value(&-1, &key).unwrap_err();
    assert_eq!(1, errors.len());
    let error = errors.errors.get(0).unwrap();
    assert_eq!("NOT_LESS_THAN_0", error.type_id);
}

Fields

validations: Vec<ValidatorFn<Value, Key>>

Implementations

impl<Value, Key> Validator<Value, Key>

pub fn new() -> Self

Create a new Validator.

pub fn validation<F: Into<ValidatorFn<Value, Key>> + 'static>( self, validator_fn: F, ) -> Self

A factory method to add a validation function to this validator.

Trait Implementations

impl<Value: Clone, Key: Clone> Clone for Validator<Value, Key>

fn clone(&self) -> Validator<Value, Key>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Value: Debug, Key: Debug> Debug for Validator<Value, Key>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Value, Key> Default for Validator<Value, Key>

fn default() -> Self

Returns the “default value” for a type.

impl<Value, Key> From<Validator<Value, Key>> for AsyncValidator<Value, Key>

where Value: Clone + PartialEq + 'static, Key: Clone + PartialEq + 'static,

fn from(validator: Validator<Value, Key>) -> Self

Converts to this type from the input type.

impl<Value, Key> PartialEq for Validator<Value, Key>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Value, Key> Validation<Value, Key> for Validator<Value, Key>

where Key: PartialEq + Clone,

fn validate_value( &self, value: &Value, key: &Key, ) -> Result<(), ValidationErrors<Key>>

Validate a given form field referenced by a given Key, that contains a given Value, returns ValidationErrors if there are any.