foundation_jsonschema 0.0.1

Self-contained JSON Schema validation for ewe_platform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! `properties` — validates named properties against their sub-schemas.

use alloc::boxed::Box;
use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;

use serde_json::Value;

use crate::error::{ErrorIterator, ValidationError};
use crate::node::SchemaNode;
use crate::paths::LazyLocation;

use super::{Validate, ValidationContext};

/// Validates each named property against its compiled sub-schema.
pub struct PropertiesValidator {
    properties: BTreeMap<String, SchemaNode>,
}

impl PropertiesValidator {
    /// Create with a map of property name → compiled schema.
    #[must_use]
    pub fn new(properties: BTreeMap<String, SchemaNode>) -> Self {
        Self { properties }
    }
}

impl Validate for PropertiesValidator {
    fn is_valid(&self, instance: &Value, ctx: &mut ValidationContext) -> bool {
        let mut valid = true;
        if let Value::Object(obj) = instance {
            for (name, value) in obj {
                if let Some(schema) = self.properties.get(name) {
                    let state = ctx.save_evaluation_state();
                    ctx.mark_property_evaluated(name);
                    if !schema.is_valid(value, ctx) {
                        valid = false;
                    }
                    // Restore to pre-subschema state but keep our mark
                    ctx.restore_evaluation_state(&state);
                    ctx.mark_property_evaluated(name);
                }
            }
        }
        valid
    }

    fn validate(
        &self,
        instance: &Value,
        instance_path: &LazyLocation<'_>,
        ctx: &mut ValidationContext,
    ) -> Result<(), ValidationError> {
        if let Value::Object(obj) = instance {
            for (name, value) in obj {
                if let Some(schema) = self.properties.get(name) {
                    let child_path = instance_path.push_property(name);
                    let state = ctx.save_evaluation_state();
                    ctx.mark_property_evaluated(name);
                    schema.validate(value, &child_path, ctx)?;
                    ctx.restore_evaluation_state(&state);
                    ctx.mark_property_evaluated(name);
                }
            }
        }
        Ok(())
    }

    fn iter_errors(
        &self,
        instance: &Value,
        instance_path: &LazyLocation<'_>,
        ctx: &mut ValidationContext,
    ) -> ErrorIterator {
        let mut errors: Vec<ValidationError> = Vec::new();
        if let Value::Object(obj) = instance {
            for (name, value) in obj {
                if let Some(schema) = self.properties.get(name) {
                    let child_path = instance_path.push_property(name);
                    let state = ctx.save_evaluation_state();
                    ctx.mark_property_evaluated(name);
                    for e in schema.iter_errors(value, &child_path, ctx) {
                        errors.push(e);
                    }
                    ctx.restore_evaluation_state(&state);
                    ctx.mark_property_evaluated(name);
                }
            }
        }
        Box::new(errors.into_iter())
    }
}