Struct ValidatorRegistry 

pub struct ValidatorRegistry { /* private fields */ }

A deterministic local registry containing one definition per stable ID.

Examples

use qubit_validator::ValidatorRegistry;

let registry = ValidatorRegistry::empty();
assert!(registry.registrations().is_empty());
assert!(registry.get("example.unknown").is_none());

Implementations

impl ValidatorRegistry

pub fn from_registrations<I>( registrations: I, ) -> Result<Self, ValidatorRegistryError>

where I: IntoIterator, I::Item: Into<ValidatorRegistration>,

Builds a registry by taking ownership of registration values.

Type Parameters

• I - An iterable whose items can be converted into registrations.

Parameters

• registrations - Values to validate and store in the registry.

Errors

Returns every source which declared a duplicated stable ID, or the identifier and cause of the first invalid descriptor.

Returns

Returns a registry containing the validated registrations sorted by ID.

Examples found in repository

examples/local_registry.rs (line 156)

fn main() -> Result<(), Box<dyn Error>> {
    let registration = ValidatorRegistration::new(
        ValidatorId::new("text.non_blank"),
        &DESCRIPTOR,
        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
    );
    let registry = ValidatorRegistry::from_registrations([registration])?;

    assert!(registry.get("text.non_blank").is_some());
    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
    let context = BoundValidationContext::new(&[]);

    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
    assert_eq!(valid, ValidationOutcome::Valid);

    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
    let ValidationOutcome::Invalid(violations) = invalid else {
        panic!("blank text must be invalid");
    };
    assert_eq!(violations.len(), 1);
    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));

    assert_dependency_specs_come_from_signature()?;
    assert_parameters_are_consumed_once()?;

    #[cfg(feature = "inventory")]
    {
        let global = ValidatorRegistry::try_global()?;
        assert!(global.get("text.non_blank.global").is_some());
    }

    Ok(())
}

pub fn empty() -> Self

Returns an empty registry.

Returns

Returns a registry with no registrations.

pub fn try_global() -> Result<&'static Self, ValidatorRegistryError>

Initializes and returns the process-wide inventory registry.

Errors

Returns the cached error when linked registrations contain a duplicate ID or an invalid descriptor. This method is available only with the inventory feature.

Returns

Returns the process-wide registry when initialization succeeds.

Examples found in repository

examples/local_registry.rs (line 177)

fn main() -> Result<(), Box<dyn Error>> {
    let registration = ValidatorRegistration::new(
        ValidatorId::new("text.non_blank"),
        &DESCRIPTOR,
        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
    );
    let registry = ValidatorRegistry::from_registrations([registration])?;

    assert!(registry.get("text.non_blank").is_some());
    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
    let context = BoundValidationContext::new(&[]);

    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
    assert_eq!(valid, ValidationOutcome::Valid);

    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
    let ValidationOutcome::Invalid(violations) = invalid else {
        panic!("blank text must be invalid");
    };
    assert_eq!(violations.len(), 1);
    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));

    assert_dependency_specs_come_from_signature()?;
    assert_parameters_are_consumed_once()?;

    #[cfg(feature = "inventory")]
    {
        let global = ValidatorRegistry::try_global()?;
        assert!(global.get("text.non_blank.global").is_some());
    }

    Ok(())
}

pub fn global() -> &'static Self

Returns the process-wide inventory registry.

Panics

Panics when linked registrations contain duplicate IDs or an invalid descriptor. This method is available only with the inventory feature.

Returns

Returns the initialized process-wide registry.

pub fn get(&self, id: &str) -> Option<&ValidatorRegistration>

Finds a registration by stable ID.

Parameters

• id - Stable identifier to look up.

Returns

Returns Some for a registered ID and None when the ID is unknown.

Examples found in repository

examples/local_registry.rs (line 158)

fn main() -> Result<(), Box<dyn Error>> {
    let registration = ValidatorRegistration::new(
        ValidatorId::new("text.non_blank"),
        &DESCRIPTOR,
        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
    );
    let registry = ValidatorRegistry::from_registrations([registration])?;

    assert!(registry.get("text.non_blank").is_some());
    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
    let context = BoundValidationContext::new(&[]);

    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
    assert_eq!(valid, ValidationOutcome::Valid);

    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
    let ValidationOutcome::Invalid(violations) = invalid else {
        panic!("blank text must be invalid");
    };
    assert_eq!(violations.len(), 1);
    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));

    assert_dependency_specs_come_from_signature()?;
    assert_parameters_are_consumed_once()?;

    #[cfg(feature = "inventory")]
    {
        let global = ValidatorRegistry::try_global()?;
        assert!(global.get("text.non_blank.global").is_some());
    }

    Ok(())
}

pub fn registrations(&self) -> &[ValidatorRegistration]

Returns registrations sorted by stable ID.

Returns

Returns a borrowed slice of all registrations in stable-ID order.

pub fn bind( &self, id: &str, input: InputType, params: &[NamedValidationArgument<'_>], ) -> Result<BoundValidator, BindError>

Binds a rule by ID and input shape.

Parameters

• id - Stable identifier of the registered rule to bind.
• input - Input shape that the bound rule must accept.
• params - Named arguments supplied to the rule.

Errors

Returns MissingRule when id has no registration. This error has no resolved rule ID; callers that need the requested text retain id. Signature and preparation errors for a found rule carry its ID.

Returns

Returns the bound validator when the registration exists and accepts the supplied input and parameters.

Examples found in repository

examples/local_registry.rs (line 159)

fn main() -> Result<(), Box<dyn Error>> {
    let registration = ValidatorRegistration::new(
        ValidatorId::new("text.non_blank"),
        &DESCRIPTOR,
        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
    );
    let registry = ValidatorRegistry::from_registrations([registration])?;

    assert!(registry.get("text.non_blank").is_some());
    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
    let context = BoundValidationContext::new(&[]);

    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
    assert_eq!(valid, ValidationOutcome::Valid);

    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
    let ValidationOutcome::Invalid(violations) = invalid else {
        panic!("blank text must be invalid");
    };
    assert_eq!(violations.len(), 1);
    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));

    assert_dependency_specs_come_from_signature()?;
    assert_parameters_are_consumed_once()?;

    #[cfg(feature = "inventory")]
    {
        let global = ValidatorRegistry::try_global()?;
        assert!(global.get("text.non_blank.global").is_some());
    }

    Ok(())
}

Trait Implementations

impl Debug for ValidatorRegistry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.