Struct JSONASchemaValidator

pub struct JSONASchemaValidator { /* private fields */ }

Implementations

impl JSONASchemaValidator

pub fn validate(&self, node: &Node) -> Vec<JSONASchemaValidationError>

Examples found in repository

examples/validate.rs (line 22)

fn main() {
    let mut args = std::env::args();
    args.next();
    let (schema_jsona_path, plain_jsona_path) =
        if let (Some(v1), Some(v2)) = (args.next(), args.next()) {
            (v1, v2)
        } else {
            println!("Usage: validate <schema-jsona> <to-validate-jsona>");
            return;
        };
    let schema_jsona = std::fs::read_to_string(std::path::Path::new(&schema_jsona_path))
        .expect("not found schema jsona file");
    let schema_node: Node = schema_jsona.parse().expect("invalid schema jsona file");
    let validator =
        JSONASchemaValidator::try_from(&schema_node).expect("invalid schema jsona schema");
    let plain_jsona = std::fs::read_to_string(std::path::Path::new(&plain_jsona_path))
        .expect("not found to validate jsona file");
    let plain_node: Node = plain_jsona.parse().expect("invalid to validate jsona file");
    let errors = validator.validate(&plain_node);
    errors.iter().for_each(|err| {
        println!("{}", err);
    });
}

pub fn pointer(&self, keys: &Keys) -> Vec<&Schema>

Examples found in repository

examples/query-schema.rs (line 19)

fn main() {
    let mut args = std::env::args();
    let jsona_file = args
        .nth(1)
        .expect("Usage: query-schema <schema-jsona-file> [keys]");
    let keys = args.next();
    let jsona_file_path = std::path::Path::new(&jsona_file);
    let jsona_content =
        std::fs::read_to_string(jsona_file_path).expect("not found schema jsona file");
    let node: Node = jsona_content.parse().expect("invalid file");
    let validator = JSONASchemaValidator::try_from(&node).expect("invalid schema");
    let keys = match keys {
        Some(keys) => keys.parse().expect("invalid query path"),
        None => Keys::default(),
    };
    let result = serde_json::to_string_pretty(&validator.pointer(&keys)).unwrap();
    println!("{}", result);
}

pub fn get_entry_schema(&self, key: &str) -> Option<&Schema>

pub fn contains_annotation_key(&self, key: &str) -> bool

Trait Implementations

impl Debug for JSONASchemaValidator

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

Formats the value using the given formatter.

impl TryFrom<&Node> for JSONASchemaValidator

type Error = Vec<SchemaError>

The type returned in the event of a conversion error.

fn try_from(value: &Node) -> Result<Self, Self::Error>

Performs the conversion.