corvus_json_schema 0.1.0

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/instance.rs

@@ -0,0 +1,228 @@
+//! The instance values the evaluator reads: anything that can show itself as one of the six JSON kinds, with arrays and
+//! objects read in place. `&serde_json::Value` is one; a host language's own values (for example Python objects, read
+//! through its C API) can be another, so that evaluation needs no conversion to `serde_json::Value` first.
+
+use serde_json::{Map, Number, Value};
+
+/// A JSON value the evaluator can read in place. Cheap to copy (a reference or a handle); values reached through it
+/// (items, property values, strings) live as long as `'a`.
+pub trait Instance<'a>: Copy {
+    /// An array of instances.
+    type Array: ArrayView<'a, Item = Self>;
+    /// An object of named instances.
+    type Object: ObjectView<'a, Item = Self>;
+
+    /// The value's kind and content.
+    fn view(self) -> View<'a, Self>;
+
+    /// The value's kind alone (for type tests, which need no content).
+    #[inline]
+    fn kind(self) -> Kind {
+        match self.view() {
+            View::Null => Kind::Null,
+            View::Bool(_) => Kind::Bool,
+            View::Number(_) => Kind::Number,
+            View::String(_) => Kind::String,
+            View::Array(_) => Kind::Array,
+            View::Object(_) => Kind::Object,
+        }
+    }
+}
+
+/// The kind of a JSON value. The discriminants are the evaluator's type bits, so a type test is one mask operation
+/// (and a match that produces a kind compiles to a table, not a jump per value).
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+#[repr(u8)]
+pub enum Kind {
+    Null = 1,
+    Bool = 2,
+    Object = 4,
+    Array = 8,
+    Number = 16,
+    String = 32,
+}
+
+/// What an instance is.
+pub enum View<'a, I: Instance<'a>> {
+    Null,
+    Bool(bool),
+    Number(Number),
+    String(&'a str),
+    Array(I::Array),
+    Object(I::Object),
+}
+
+/// The items of an array.
+pub trait ArrayView<'a>: Copy {
+    type Item: Instance<'a>;
+
+    fn len(self) -> usize;
+
+    fn is_empty(self) -> bool {
+        self.len() == 0
+    }
+
+    /// The item at an index (which must be below `len`).
+    fn get(self, index: usize) -> Self::Item;
+
+    fn iter(self) -> impl Iterator<Item = Self::Item>;
+
+    /// The items from an index on (none when it is past the end).
+    fn tail(self, start: usize) -> impl Iterator<Item = Self::Item> {
+        self.iter().skip(start)
+    }
+}
+
+/// The properties of an object, in their order.
+pub trait ObjectView<'a>: Copy {
+    type Item: Instance<'a>;
+
+    fn len(self) -> usize;
+
+    fn is_empty(self) -> bool {
+        self.len() == 0
+    }
+
+    /// The value of a property.
+    fn get(self, name: &str) -> Option<Self::Item>;
+
+    fn contains_key(self, name: &str) -> bool {
+        self.get(name).is_some()
+    }
+
+    fn iter(self) -> impl Iterator<Item = (&'a str, Self::Item)>;
+
+    fn values(self) -> impl Iterator<Item = Self::Item> {
+        self.iter().map(|(_, v)| v)
+    }
+}
+
+impl<'a> Instance<'a> for &'a Value {
+    type Array = &'a [Value];
+    type Object = &'a Map<String, Value>;
+
+    #[inline(always)]
+    fn view(self) -> View<'a, Self> {
+        match self {
+            Value::Null => View::Null,
+            Value::Bool(b) => View::Bool(*b),
+            Value::Number(n) => View::Number(n.clone()),
+            Value::String(s) => View::String(s),
+            Value::Array(a) => View::Array(a.as_slice()),
+            Value::Object(o) => View::Object(o),
+        }
+    }
+
+    #[inline(always)]
+    fn kind(self) -> Kind {
+        match self {
+            Value::Null => Kind::Null,
+            Value::Bool(_) => Kind::Bool,
+            Value::Number(_) => Kind::Number,
+            Value::String(_) => Kind::String,
+            Value::Array(_) => Kind::Array,
+            Value::Object(_) => Kind::Object,
+        }
+    }
+}
+
+impl<'a> ArrayView<'a> for &'a [Value] {
+    type Item = &'a Value;
+
+    #[inline(always)]
+    fn len(self) -> usize {
+        <[Value]>::len(self)
+    }
+
+    #[inline(always)]
+    fn get(self, index: usize) -> &'a Value {
+        &self[index]
+    }
+
+    #[inline(always)]
+    fn iter(self) -> impl Iterator<Item = &'a Value> {
+        <[Value]>::iter(self)
+    }
+
+    #[inline(always)]
+    fn tail(self, start: usize) -> impl Iterator<Item = &'a Value> {
+        self.get(start..).unwrap_or_default().iter()
+    }
+}
+
+/// Objects up to this size are searched by scanning their keys: comparing lengths first, that is cheaper than hashing
+/// the name with serde_json's SipHash.
+const LINEAR_KEYS: usize = 32;
+
+impl<'a> ObjectView<'a> for &'a Map<String, Value> {
+    type Item = &'a Value;
+
+    #[inline(always)]
+    fn len(self) -> usize {
+        Map::len(self)
+    }
+
+    #[inline]
+    fn get(self, name: &str) -> Option<&'a Value> {
+        if Map::len(self) <= LINEAR_KEYS {
+            Map::iter(self).find(|(k, _)| str_eq(k, name)).map(|(_, v)| v)
+        } else {
+            Map::get(self, name)
+        }
+    }
+
+    #[inline]
+    fn contains_key(self, name: &str) -> bool {
+        if Map::len(self) <= LINEAR_KEYS { self.keys().any(|k| str_eq(k, name)) } else { Map::contains_key(self, name) }
+    }
+
+    #[inline(always)]
+    fn iter(self) -> impl Iterator<Item = (&'a str, &'a Value)> {
+        Map::iter(self).map(|(k, v)| (k.as_str(), v))
+    }
+
+    #[inline(always)]
+    fn values(self) -> impl Iterator<Item = &'a Value> {
+        Map::values(self)
+    }
+}
+
+/// String equality with the length test and short comparisons inline (property names are short).
+#[inline(always)]
+pub(crate) fn str_eq(a: &str, b: &str) -> bool {
+    let (a, b) = (a.as_bytes(), b.as_bytes());
+    if a.len() != b.len() {
+        return false;
+    }
+    let n = a.len();
+    if n <= 8 {
+        if n >= 4 {
+            // Two overlapping four-byte words cover every byte (one load each, no per-byte bounds checks).
+            let word = |s: &[u8], i: usize| u32::from_le_bytes(s[i..i + 4].try_into().unwrap());
+            return word(a, 0) == word(b, 0) && word(a, n - 4) == word(b, n - 4);
+        }
+        return a == b;
+    }
+    // Eight-byte words from the start, then one ending at the last byte (overlapping the previous one): property names
+    // are short enough that a call to memcmp costs more than the compare.
+    let word = |s: &[u8], i: usize| u64::from_le_bytes(s[i..i + 8].try_into().unwrap());
+    let mut i = 0;
+    while i + 8 < n {
+        if word(a, i) != word(b, i) {
+            return false;
+        }
+        i += 8;
+    }
+    word(a, n - 8) == word(b, n - 8)
+}
+
+// The kinds are the evaluator's type bits.
+const _: () = {
+    use crate::node::type_mask;
+    assert!(Kind::Null as u8 == type_mask::NULL);
+    assert!(Kind::Bool as u8 == type_mask::BOOLEAN);
+    assert!(Kind::Object as u8 == type_mask::OBJECT);
+    assert!(Kind::Array as u8 == type_mask::ARRAY);
+    assert!(Kind::Number as u8 == type_mask::NUMBER);
+    assert!(Kind::String as u8 == type_mask::STRING);
+};

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/lib.rs

@@ -0,0 +1,189 @@
+//! A high-performance JSON Schema evaluator (draft 4, 6, 7, 2019-09 and 2020-12), ported from the Corvus.Text.Json V5
+//! runtime evaluator (`Corvus.Text.Json.RuntimeEvaluator`).
+//!
+//! A schema is compiled once into a node graph with pre-digested keyword data, then any number of
+//! `serde_json::Value` instances are evaluated against it: fast (fail-fast, no reporting) with
+//! [`Validator::is_valid`], or exhaustively with a [`JsonSchemaResultsCollector`] for Basic, Detailed or Verbose
+//! results and annotations, with the same rows (paths, messages, order) as the C# collector.
+//!
+//! ```
+//! use serde_json::json;
+//!
+//! let validator = corvus_json_schema::compile(&json!({
+//!     "type": "object",
+//!     "properties": { "id": { "type": "integer", "minimum": 1 } },
+//!     "required": ["id"]
+//! }))
+//! .unwrap();
+//! assert!(validator.is_valid(&json!({ "id": 3 })));
+//! assert!(!validator.is_valid(&json!({ "id": 0 })));
+//! ```
+
+mod compiler;
+mod dialect;
+mod document;
+mod eval;
+mod formats;
+mod instance;
+mod loader;
+#[rustfmt::skip]
+mod metaschemas;
+mod node;
+mod numbers;
+mod options;
+mod pattern;
+mod results;
+mod uri;
+
+use std::sync::Arc;
+
+use serde_json::Value;
+
+pub use dialect::Dialect;
+pub use document::{JsonDocument, JsonDocumentArray, JsonDocumentObject, JsonDocumentValue, JsonParseError};
+pub use instance::{ArrayView, Instance, Kind, ObjectView, View};
+pub use options::{
+    CompileOptions, DocumentResolver, FormatValidator, SchemaCompilationError, SchemaEvaluationDepthError,
+};
+pub use results::{
+    Annotation, JsonSchemaResultsCollector, ResultsLevel, SchemaResult, collect_annotations, encode_pointer_segment,
+    enumerate_annotations, schema_location_fragment,
+};
+
+/// The version of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Why JSON text could not be validated.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum JsonValidationError {
+    /// The text is not valid JSON.
+    InvalidJson(JsonParseError),
+    /// Evaluation recursed in place beyond the maximum depth.
+    DepthExceeded(SchemaEvaluationDepthError),
+}
+
+impl std::fmt::Display for JsonValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            JsonValidationError::InvalidJson(e) => write!(f, "invalid JSON: {e}"),
+            JsonValidationError::DepthExceeded(e) => e.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for JsonValidationError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            JsonValidationError::InvalidJson(e) => Some(e),
+            JsonValidationError::DepthExceeded(e) => Some(e),
+        }
+    }
+}
+
+/// A compiled schema. Cheap to clone and safe to share between threads.
+#[derive(Clone)]
+pub struct Validator {
+    program: Arc<eval::Program>,
+}
+
+impl std::fmt::Debug for Validator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Validator").field("nodes", &self.program.nodes.len()).finish()
+    }
+}
+
+/// Compiles a schema with the default options (2020-12 for documents without `$schema`, `format` as an annotation
+/// unless the vocabularies assert it).
+pub fn compile(schema: &Value) -> Result<Validator, SchemaCompilationError> {
+    compile_with(schema, &CompileOptions::default())
+}
+
+/// Compiles a schema.
+pub fn compile_with(schema: &Value, options: &CompileOptions) -> Result<Validator, SchemaCompilationError> {
+    let compiled = compiler::SchemaCompiler::compile(schema.clone(), options)?;
+    Ok(Validator::from_compiled(compiled, options))
+}
+
+/// Compiles the schema document at `uri`, fetched through `options.resolve_document` (or one of the standard
+/// metaschemas).
+pub fn compile_from_uri(uri: &str, options: &CompileOptions) -> Result<Validator, SchemaCompilationError> {
+    let compiled = compiler::SchemaCompiler::compile_from_uri(uri, options)?;
+    Ok(Validator::from_compiled(compiled, options))
+}
+
+impl Validator {
+    fn from_compiled(c: compiler::CompiledSchema, options: &CompileOptions) -> Validator {
+        let program = eval::Program::new(
+            c.nodes,
+            c.root,
+            c.uses_dynamic_scope,
+            options.max_depth,
+            options.formats.clone(),
+            c.documents,
+            c.annotation_sources,
+            options.assert_format.is_some(),
+        );
+        Validator { program: Arc::new(program) }
+    }
+
+    /// Whether the instance is valid. A schema that recursed in place beyond the maximum depth is reported as
+    /// invalid; use [`Validator::validate`] to tell the two apart.
+    #[inline]
+    pub fn is_valid(&self, instance: &Value) -> bool {
+        eval::Evaluator::new(&self.program, None).validate(instance)
+    }
+
+    /// Whether the instance is valid, or an error if evaluation recursed in place beyond the maximum depth.
+    pub fn validate(&self, instance: &Value) -> Result<bool, SchemaEvaluationDepthError> {
+        let mut e = eval::Evaluator::new(&self.program, None);
+        let ok = e.validate(instance);
+        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+    }
+
+    /// Evaluates the instance exhaustively, reporting to the collector. Returns whether it is valid.
+    pub fn evaluate(
+        &self,
+        instance: &Value,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, SchemaEvaluationDepthError> {
+        self.evaluate_instance(instance, collector)
+    }
+
+    /// [`Validator::validate`] for any [`Instance`]: a value read in place, such as a host language's own objects,
+    /// with no conversion to `serde_json::Value`.
+    pub fn validate_instance<'a, I: Instance<'a>>(&self, instance: I) -> Result<bool, SchemaEvaluationDepthError> {
+        let mut e = eval::Evaluator::new(&self.program, None);
+        let ok = e.validate(instance);
+        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+    }
+
+    /// Whether the JSON text is valid. The text is parsed into the thread's reused buffers and evaluated in place: in
+    /// the steady state nothing is allocated. Use [`JsonDocument`] to validate the same text more than once.
+    pub fn validate_json(&self, json: &str) -> Result<bool, JsonValidationError> {
+        JsonDocument::with_document(json, |d| self.validate_instance(d.root()))
+            .map_err(JsonValidationError::InvalidJson)?
+            .map_err(JsonValidationError::DepthExceeded)
+    }
+
+    /// [`Validator::evaluate`] for JSON text, parsed as [`Validator::validate_json`] parses it.
+    pub fn evaluate_json(
+        &self,
+        json: &str,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, JsonValidationError> {
+        JsonDocument::with_document(json, |d| self.evaluate_instance(d.root(), collector))
+            .map_err(JsonValidationError::InvalidJson)?
+            .map_err(JsonValidationError::DepthExceeded)
+    }
+
+    /// [`Validator::evaluate`] for any [`Instance`].
+    pub fn evaluate_instance<'a, I: Instance<'a>>(
+        &self,
+        instance: I,
+        collector: &mut JsonSchemaResultsCollector,
+    ) -> Result<bool, SchemaEvaluationDepthError> {
+        let mut e = eval::Evaluator::new(&self.program, Some(collector));
+        let ok = e.evaluate(instance);
+        if e.depth_exceeded { Err(SchemaEvaluationDepthError) } else { Ok(ok) }
+    }
+}