Struct Validator 

pub struct Validator(/* private fields */);

Validator handle returned by the helpers in this module. Composes with Validator::and / Validator::or / Validator::msg.

Implementations

impl Validator

pub fn new<V: Validate>(v: V) -> Self

Wrap any Validate implementation — including a plain closure |s: &str| -> Result<(), String> — into a Validator.

Examples found in repository

examples/prompt_validate.rs (lines 17-25)

fn main() {
    let _ = colors(); // silence unused-import warning if you remove theming below

    intro("Validation playground");

    let abort = "Aborted — nothing was saved.";

    // 12-word seed phrase, composed from primitives.
    let lowercase_words = Validator::new(|v: &str| {
        if v.split_whitespace()
            .all(|w| w.chars().all(|c| c.is_ascii_lowercase()))
        {
            Ok(())
        } else {
            Err("Words must be lowercase ASCII".into())
        }
    });
    let _seed = text("Recovery phrase")
        .rule(word_count(12).and(lowercase_words))
        .run()
        .or_cancel(abort);

    let _pw = secret("Set a password")
        .rule(
            min_chars(12)
                .and(has_upper())
                .and(has_lower())
                .and(has_digit())
                .and(has_special())
                .msg("≥12 chars with upper, lower, digit, and a special char"),
        )
        .run()
        .or_cancel(abort);

    let _mail = text("Email")
        .placeholder("you@example.com")
        .rule(email())
        .run()
        .or_cancel(abort);

    let _port = text("Listen port")
        .default("8080")
        .rule(int_between(1024, 65535))
        .run()
        .or_cancel(abort);

    let _user = text("Username")
        .rule(
            min_chars(3)
                .and(max_chars(20))
                .and(alphanumeric())
                .msg("3–20 alphanumeric characters"),
        )
        .run()
        .or_cancel(abort);

    let _name = text("Display name")
        .validate(|s: &str| {
            if s.contains(char::is_whitespace) {
                Err("No spaces allowed".into())
            } else {
                Ok(())
            }
        })
        .run()
        .or_cancel(abort);

    outro("All validators passed!");
}

pub fn check(&self, v: &str) -> Result<(), String>

Run the validator. Mirrors Validate::check.

pub fn and(self, other: Validator) -> Validator

Both must pass. Returns the first error encountered.

Examples found in repository

examples/prompt_validate.rs (line 27)

fn main() {
    let _ = colors(); // silence unused-import warning if you remove theming below

    intro("Validation playground");

    let abort = "Aborted — nothing was saved.";

    // 12-word seed phrase, composed from primitives.
    let lowercase_words = Validator::new(|v: &str| {
        if v.split_whitespace()
            .all(|w| w.chars().all(|c| c.is_ascii_lowercase()))
        {
            Ok(())
        } else {
            Err("Words must be lowercase ASCII".into())
        }
    });
    let _seed = text("Recovery phrase")
        .rule(word_count(12).and(lowercase_words))
        .run()
        .or_cancel(abort);

    let _pw = secret("Set a password")
        .rule(
            min_chars(12)
                .and(has_upper())
                .and(has_lower())
                .and(has_digit())
                .and(has_special())
                .msg("≥12 chars with upper, lower, digit, and a special char"),
        )
        .run()
        .or_cancel(abort);

    let _mail = text("Email")
        .placeholder("you@example.com")
        .rule(email())
        .run()
        .or_cancel(abort);

    let _port = text("Listen port")
        .default("8080")
        .rule(int_between(1024, 65535))
        .run()
        .or_cancel(abort);

    let _user = text("Username")
        .rule(
            min_chars(3)
                .and(max_chars(20))
                .and(alphanumeric())
                .msg("3–20 alphanumeric characters"),
        )
        .run()
        .or_cancel(abort);

    let _name = text("Display name")
        .validate(|s: &str| {
            if s.contains(char::is_whitespace) {
                Err("No spaces allowed".into())
            } else {
                Ok(())
            }
        })
        .run()
        .or_cancel(abort);

    outro("All validators passed!");
}

pub fn or(self, other: Validator) -> Validator

At least one must pass. Returns the second error if both fail (usually more user-friendly than “you failed multiple things”).

pub fn msg(self, message: impl Into<String>) -> Validator

Replace the error message produced by this validator.

Examples found in repository

examples/prompt_validate.rs (line 38)

fn main() {
    let _ = colors(); // silence unused-import warning if you remove theming below

    intro("Validation playground");

    let abort = "Aborted — nothing was saved.";

    // 12-word seed phrase, composed from primitives.
    let lowercase_words = Validator::new(|v: &str| {
        if v.split_whitespace()
            .all(|w| w.chars().all(|c| c.is_ascii_lowercase()))
        {
            Ok(())
        } else {
            Err("Words must be lowercase ASCII".into())
        }
    });
    let _seed = text("Recovery phrase")
        .rule(word_count(12).and(lowercase_words))
        .run()
        .or_cancel(abort);

    let _pw = secret("Set a password")
        .rule(
            min_chars(12)
                .and(has_upper())
                .and(has_lower())
                .and(has_digit())
                .and(has_special())
                .msg("≥12 chars with upper, lower, digit, and a special char"),
        )
        .run()
        .or_cancel(abort);

    let _mail = text("Email")
        .placeholder("you@example.com")
        .rule(email())
        .run()
        .or_cancel(abort);

    let _port = text("Listen port")
        .default("8080")
        .rule(int_between(1024, 65535))
        .run()
        .or_cancel(abort);

    let _user = text("Username")
        .rule(
            min_chars(3)
                .and(max_chars(20))
                .and(alphanumeric())
                .msg("3–20 alphanumeric characters"),
        )
        .run()
        .or_cancel(abort);

    let _name = text("Display name")
        .validate(|s: &str| {
            if s.contains(char::is_whitespace) {
                Err("No spaces allowed".into())
            } else {
                Ok(())
            }
        })
        .run()
        .or_cancel(abort);

    outro("All validators passed!");
}

Trait Implementations

impl Clone for Validator

fn clone(&self) -> Validator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> From<F> for Validator

where F: Fn(&str) -> Result<(), String> + Send + Sync + 'static,

fn from(f: F) -> Self

Converts to this type from the input type.

impl Validate for Validator

fn check(&self, v: &str) -> Result<(), String>

Return Ok(()) to accept the value, Err(msg) to reject and show msg as the user-facing error.