Struct Validator 

pub struct Validator<'a> { /* private fields */ }

Request validator.

Example

use ferro_rs::validation::{Validator, rules::*};

let data = serde_json::json!({
    "email": "user@example.com",
    "password": "secret123",
    "password_confirmation": "secret123"
});

let result = Validator::new(&data)
    .rules("email", vec![required(), email()])
    .rules("password", vec![required(), min(8), confirmed()])
    .validate();

match result {
    Ok(()) => println!("Validation passed!"),
    Err(errors) => println!("Errors: {:?}", errors),
}

Implementations

impl<'a> Validator<'a>

pub fn new(data: &'a Value) -> Self

Create a new validator for the given data.

pub fn with_error( self, field: impl Into<String>, message: impl Into<String>, ) -> Self

Pre-seed a validation error for a field without adding a rule.

Useful for cross-field checks (e.g. password confirmation) performed before calling validate(). The error appears in the final result alongside any rule-based errors.

Example

let mut validator = Validator::new(&data)
    .rules("password", rules![required(), min(8)]);

if form.password != form.password_confirmation {
    validator = validator.with_error("password_confirmation", "Passwords do not match.");
}

validator.validate()?;

pub fn rule<R: Rule + 'static>(self, field: impl Into<String>, rule: R) -> Self

Add a single validation rule for a field.

pub fn rules(self, field: impl Into<String>, rules: Vec<Box<dyn Rule>>) -> Self

Add multiple validation rules for a field using boxed rules.

Example

use ferro_rs::validation::{Validator, rules::*};
use ferro_rs::rules;

Validator::new(&data)
    .rules("email", rules![required(), email()])
    .rules("name", rules![required(), string(), max(255)]);

pub fn boxed_rules( self, field: impl Into<String>, rules: Vec<Box<dyn Rule>>, ) -> Self

Add boxed rules for a field (useful for dynamic rule creation).

pub fn message(self, key: impl Into<String>, message: impl Into<String>) -> Self

Set a custom error message for a field.rule combination.

Example

Validator::new(&data)
    .rules("email", vec![required(), email()])
    .message("email.required", "Please provide your email address")
    .message("email.email", "That doesn't look like a valid email");

pub fn messages(self, messages: HashMap<String, String>) -> Self

Set custom messages from a map.

pub fn attribute( self, field: impl Into<String>, name: impl Into<String>, ) -> Self

Set a custom attribute name for a field.

Example

Validator::new(&data)
    .rules("email", vec![required()])
    .attribute("email", "email address");
// Error: "The email address field is required."

pub fn attributes(self, attributes: HashMap<String, String>) -> Self

Set custom attributes from a map.

pub fn stop_on_first_failure(self) -> Self

Stop validating remaining fields after first failure.

pub fn validate_or_redirect( self, url: impl Into<String>, ) -> Result<(), ActionError>

Validate and, on failure, flash per-field errors + old input and return an crate::http::action::ActionError redirecting to url.

Composes the existing with_old_input + into_action_error chain so per-field errors and old input flash exactly as the modern form-error idiom does today. The validator already holds the data passed to Validator::new, so it is reused here without requiring the caller to pass it again.

Validator::new(&data)
    .rules("name", rules![required()])
    .validate_or_redirect(&form_url)?;

pub fn validate(self) -> Result<(), ValidationError>

Run validation and return errors if any.

pub fn passes(&self) -> bool

Check if validation passes.

pub fn fails(&self) -> bool

Check if validation fails.