corvus_json_schema 0.1.0

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

@@ -0,0 +1,417 @@
+//! The compiled schema graph: one `SchemaNode` per distinct (document, pointer), with pre-digested keyword data.
+//! A port of `Corvus.Text.Json.RuntimeEvaluator.Compilation.SchemaNode` (via the TypeScript port's `node.ts`).
+
+use std::sync::Arc;
+
+use serde_json::{Number, Value};
+
+use crate::dialect::Dialect;
+use crate::formats::FormatKind;
+use crate::pattern::Pattern;
+
+/// A node index in the compiled graph.
+pub(crate) type NodeId = u32;
+
+/// JSON types as bits.
+pub(crate) mod type_mask {
+    pub const NULL: u8 = 1;
+    pub const BOOLEAN: u8 = 2;
+    pub const OBJECT: u8 = 4;
+    pub const ARRAY: u8 = 8;
+    pub const NUMBER: u8 = 16;
+    pub const STRING: u8 = 32;
+    pub const INTEGER: u8 = 64;
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum ContentKind {
+    None,
+    Base64,
+    Json,
+    Base64Json,
+}
+
+/// An annotation-producing keyword and its value (reported in verbose results).
+#[derive(Clone, Debug)]
+pub(crate) struct AnnotationEntry {
+    pub keyword: String,
+    pub value: Value,
+    /// Reported only when the instance is a string (content keywords).
+    pub strings_only: bool,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct PatternProperty {
+    pub pattern: Arc<Pattern>,
+    pub node: NodeId,
+}
+
+/// The keyword a dependency entry came from, which names its result rows.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum DependencyKeyword {
+    Dependencies,
+    DependentSchemas,
+    DependentRequired,
+}
+
+impl DependencyKeyword {
+    pub fn name(self) -> &'static str {
+        match self {
+            DependencyKeyword::Dependencies => "dependencies",
+            DependencyKeyword::DependentSchemas => "dependentSchemas",
+            DependencyKeyword::DependentRequired => "dependentRequired",
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct DependencyEntry {
+    pub keyword: DependencyKeyword,
+    pub name: String,
+    pub required: Option<Vec<String>>,
+    pub schema: Option<NodeId>,
+}
+
+/// A `$dynamicRef`/`$recursiveRef` that stays dynamic after compile-time analysis.
+#[derive(Clone, Debug)]
+pub(crate) struct DynamicRefTarget {
+    pub is_recursive: bool,
+    pub fallback: NodeId,
+    /// (resource id, node id of that resource's matching anchor), for the resources that define it.
+    pub by_resource: Vec<(u32, NodeId)>,
+}
+
+/// A discriminator value: the JSON scalars `const`/`enum` can name.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum DiscriminatorValue {
+    String(String),
+    Number(Number),
+    Bool(bool),
+    Null,
+}
+
+impl DiscriminatorValue {
+    /// Whether an instance value equals this one (numbers by value: `1` and `1.0` are the same key).
+    pub fn matches<'a, I: crate::instance::Instance<'a>>(&self, v: I) -> bool {
+        use crate::instance::View;
+        match (self, v.view()) {
+            (DiscriminatorValue::String(a), View::String(b)) => a == b,
+            (DiscriminatorValue::Number(a), View::Number(b)) => crate::numbers::num_eq(a, &b),
+            (DiscriminatorValue::Bool(a), View::Bool(b)) => *a == b,
+            (DiscriminatorValue::Null, View::Null) => true,
+            _ => false,
+        }
+    }
+
+    /// Key equality, with numbers by value.
+    pub fn same(&self, other: &DiscriminatorValue) -> bool {
+        match (self, other) {
+            (DiscriminatorValue::Number(a), DiscriminatorValue::Number(b)) => crate::numbers::num_eq(a, b),
+            _ => self == other,
+        }
+    }
+}
+
+/// Selects oneOf/anyOf branches by the value of one property (`SchemaCompiler.BuildDiscriminator`).
+#[derive(Clone, Debug)]
+pub(crate) struct Discriminator {
+    pub property: String,
+    /// Known discriminator values and the branches (indexes into the keyword's list) each can select.
+    pub known: Vec<(DiscriminatorValue, Vec<u32>)>,
+    /// Branches that stay candidates for a value not in `known` (negative and wildcard branches).
+    pub unknown: Vec<u32>,
+    /// Every branch requires the property, so its absence fails the keyword at once.
+    pub all_require: bool,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum StaticDynamicKeyword {
+    DynamicRef,
+    RecursiveRef,
+}
+
+impl StaticDynamicKeyword {
+    pub fn name(self) -> &'static str {
+        match self {
+            StaticDynamicKeyword::DynamicRef => "$dynamicRef",
+            StaticDynamicKeyword::RecursiveRef => "$recursiveRef",
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct SchemaNode {
+    pub resource_id: u32,
+    pub dialect: Dialect,
+    /// The JSON pointer of the schema within its document (C#'s SchemaLocation).
+    pub pointer: String,
+
+    pub always_true: bool,
+    pub always_false: bool,
+
+    // Assertions.
+    pub type_mask: u8,
+    pub has_type: bool,
+    pub const_value: Option<Value>,
+    pub enum_values: Option<Vec<Value>>,
+
+    // References.
+    pub ref_: Option<NodeId>,
+    /// A `$dynamicRef`/`$recursiveRef` that compile-time analysis resolved statically, and its keyword.
+    pub static_dynamic_ref: Option<NodeId>,
+    pub static_dynamic_keyword: StaticDynamicKeyword,
+    pub dynamic_ref: Option<Box<DynamicRefTarget>>,
+
+    // In-place applicators.
+    pub all_of: Option<Vec<NodeId>>,
+    pub any_of: Option<Vec<NodeId>>,
+    pub one_of: Option<Vec<NodeId>>,
+    pub not: Option<NodeId>,
+    pub if_: Option<NodeId>,
+    pub then: Option<NodeId>,
+    pub else_: Option<NodeId>,
+
+    // Objects.
+    pub properties: Option<Vec<(String, NodeId)>>,
+    pub pattern_properties: Option<Vec<PatternProperty>>,
+    pub additional_properties: Option<NodeId>,
+    pub property_names: Option<NodeId>,
+    /// `required` without duplicates.
+    pub required: Option<Vec<String>>,
+    /// `required` as written (duplicates kept), for results.
+    pub required_list: Option<Vec<String>>,
+    pub dependencies: Option<Vec<DependencyEntry>>,
+    pub min_properties: Option<u64>,
+    pub max_properties: Option<u64>,
+    pub unevaluated_properties: Option<NodeId>,
+
+    // Arrays.
+    pub prefix_items: Option<Vec<NodeId>>,
+    /// The keywords behind prefix_items/items: `prefixItems`/`items` (2020-12) or `items`/`additionalItems` (legacy).
+    pub prefix_keyword: &'static str,
+    pub items_keyword: &'static str,
+    pub items: Option<NodeId>,
+    pub contains: Option<NodeId>,
+    pub min_contains: u64,
+    pub max_contains: Option<u64>,
+    pub contains_marks_evaluated: bool,
+    pub min_items: Option<u64>,
+    pub max_items: Option<u64>,
+    pub unique_items: bool,
+    pub unevaluated_items: Option<NodeId>,
+
+    // Strings.
+    pub min_length: Option<u64>,
+    pub max_length: Option<u64>,
+    pub pattern: Option<Arc<Pattern>>,
+    pub format: Option<String>,
+    pub format_kind: FormatKind,
+    pub assert_format: bool,
+    pub content: ContentKind,
+    pub assert_content: bool,
+
+    // Numbers.
+    pub minimum: Option<Number>,
+    pub maximum: Option<Number>,
+    pub exclusive_minimum: Option<Number>,
+    pub exclusive_maximum: Option<Number>,
+    pub multiple_of: Option<Number>,
+
+    // Analysis.
+    pub marks_properties: bool,
+    pub marks_items: bool,
+    pub in_place_cycle: bool,
+    pub one_of_discriminator: Option<Box<Discriminator>>,
+    pub any_of_discriminator: Option<Box<Discriminator>>,
+}
+
+impl SchemaNode {
+    pub fn new(resource_id: u32, dialect: Dialect, pointer: String) -> SchemaNode {
+        SchemaNode {
+            resource_id,
+            dialect,
+            pointer,
+            always_true: false,
+            always_false: false,
+            type_mask: 0,
+            has_type: false,
+            const_value: None,
+            enum_values: None,
+            ref_: None,
+            static_dynamic_ref: None,
+            static_dynamic_keyword: StaticDynamicKeyword::DynamicRef,
+            dynamic_ref: None,
+            all_of: None,
+            any_of: None,
+            one_of: None,
+            not: None,
+            if_: None,
+            then: None,
+            else_: None,
+            properties: None,
+            pattern_properties: None,
+            additional_properties: None,
+            property_names: None,
+            required: None,
+            required_list: None,
+            dependencies: None,
+            min_properties: None,
+            max_properties: None,
+            unevaluated_properties: None,
+            prefix_items: None,
+            prefix_keyword: "prefixItems",
+            items_keyword: "items",
+            items: None,
+            contains: None,
+            min_contains: 1,
+            max_contains: None,
+            contains_marks_evaluated: false,
+            min_items: None,
+            max_items: None,
+            unique_items: false,
+            unevaluated_items: None,
+            min_length: None,
+            max_length: None,
+            pattern: None,
+            format: None,
+            format_kind: FormatKind::Unknown,
+            assert_format: false,
+            content: ContentKind::None,
+            assert_content: false,
+            minimum: None,
+            maximum: None,
+            exclusive_minimum: None,
+            exclusive_maximum: None,
+            multiple_of: None,
+            marks_properties: false,
+            marks_items: false,
+            in_place_cycle: false,
+            one_of_discriminator: None,
+            any_of_discriminator: None,
+        }
+    }
+
+    /// Keywords that apply only to objects.
+    pub fn has_object_keywords(&self) -> bool {
+        self.properties.is_some()
+            || self.pattern_properties.is_some()
+            || self.additional_properties.is_some()
+            || self.property_names.is_some()
+            || self.required.is_some()
+            || self.dependencies.is_some()
+            || self.min_properties.is_some()
+            || self.max_properties.is_some()
+            || self.unevaluated_properties.is_some()
+    }
+
+    pub fn has_array_keywords(&self) -> bool {
+        self.prefix_items.is_some()
+            || self.items.is_some()
+            || self.contains.is_some()
+            || self.min_items.is_some()
+            || self.max_items.is_some()
+            || self.unique_items
+            || self.unevaluated_items.is_some()
+    }
+
+    pub fn has_string_keywords(&self) -> bool {
+        self.min_length.is_some()
+            || self.max_length.is_some()
+            || self.pattern.is_some()
+            || (self.assert_format && self.format.is_some() && !self.format_kind.is_numeric())
+            || self.assert_content
+    }
+
+    pub fn has_number_keywords(&self) -> bool {
+        self.minimum.is_some()
+            || self.maximum.is_some()
+            || self.exclusive_minimum.is_some()
+            || self.exclusive_maximum.is_some()
+            || self.multiple_of.is_some()
+            || (self.assert_format && self.format.is_some() && self.format_kind.is_numeric())
+    }
+
+    pub fn has_in_place_applicators(&self) -> bool {
+        self.ref_.is_some()
+            || self.static_dynamic_ref.is_some()
+            || self.dynamic_ref.is_some()
+            || self.all_of.is_some()
+            || self.any_of.is_some()
+            || self.one_of.is_some()
+            || self.not.is_some()
+            || self.if_.is_some()
+            || self.dependencies.as_ref().is_some_and(|d| d.iter().any(|e| e.schema.is_some()))
+    }
+
+    /// Nothing but `$ref`: no other keyword that asserts.
+    pub fn is_pure_ref(&self) -> bool {
+        self.ref_.is_some()
+            && !self.has_type
+            && self.const_value.is_none()
+            && self.enum_values.is_none()
+            && !self.has_object_keywords()
+            && !self.has_array_keywords()
+            && !self.has_string_keywords()
+            && !self.has_number_keywords()
+            && self.dynamic_ref.is_none()
+            && self.static_dynamic_ref.is_none()
+            && self.all_of.is_none()
+            && self.any_of.is_none()
+            && self.one_of.is_none()
+            && self.not.is_none()
+            && self.if_.is_none()
+            && self.dependencies.is_none()
+    }
+
+    /// In-place children (the instance is evaluated at the same location).
+    pub fn in_place_children(&self, include_not: bool) -> Vec<NodeId> {
+        let mut out = Vec::new();
+        out.extend(self.ref_);
+        out.extend(self.static_dynamic_ref);
+        if let Some(d) = &self.dynamic_ref {
+            out.push(d.fallback);
+            out.extend(d.by_resource.iter().map(|&(_, n)| n));
+        }
+        for list in [&self.all_of, &self.any_of, &self.one_of].into_iter().flatten() {
+            out.extend_from_slice(list);
+        }
+        if include_not {
+            out.extend(self.not);
+        }
+        out.extend(self.if_);
+        out.extend(self.then);
+        out.extend(self.else_);
+        if let Some(deps) = &self.dependencies {
+            out.extend(deps.iter().filter_map(|d| d.schema));
+        }
+        out
+    }
+
+    /// Every child node.
+    pub fn children(&self) -> Vec<NodeId> {
+        let mut out = self.in_place_children(true);
+        if let Some(p) = &self.properties {
+            out.extend(p.iter().map(|&(_, n)| n));
+        }
+        if let Some(p) = &self.pattern_properties {
+            out.extend(p.iter().map(|pp| pp.node));
+        }
+        for c in [
+            self.additional_properties,
+            self.property_names,
+            self.unevaluated_properties,
+            self.items,
+            self.contains,
+            self.unevaluated_items,
+        ]
+        .into_iter()
+        .flatten()
+        {
+            out.push(c);
+        }
+        if let Some(p) = &self.prefix_items {
+            out.extend_from_slice(p);
+        }
+        out
+    }
+}

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

@@ -0,0 +1,244 @@
+//! Exact numeric comparisons over `serde_json::Number` (integers stay exact; floats compare by value), and exact
+//! `multipleOf` over decimal forms, matching the C# evaluator's normalised-decimal semantics.
+
+use std::cmp::Ordering;
+
+use serde_json::Number;
+
+/// The value of a JSON number: an exact integer, or a double.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Num {
+    I(i128),
+    F(f64),
+}
+
+impl Num {
+    #[inline]
+    pub fn of(n: &Number) -> Num {
+        if let Some(i) = n.as_i64() {
+            Num::I(i as i128)
+        } else if let Some(u) = n.as_u64() {
+            Num::I(u as i128)
+        } else {
+            let f = n.as_f64().unwrap_or(f64::NAN);
+            // A double that holds an integer exactly (1.0, 1e3) is that integer.
+            if f.fract() == 0.0 && f.abs() < 1.0e36 { Num::I(f as i128) } else { Num::F(f) }
+        }
+    }
+}
+
+/// Compares an integer with a double exactly.
+fn cmp_int_float(i: i128, f: f64) -> Ordering {
+    if f.is_nan() {
+        return Ordering::Less;
+    }
+    if f >= 1.7e38 {
+        return Ordering::Less;
+    }
+    if f <= -1.7e38 {
+        return Ordering::Greater;
+    }
+    let fl = f.floor();
+    let fi = fl as i128;
+    match i.cmp(&fi) {
+        Ordering::Equal => {
+            if f > fl {
+                Ordering::Less
+            } else {
+                Ordering::Equal
+            }
+        }
+        o => o,
+    }
+}
+
+#[inline]
+pub(crate) fn cmp(a: Num, b: Num) -> Ordering {
+    match (a, b) {
+        (Num::I(x), Num::I(y)) => x.cmp(&y),
+        (Num::I(x), Num::F(y)) => cmp_int_float(x, y),
+        (Num::F(x), Num::I(y)) => cmp_int_float(y, x).reverse(),
+        (Num::F(x), Num::F(y)) => x.partial_cmp(&y).unwrap_or(Ordering::Equal),
+    }
+}
+
+/// JSON number equality (1 == 1.0).
+#[inline]
+pub(crate) fn num_eq(a: &Number, b: &Number) -> bool {
+    cmp(Num::of(a), Num::of(b)) == Ordering::Equal
+}
+
+/// A decimal: mantissa × 10^exponent, from the shortest round-trip text of the number.
+fn decimal(n: Num) -> Option<(i128, i32)> {
+    match n {
+        Num::I(i) => Some((i, 0)),
+        Num::F(f) => {
+            if !f.is_finite() {
+                return None;
+            }
+            // `{:e}` gives the shortest round-trip digits: "1.25e-3", "5e0". Formatted on the stack.
+            let mut buf = StackText::default();
+            std::fmt::Write::write_fmt(&mut buf, format_args!("{f:e}")).ok()?;
+            let s = buf.as_str();
+            let (mant, exp) = s.split_once('e')?;
+            let exp: i32 = exp.parse().ok()?;
+            let neg = mant.starts_with('-');
+            let mant = mant.trim_start_matches('-');
+            let (int_part, frac) = mant.split_once('.').unwrap_or((mant, ""));
+            if int_part.len() + frac.len() > 36 {
+                return None;
+            }
+            let mut m: i128 = 0;
+            for c in int_part.bytes().chain(frac.bytes()) {
+                m = m * 10 + (c - b'0') as i128;
+            }
+            Some((if neg { -m } else { m }, exp - frac.len() as i32))
+        }
+    }
+}
+
+/// A short text formatted without allocating (a double's `{:e}` form is at most 24 bytes).
+struct StackText {
+    buf: [u8; 40],
+    len: usize,
+}
+
+impl Default for StackText {
+    fn default() -> Self {
+        StackText { buf: [0; 40], len: 0 }
+    }
+}
+
+impl StackText {
+    fn as_str(&self) -> &str {
+        std::str::from_utf8(&self.buf[..self.len]).unwrap_or("")
+    }
+}
+
+impl std::fmt::Write for StackText {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        let end = self.len + s.len();
+        if end > self.buf.len() {
+            return Err(std::fmt::Error);
+        }
+        self.buf[self.len..end].copy_from_slice(s.as_bytes());
+        self.len = end;
+        Ok(())
+    }
+}
+
+fn gcd(mut a: u128, mut b: u128) -> u128 {
+    while b != 0 {
+        (a, b) = (b, a % b);
+    }
+    a
+}
+
+/// Whether `m * 10^shift` is divisible by `d` (`d > 0`), without forming the (possibly huge) product: after removing
+/// the common factor of `m` and `d`, what remains of `d` must divide `10^shift`, so hold only 2s and 5s.
+fn divides_scaled(m: u128, shift: u32, d: u128) -> bool {
+    let mut rest = d / gcd(m, d);
+    for f in [2u128, 5] {
+        let mut count = 0u32;
+        while rest % f == 0 {
+            rest /= f;
+            count += 1;
+        }
+        if count > shift {
+            return false;
+        }
+    }
+    rest == 1
+}
+
+/// A `multipleOf` divisor with its integer or decimal form worked out once (the C# evaluator's DivisorValue).
+#[derive(Clone, Debug)]
+pub(crate) struct Divisor {
+    int: Option<i128>,
+    /// Magnitude of the mantissa and the exponent: the divisor is `m * 10^e`.
+    decimal: Option<(u128, i32)>,
+}
+
+impl Divisor {
+    pub fn new(d: &Number) -> Divisor {
+        let n = Num::of(d);
+        Divisor {
+            int: match n {
+                Num::I(i) => Some(i),
+                Num::F(_) => None,
+            },
+            decimal: decimal(n).map(|(m, e)| (m.unsigned_abs(), e)),
+        }
+    }
+
+    /// Exact `multipleOf`: whether `x / d` is an integer, over the decimal forms of both numbers.
+    pub fn divides(&self, x: &Number) -> bool {
+        let xn = Num::of(x);
+        if let (Num::I(a), Some(b)) = (xn, self.int) {
+            return b != 0 && a % b == 0;
+        }
+        let (Some((am, ae)), Some((bm, be))) = (decimal(xn), self.decimal) else {
+            return false;
+        };
+        let am = am.unsigned_abs();
+        if bm == 0 {
+            return false;
+        }
+        if am == 0 {
+            return true;
+        }
+        let shift = ae - be;
+        if shift >= 0 {
+            divides_scaled(am, shift as u32, bm)
+        } else {
+            // am must be divisible by bm * 10^-shift; am < 10^37, so a larger power of ten cannot divide it.
+            match 10u128.checked_pow((-shift) as u32).and_then(|p| bm.checked_mul(p)) {
+                Some(den) => am % den == 0,
+                None => false,
+            }
+        }
+    }
+}
+
+/// Exact `multipleOf`: whether `x / d` is an integer, over the decimal forms of both numbers.
+pub(crate) fn multiple_of(x: &Number, d: &Number) -> bool {
+    Divisor::new(d).divides(x)
+}
+
+/// The number's text as C# formats it in messages.
+pub(crate) fn number_text(n: &Number) -> String {
+    n.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn n(v: serde_json::Value) -> Number {
+        v.as_number().unwrap().clone()
+    }
+
+    #[test]
+    fn multiple_of_is_exact() {
+        assert!(multiple_of(&n(json!(0.0075)), &n(json!(0.0001))));
+        assert!(!multiple_of(&n(json!(0.00751)), &n(json!(0.0001))));
+        assert!(multiple_of(&n(json!(4.5)), &n(json!(1.5))));
+        assert!(!multiple_of(&n(json!(35)), &n(json!(1.5))));
+        assert!(multiple_of(&n(json!(10)), &n(json!(5))));
+        assert!(!multiple_of(&n(json!(1e308)), &n(json!(0.123456789))));
+        assert!(multiple_of(&n(json!(1e308)), &n(json!(0.5))));
+        assert!(multiple_of(&n(json!(0)), &n(json!(0.3))));
+        assert!(!multiple_of(&n(json!(1e-300)), &n(json!(1e-7))));
+    }
+
+    #[test]
+    fn comparisons_are_exact() {
+        assert_eq!(
+            cmp(Num::of(&n(json!(9007199254740993u64))), Num::of(&n(json!(9007199254740992.0)))),
+            Ordering::Greater
+        );
+        assert_eq!(cmp(Num::of(&n(json!(1))), Num::of(&n(json!(1.0)))), Ordering::Equal);
+        assert_eq!(cmp(Num::of(&n(json!(-1))), Num::of(&n(json!(-0.5)))), Ordering::Less);
+    }
+}