114 lines
3.1 KiB
Rust
114 lines
3.1 KiB
Rust
//! # jsonschema
|
|
//!
|
|
//! A crate for performing fast JSON Schema validation. It is fast due to schema compilation into
|
|
//! a validation tree, which reduces runtime costs for working with schema parameters.
|
|
//!
|
|
//! Supports:
|
|
//! - JSON Schema drafts 6, 7 (all test cases);
|
|
//! - Loading remote documents via HTTP(S);
|
|
//!
|
|
//! ## Example:
|
|
//!
|
|
//! ```rust
|
|
//! use jsonschema::{JSONSchema, Draft, CompilationError};
|
|
//! use serde_json::json;
|
|
//!
|
|
//!fn main() -> Result<(), CompilationError> {
|
|
//! let schema = json!({"maxLength": 5});
|
|
//! let instance = json!("foo");
|
|
//! let compiled = JSONSchema::compile(&schema, Some(Draft::Draft7))?;
|
|
//! let result = compiled.validate(&instance);
|
|
//! if let Err(errors) = result {
|
|
//! for error in errors {
|
|
//! println!("Validation error: {}", error)
|
|
//! }
|
|
//! }
|
|
//! Ok(())
|
|
//! }
|
|
//!
|
|
//! ```
|
|
#![warn(
|
|
clippy::doc_markdown,
|
|
clippy::redundant_closure,
|
|
clippy::explicit_iter_loop,
|
|
clippy::match_same_arms,
|
|
clippy::needless_borrow,
|
|
clippy::print_stdout,
|
|
clippy::integer_arithmetic,
|
|
clippy::cast_possible_truncation,
|
|
clippy::result_unwrap_used,
|
|
clippy::result_map_unwrap_or_else,
|
|
clippy::option_unwrap_used,
|
|
clippy::option_map_unwrap_or_else,
|
|
clippy::option_map_unwrap_or,
|
|
clippy::trivially_copy_pass_by_ref,
|
|
clippy::needless_pass_by_value,
|
|
missing_docs,
|
|
missing_debug_implementations,
|
|
trivial_casts,
|
|
trivial_numeric_casts,
|
|
unused_extern_crates,
|
|
unused_import_braces,
|
|
unused_qualifications,
|
|
variant_size_differences
|
|
)]
|
|
mod compilation;
|
|
mod error;
|
|
mod keywords;
|
|
mod primitive_type;
|
|
mod resolver;
|
|
mod schemas;
|
|
mod validator;
|
|
pub use compilation::JSONSchema;
|
|
pub use error::{CompilationError, ErrorIterator, ValidationError};
|
|
pub use schemas::Draft;
|
|
use serde_json::Value;
|
|
|
|
/// A shortcut for validating `instance` against `schema`. Draft version is detected automatically.
|
|
/// ```rust
|
|
/// use jsonschema::is_valid;
|
|
/// use serde_json::json;
|
|
///
|
|
/// let schema = json!({"maxLength": 5});
|
|
/// let instance = json!("foo");
|
|
/// assert!(is_valid(&schema, &instance));
|
|
/// ```
|
|
///
|
|
/// This function panics if an invalid schema is passed.
|
|
#[must_use]
|
|
#[inline]
|
|
pub fn is_valid(schema: &Value, instance: &Value) -> bool {
|
|
let compiled = JSONSchema::compile(schema, None).expect("Invalid schema");
|
|
compiled.is_valid(instance)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests_util {
|
|
use super::JSONSchema;
|
|
use serde_json::Value;
|
|
|
|
pub fn is_not_valid(schema: Value, instance: Value) {
|
|
let compiled = JSONSchema::compile(&schema, None).unwrap();
|
|
assert!(!compiled.is_valid(&instance), "{} should not be valid");
|
|
assert!(
|
|
compiled.validate(&instance).is_err(),
|
|
"{} should not be valid"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use serde_json::json;
|
|
|
|
#[test]
|
|
fn test_is_valid() {
|
|
let schema = json!({"minLength": 5});
|
|
let valid = json!("foobar");
|
|
let invalid = json!("foo");
|
|
assert!(is_valid(&schema, &valid));
|
|
assert!(!is_valid(&schema, &invalid));
|
|
}
|
|
}
|