Struct ValidationError

Source

pub struct ValidationError { /* private fields */ }

Expand description

One or more validation failures collected during validation.

ValidationError is designed for multi-field struct validation where all fields should be checked and all violations reported together. For single-value validation, a simpler error type may be more appropriate.

Requires the alloc feature (enabled by default via std), since it is backed by Vec<Violation>.

Implementations§

Source §

impl ValidationError

Source

pub fn new(message: &'static str) -> Self

Creates a ValidationError with a single unnamed violation.

Source

pub fn field(field: &'static str, message: &'static str) -> Self

Creates a ValidationError with a single named field violation.

Source

pub fn empty() -> Self

Creates an empty ValidationError. Useful for building up violations.

Always check is_empty before returning this as Err. Returning an empty ValidationError is valid Rust but conveys no information to the caller.

Examples found in repository ?

examples/basic.rs (line 20)

19    fn validate(&self) -> Result<(), Self::Error> {
20        let mut errors = ValidationError::empty();
21
22        if self.username.len() < 3 {
23            errors.push(Violation::with_field(
24                "username",
25                "must be at least 3 characters",
26            ));
27        }
28        if self.age < 18 {
29            errors.push(Violation::with_field("age", "must be 18 or older"));
30        }
31        if !self.email.contains('@') {
32            errors.push(Violation::with_field("email", "must contain '@'"));
33        }
34
35        if errors.is_empty() {
36            Ok(())
37        } else {
38            Err(errors)
39        }
40    }

Source

pub fn with(self, violation: Violation) -> Self

Adds a violation and returns self for chaining.

Source

pub fn push(&mut self, violation: Violation)

Adds a violation in place.

Examples found in repository ?

examples/basic.rs (lines 23-26)

19    fn validate(&self) -> Result<(), Self::Error> {
20        let mut errors = ValidationError::empty();
21
22        if self.username.len() < 3 {
23            errors.push(Violation::with_field(
24                "username",
25                "must be at least 3 characters",
26            ));
27        }
28        if self.age < 18 {
29            errors.push(Violation::with_field("age", "must be 18 or older"));
30        }
31        if !self.email.contains('@') {
32            errors.push(Violation::with_field("email", "must contain '@'"));
33        }
34
35        if errors.is_empty() {
36            Ok(())
37        } else {
38            Err(errors)
39        }
40    }

Source

pub fn merge(self, other: Self) -> Self

Merges another ValidationError into this one.

Source

pub fn require(self, condition: bool, violation: Violation) -> Self

Records violation only when condition is false, and returns self for chaining. A true condition means the rule held, so nothing is added.

Pair this with finish to express multi-field validation without the easy-to-forget final emptiness check:

use reliakit_validate::{ValidationError, Violation};

let result = ValidationError::empty()
    .require(!"".is_empty(), Violation::with_field("name", "must not be empty"))
    .require(15 >= 18, Violation::with_field("age", "must be at least 18"))
    .finish();

assert_eq!(result.unwrap_err().len(), 2);

Source

pub fn require_field( self, condition: bool, field: &'static str, message: &'static str, ) -> Self

Like require, building the Violation from a field name and message.

Source

pub fn finish(self) -> ValidateResult

Converts the accumulated violations into a result: Ok(()) when there are none, otherwise Err(self).

This removes the footgun of returning an empty ValidationError as an error (see empty).

Source

pub fn violations(&self) -> &[Violation]

Returns all violations.

Examples found in repository ?

examples/basic.rs (line 54)

43fn main() {
44    let bad = Signup {
45        username: "jo".into(),
46        age: 15,
47        email: "nope".into(),
48    };
49
50    match bad.validate() {
51        Ok(()) => println!("valid"),
52        Err(errors) => {
53            println!("{} problem(s):", errors.len());
54            for v in errors.violations() {
55                println!("  - {}: {}", v.field.unwrap_or("(form)"), v.message);
56            }
57        }
58    }
59
60    let good = Signup {
61        username: "jordan".into(),
62        age: 30,
63        email: "jordan@example.com".into(),
64    };
65    println!("good signup valid: {}", good.validate().is_ok());
66}

Source

pub fn is_empty(&self) -> bool

Returns true if there are no violations.

Examples found in repository ?

examples/basic.rs (line 35)

19    fn validate(&self) -> Result<(), Self::Error> {
20        let mut errors = ValidationError::empty();
21
22        if self.username.len() < 3 {
23            errors.push(Violation::with_field(
24                "username",
25                "must be at least 3 characters",
26            ));
27        }
28        if self.age < 18 {
29            errors.push(Violation::with_field("age", "must be 18 or older"));
30        }
31        if !self.email.contains('@') {
32            errors.push(Violation::with_field("email", "must contain '@'"));
33        }
34
35        if errors.is_empty() {
36            Ok(())
37        } else {
38            Err(errors)
39        }
40    }

Source

pub fn len(&self) -> usize

Returns the number of violations.

Examples found in repository ?

examples/basic.rs (line 53)

43fn main() {
44    let bad = Signup {
45        username: "jo".into(),
46        age: 15,
47        email: "nope".into(),
48    };
49
50    match bad.validate() {
51        Ok(()) => println!("valid"),
52        Err(errors) => {
53            println!("{} problem(s):", errors.len());
54            for v in errors.violations() {
55                println!("  - {}: {}", v.field.unwrap_or("(form)"), v.message);
56            }
57        }
58    }
59
60    let good = Signup {
61        username: "jordan".into(),
62        age: 30,
63        email: "jordan@example.com".into(),
64    };
65    println!("good signup valid: {}", good.validate().is_ok());
66}