Struct Rule

Source

pub struct Rule<T: ?Sized> { /* private fields */ }

Expand description

A composable validation rule for values of type T.

Rules are the building blocks of domainstack’s validation system. They can be composed using and(), or(), not(), and when() to create complex validation logic.

Rules now receive a RuleContext providing field information for better error messages.

§Examples

§Basic Rule

use domainstack::prelude::*;

let rule = rules::min_len(3);
let ctx = RuleContext::root("username");
assert!(rule.apply_with_context("alice", &ctx).is_empty());
assert!(!rule.apply_with_context("ab", &ctx).is_empty());

§Composing Rules

use domainstack::prelude::*;

// Username must be 3-20 characters and alphanumeric
let rule = rules::min_len(3)
    .and(rules::max_len(20))
    .and(rules::alphanumeric());

let ctx = RuleContext::root("username");
assert!(rule.apply_with_context("alice123", &ctx).is_empty());
assert!(!rule.apply_with_context("ab", &ctx).is_empty());  // too short

§Custom Rules with Context

use domainstack::{Rule, RuleContext, ValidationError, Path};

fn lowercase_only() -> Rule<str> {
    Rule::new(|value: &str, ctx: &RuleContext| {
        if value.chars().all(|c| c.is_lowercase() || !c.is_alphabetic()) {
            ValidationError::default()
        } else {
            ValidationError::single(
                ctx.full_path(),
                "not_lowercase",
                "Must contain only lowercase letters"
            )
        }
    })
}

let rule = lowercase_only();
let ctx = RuleContext::root("username");
assert!(rule.apply_with_context("hello", &ctx).is_empty());
assert!(!rule.apply_with_context("Hello", &ctx).is_empty());

Implementations§

Source §

impl<T: ?Sized + 'static> Rule<T>

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&T, &RuleContext) -> ValidationError + Send + Sync + 'static,

Creates a new validation rule.

Rules receive both the value to validate and a RuleContext providing field information for better error messages.

Source

pub fn apply(&self, value: &T) -> ValidationError

Applies the rule with an anonymous context.

For better error messages, use apply_with_context() instead.

Source

pub fn apply_with_context( &self, value: &T, ctx: &RuleContext, ) -> ValidationError

Applies the rule with a specific context for field-aware error messages.

Source

pub fn code(self, code: &'static str) -> Rule<T>

Customize the error code for validation failures.

§Examples

use domainstack::prelude::*;

let rule = rules::min_len(5).code("email_too_short");
let err = rule.apply("hi");
assert_eq!(err.violations[0].code, "email_too_short");

Source

pub fn message( self, msg: impl Into<String> + Clone + Send + Sync + 'static, ) -> Rule<T>

Customize the error message for validation failures.

§Examples

use domainstack::prelude::*;

let rule = rules::min_len(5).message("Email too short");
let err = rule.apply("hi");
assert_eq!(err.violations[0].message, "Email too short");

Source

pub fn meta( self, key: &'static str, value: impl Into<String> + Clone + Send + Sync + 'static, ) -> Rule<T>

Add metadata to validation errors.

§Examples

use domainstack::prelude::*;

let rule = rules::min_len(5)
    .meta("hint", "Use at least 5 characters");

let err = rule.apply("hi");
assert_eq!(err.violations[0].meta.get("hint"), Some("Use at least 5 characters"));