Struct Violation

Source

pub struct Violation { /* private fields */ }

Expand description

One rule violation without the rejected value.

§Examples

use qubit_validator::{ValidatorId, Violation, ViolationCode};

let violation = Violation::new(
    ValidatorId::new("text.required"),
    ViolationCode::new("text.blank"),
);
assert_eq!(violation.code().as_str(), "text.blank");

Implementations§

Source §

impl Violation

Source

pub fn new(rule_id: ValidatorId, code: ViolationCode) -> Self

Creates a safe violation at the root path.

§Parameters

rule_id: Stable identifier of the rule that rejected the value.
code: Program-declared code describing the violation.

§Returns

A violation with an empty path and no parameters.

Source

pub const fn rule_id(&self) -> ValidatorId

Returns the stable rule identifier.

§Returns

The identifier assigned by the bound validator.

Source

pub const fn code(&self) -> ViolationCode

Returns the stable violation code.

§Returns

The program-declared code for this violation.

Examples found in repository ?

examples/local_registry.rs (line 170)

150fn main() -> Result<(), Box<dyn Error>> {
151    let registration = ValidatorRegistration::new(
152        ValidatorId::new("text.non_blank"),
153        &DESCRIPTOR,
154        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
155    );
156    let registry = ValidatorRegistry::from_registrations([registration])?;
157
158    assert!(registry.get("text.non_blank").is_some());
159    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
160    let context = BoundValidationContext::new(&[]);
161
162    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
163    assert_eq!(valid, ValidationOutcome::Valid);
164
165    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
166    let ValidationOutcome::Invalid(violations) = invalid else {
167        panic!("blank text must be invalid");
168    };
169    assert_eq!(violations.len(), 1);
170    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));
171
172    assert_dependency_specs_come_from_signature()?;
173    assert_parameters_are_consumed_once()?;
174
175    #[cfg(feature = "inventory")]
176    {
177        let global = ValidatorRegistry::try_global()?;
178        assert!(global.get("text.non_blank.global").is_some());
179    }
180
181    Ok(())
182}

Source

pub const fn path(&self) -> &ValidationPath

Returns the structured path.

The path contains no raw rejected value or map key.

§Returns

The structured path to the rejected value.

Source

pub const fn params(&self) -> &BTreeMap<&'static str, ViolationParam>

Returns structured parameters supplied by the caller.

The type restricts their representation but does not prove provenance; callers remain responsible for keeping rejected input and sensitive values derived from it out of this collection.

§Returns

The named parameters associated with this violation.

Source

pub fn with_path(self, path: ValidationPath) -> Self

Replaces the structured location of the rejected value.

§Parameters

path: Path containing only declared fields and opaque positions.

§Returns

The violation with path stored in place of its previous path.

Source

pub fn with_param(self, name: &'static str, value: ViolationParam) -> Self

Adds or replaces a structured parameter by its declared name.

The type restricts representation but cannot prove provenance. Supply only program-declared tokens or rule configuration values, never rejected input or sensitive values derived from it.

§Parameters

name: Static program-declared parameter name.
value: Scalar or static token associated with the name, subject to the caller’s provenance and redaction responsibility.