Crate vale

Vale stands for Valid Entity, and is a simple library that provides entity validation through either annotations, or through a Fluent-style implementation. At the core of the library is the vale::Validate trait, which implies that a piece of data can be validated. The library also offers supoort for the rocket webframework. If support for more webframeworks is desired, it should be fairly trivial to implement support for those frameworks.

Example

This example shows how to derive the validation trait

use vale::Validate;

#[derive(Validate)]
struct Entity {
    #[validate(gt(0))]
    id: i32,
    #[validate(len_lt(5), with(add_element))]
    others: Vec<i32>,
    #[validate(eq("hello world"))]
    msg: String,
}

fn add_element(v: &mut Vec<i32>) -> bool {
    v.push(3);
    true
}

fn main() {
    let mut e = get_entity();
    if let Err(errs) = e.validate() {
        println!("The following validations failed: {:?}", errs);
    }
}

It is also possible to use fluent-style validation:

struct Entity {
    id: i32,
    others: Vec<i32>,
    msg: String,
}

impl vale::Validate for Entity {
    #[vale::ruleset]
    fn validate(&mut self) -> vale::Result {
        vale::rule!(self.id > 0, "`id` is nonpositive!");
        vale::rule!(self.others.len() < 5, "Too many others");
    }
}

Macros

• rule
  The rule macro is used to create new rules that dictate how a field of the validated entity should be tranformed and validated.

Structs

• Valid
  A struct that can be used in Rocket routes. If you have some type that implements Validate, you can designate in your controller that you want to have a validated instance of that type.

Traits

• Validate
  The core trait of this library. Any entity that implements Validate can be validated by running the validate function. This will either return an Ok(()), or an Err containing a list of errors that were triggered during validation. It is also possible for validate to perform tranformations on the entity that is being validated.

Type Aliases

• Result
  A type alias for the Result returned by the Validate::validate function.

Attribute Macros

• ruleset
  Use this macro to annotate yout implementation of vale::Validate for your struct to help write the error reporting boilerplate for you. See the documentation of vale::rule for usage examples.

Derive Macros

• Validate
  A proc macro used to implement Validate automatically for a struct.