corvus_json_schema 0.1.3 → 0.2.0

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

@@ -271,12 +271,11 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             (r.dialect, r.vocabularies)
         };
         let legacy = dialect.is_legacy();
+        let grammar = crate::pattern::Grammar::of(dialect, self.options);
 
-        if legacy {
-            if let Some(Value::String(r)) = e.get("$ref") {
-                // In draft 7 and earlier, $ref replaces every sibling keyword.
-                return self.compile_ref(id, target, r);
-            }
+        if legacy && let Some(Value::String(r)) = e.get("$ref") {
+            // In draft 7 and earlier, $ref replaces every sibling keyword.
+            return self.compile_ref(id, target, r);
         }
 
         let applicator = legacy || voc & vocab::APPLICATOR != 0;
@@ -295,15 +294,15 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
         if let Some(Value::String(r)) = e.get("$ref") {
             self.compile_ref(id, target, r)?;
         }
-        if dialect >= Dialect::Draft202012 {
-            if let Some(Value::String(r)) = e.get("$dynamicRef") {
-                self.compile_dynamic_ref(id, target, r, false)?;
-            }
+        if dialect >= Dialect::Draft202012
+            && let Some(Value::String(r)) = e.get("$dynamicRef")
+        {
+            self.compile_dynamic_ref(id, target, r, false)?;
         }
-        if dialect == Dialect::Draft201909 {
-            if let Some(Value::String(r)) = e.get("$recursiveRef") {
-                self.compile_dynamic_ref(id, target, r, true)?;
-            }
+        if dialect == Dialect::Draft201909
+            && let Some(Value::String(r)) = e.get("$recursiveRef")
+        {
+            self.compile_dynamic_ref(id, target, r, true)?;
         }
 
         // Applicators.
@@ -321,18 +320,18 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 let c = self.child(target, v, "/not");
                 self.nodes[id as usize].not = Some(c);
             }
-            if dialect >= Dialect::Draft7 {
-                if let Some(v) = e.get("if") {
-                    let c = self.child(target, v, "/if");
-                    self.nodes[id as usize].if_ = Some(c);
-                    if let Some(v) = e.get("then") {
-                        let c = self.child(target, v, "/then");
-                        self.nodes[id as usize].then = Some(c);
-                    }
-                    if let Some(v) = e.get("else") {
-                        let c = self.child(target, v, "/else");
-                        self.nodes[id as usize].else_ = Some(c);
-                    }
+            if dialect >= Dialect::Draft7
+                && let Some(v) = e.get("if")
+            {
+                let c = self.child(target, v, "/if");
+                self.nodes[id as usize].if_ = Some(c);
+                if let Some(v) = e.get("then") {
+                    let c = self.child(target, v, "/then");
+                    self.nodes[id as usize].then = Some(c);
+                }
+                if let Some(v) = e.get("else") {
+                    let c = self.child(target, v, "/else");
+                    self.nodes[id as usize].else_ = Some(c);
                 }
             }
             if let Some(Value::Object(props)) = e.get("properties") {
@@ -346,11 +345,8 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             if let Some(Value::Object(pp)) = e.get("patternProperties") {
                 let mut list = Vec::with_capacity(pp.len());
                 for (pattern, v) in pp {
-                    let compiled = crate::pattern::compile(pattern).ok_or_else(|| {
-                        SchemaCompilationError::new(format!(
-                            "Invalid regular expression '{pattern}' in patternProperties."
-                        ))
-                    })?;
+                    let compiled =
+                        crate::pattern::compile(pattern, grammar).map_err(|e| e.of(pattern, "patternProperties"))?;
                     let c = self.child(target, v, &format!("/patternProperties/{}", escape_pointer_token(pattern)));
                     list.push(PatternProperty { pattern: compiled, node: c });
                 }
@@ -384,11 +380,11 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                     self.nodes[id as usize].prefix_items =
                         self.child_array(target, e.get("prefixItems"), "prefixItems");
                 }
-                if let Some(v) = e.get("items") {
-                    if !v.is_array() {
-                        let c = self.child(target, v, &kw("items"));
-                        self.nodes[id as usize].items = Some(c);
-                    }
+                if let Some(v) = e.get("items")
+                    && !v.is_array()
+                {
+                    let c = self.child(target, v, &kw("items"));
+                    self.nodes[id as usize].items = Some(c);
                 }
             } else if let Some(v) = e.get("items") {
                 if v.is_array() {
@@ -431,10 +427,10 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 n.type_mask = mask;
                 n.has_type = true;
             }
-            if dialect >= Dialect::Draft6 {
-                if let Some(c) = e.get("const") {
-                    n.const_value = Some(c.clone());
-                }
+            if dialect >= Dialect::Draft6
+                && let Some(c) = e.get("const")
+            {
+                n.const_value = Some(c.clone());
             }
             if let Some(Value::Array(values)) = e.get("enum") {
                 n.enum_values = Some(values.clone());
@@ -450,18 +446,18 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 n.required_list = Some(list);
                 n.required = Some(dedup);
             }
-            if dialect >= Dialect::Draft201909 {
-                if let Some(Value::Object(dr)) = e.get("dependentRequired") {
-                    let deps = dependencies.get_or_insert_with(Vec::new);
-                    for (name, v) in dr {
-                        if let Value::Array(list) = v {
-                            deps.push(DependencyEntry {
-                                keyword: DependencyKeyword::DependentRequired,
-                                name: name.clone(),
-                                required: Some(strings(list)),
-                                schema: None,
-                            });
-                        }
+            if dialect >= Dialect::Draft201909
+                && let Some(Value::Object(dr)) = e.get("dependentRequired")
+            {
+                let deps = dependencies.get_or_insert_with(Vec::new);
+                for (name, v) in dr {
+                    if let Value::Array(list) = v {
+                        deps.push(DependencyEntry {
+                            keyword: DependencyKeyword::DependentRequired,
+                            name: name.clone(),
+                            required: Some(strings(list)),
+                            schema: None,
+                        });
                     }
                 }
             }
@@ -473,9 +469,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             n.min_length = get_uint(e.get("minLength"));
             n.max_length = get_uint(e.get("maxLength"));
             if let Some(Value::String(p)) = e.get("pattern") {
-                n.pattern = Some(crate::pattern::compile(p).ok_or_else(|| {
-                    SchemaCompilationError::new(format!("Invalid regular expression '{p}' in pattern."))
-                })?);
+                n.pattern = Some(crate::pattern::compile(p, grammar).map_err(|e| e.of(p, "pattern"))?);
             }
             if let Some(Value::Number(m)) = e.get("multipleOf") {
                 n.multiple_of = Some(m.clone());
@@ -518,7 +512,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
 
         if let Some(Value::String(f)) = e.get("format") {
             n.format = Some(f.clone());
-            n.format_kind = FormatKind::of(f, dialect);
+            n.format_kind = FormatKind::of(f, dialect, grammar);
             n.assert_format = format_assert;
         }
 
@@ -577,17 +571,17 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 }
             }
         }
-        if dialect >= Dialect::Draft201909 {
-            if let Some(Value::Object(ds)) = e.get("dependentSchemas") {
-                for (name, v) in ds {
-                    let c = self.child(target, v, &format!("/dependentSchemas/{}", escape_pointer_token(name)));
-                    out.push(DependencyEntry {
-                        keyword: DependencyKeyword::DependentSchemas,
-                        name: name.clone(),
-                        required: None,
-                        schema: Some(c),
-                    });
-                }
+        if dialect >= Dialect::Draft201909
+            && let Some(Value::Object(ds)) = e.get("dependentSchemas")
+        {
+            for (name, v) in ds {
+                let c = self.child(target, v, &format!("/dependentSchemas/{}", escape_pointer_token(name)));
+                out.push(DependencyEntry {
+                    keyword: DependencyKeyword::DependentSchemas,
+                    name: name.clone(),
+                    required: None,
+                    schema: Some(c),
+                });
             }
         }
         out
@@ -906,15 +900,15 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
 
     fn compute_discriminators(&mut self) {
         for i in 0..self.nodes.len() {
-            if let Some(branches) = self.nodes[i].one_of.clone() {
-                if branches.len() > 1 {
-                    self.nodes[i].one_of_discriminator = self.build_discriminator(&branches).map(Box::new);
-                }
+            if let Some(branches) = self.nodes[i].one_of.clone()
+                && branches.len() > 1
+            {
+                self.nodes[i].one_of_discriminator = self.build_discriminator(&branches).map(Box::new);
             }
-            if let Some(branches) = self.nodes[i].any_of.clone() {
-                if branches.len() > 1 {
-                    self.nodes[i].any_of_discriminator = self.build_discriminator(&branches).map(Box::new);
-                }
+            if let Some(branches) = self.nodes[i].any_of.clone()
+                && branches.len() > 1
+            {
+                self.nodes[i].any_of_discriminator = self.build_discriminator(&branches).map(Box::new);
             }
         }
     }
@@ -986,32 +980,32 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             return Class::Wildcard;
         };
         let p = self.effective_node(child);
-        if let Some(c) = &p.const_value {
-            if let Some(v) = primitive(c) {
-                return Class::Positive(vec![v]);
-            }
+        if let Some(c) = &p.const_value
+            && let Some(v) = primitive(c)
+        {
+            return Class::Positive(vec![v]);
         }
-        if let Some(values) = &p.enum_values {
-            if !values.is_empty() {
-                let prims: Vec<DiscriminatorValue> = values.iter().filter_map(primitive).collect();
-                if prims.len() == values.len() {
-                    return Class::Positive(prims);
-                }
+        if let Some(values) = &p.enum_values
+            && !values.is_empty()
+        {
+            let prims: Vec<DiscriminatorValue> = values.iter().filter_map(primitive).collect();
+            if prims.len() == values.len() {
+                return Class::Positive(prims);
             }
         }
-        if let Some(not) = p.not {
-            if p.has_type && p.type_mask == type_mask::STRING {
-                let not = self.effective_node(not);
-                if let Some(values) = &not.enum_values {
-                    if values.iter().all(Value::is_string)
-                        && !not.has_type
-                        && not.const_value.is_none()
-                        && !not.has_string_keywords()
-                        && !not.has_in_place_applicators()
-                    {
-                        return Class::Negative(values.iter().filter_map(primitive).collect());
-                    }
-                }
+        if let Some(not) = p.not
+            && p.has_type
+            && p.type_mask == type_mask::STRING
+        {
+            let not = self.effective_node(not);
+            if let Some(values) = &not.enum_values
+                && values.iter().all(Value::is_string)
+                && !not.has_type
+                && not.const_value.is_none()
+                && !not.has_string_keywords()
+                && !not.has_in_place_applicators()
+            {
+                return Class::Negative(values.iter().filter_map(primitive).collect());
             }
         }
         Class::Wildcard

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

@@ -552,9 +552,9 @@ impl<'s> Parser<'s> {
             return;
         }
         let mut kept: Vec<Node> = Vec::with_capacity(pairs.len());
-        for p in pairs.chunks_exact(2) {
+        for p in pairs.as_chunks::<2>().0 {
             let name = self.key_str(&p[0]);
-            match kept.chunks_exact(2).position(|q| self.key_str(&q[0]) == name) {
+            match kept.as_chunks::<2>().0.iter().position(|q| self.key_str(&q[0]) == name) {
                 Some(at) => kept[2 * at + 1] = p[1],
                 None => kept.extend_from_slice(p),
             }

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/eval/plan/fused.rs

@@ -26,7 +26,7 @@ use crate::eval::{json_equal, matches_type};
 use crate::instance::{Instance, ObjectView, View};
 use crate::node::*;
 use crate::numbers::Num;
-use crate::pattern::Pattern;
+use crate::pattern::{Pattern, PatternBudget};
 
 const MAX_NAMES: usize = 256;
 const MAX_CONDITIONS: usize = 64;
@@ -132,11 +132,11 @@ enum TestKind {
 }
 
 impl ValueTest {
-    fn holds<'x, I: Instance<'x>>(&self, v: I) -> bool {
+    fn holds<'x, I: Instance<'x>>(&self, v: I, budget: &mut PatternBudget) -> bool {
         match &self.kind {
             TestKind::Allowed(values) => values.iter().any(|a| json_equal(a, v)),
             TestKind::Pattern { pattern, requires_string } => match v.view() {
-                View::String(s) => pattern.is_match(s),
+                View::String(s) => pattern.is_match(s, budget),
                 _ => !requires_string,
             },
         }
@@ -696,7 +696,7 @@ pub(super) fn try_fuse(
     // A known name matching an absent pattern fails its condition whatever its value: no constant is allowed.
     for (e, name) in names.iter().enumerate() {
         for (condition, pattern) in &absent {
-            if pattern.is_match(name) {
+            if pattern.is_match(name, &mut p.compile_budget.lock().unwrap_or_else(|e| e.into_inner())) {
                 tests[e].push(ValueTest { condition: *condition, kind: TestKind::Allowed(Box::new([])) });
             }
         }
@@ -714,7 +714,7 @@ pub(super) fn try_fuse(
                 apps.push((c as u16, app_child(schema), Some(p.fast_target[schema as usize])));
             }
             for pp in b.pattern_properties.iter().flatten() {
-                if pp.pattern.is_match(name) {
+                if pp.pattern.is_match(name, &mut p.compile_budget.lock().unwrap_or_else(|e| e.into_inner())) {
                     matched = true;
                     apps.push((c as u16, app_child(pp.node), Some(p.fast_target[pp.node as usize])));
                 }
@@ -942,7 +942,7 @@ impl Evaluator<'_, '_> {
     fn resolve_unknown<'x, I: Instance<'x>>(&mut self, c: &Contributor, name: &str, v: I) -> Option<bool> {
         let mut matched = false;
         for (pattern, child) in c.patterns.iter() {
-            if pattern.is_match(name) {
+            if pattern.is_match(name, &mut self.budget) {
                 matched = true;
                 if !self.apply(*child, v) {
                     return None;
@@ -965,7 +965,11 @@ impl Evaluator<'_, '_> {
             Some(merged) => {
                 let allowed = merged.allowed(v);
                 for (t, test) in entry.tests.iter().enumerate() {
-                    let holds = if merged.keyed & (1 << t) != 0 { allowed & (1 << t) != 0 } else { test.holds(v) };
+                    let holds = if merged.keyed & (1 << t) != 0 {
+                        allowed & (1 << t) != 0
+                    } else {
+                        test.holds(v, &mut self.budget)
+                    };
                     if !holds {
                         pass.failed |= 1 << test.condition;
                     }
@@ -973,7 +977,7 @@ impl Evaluator<'_, '_> {
             }
             None => {
                 for test in entry.tests.iter() {
-                    if !test.holds(v) {
+                    if !test.holds(v, &mut self.budget) {
                         pass.failed |= 1 << test.condition;
                     }
                 }
@@ -1004,7 +1008,7 @@ impl Evaluator<'_, '_> {
             return Outcome::Done { cover, defer };
         }
         for (c, pattern) in f.absent.iter() {
-            if pass.failed & (1 << c) == 0 && pattern.is_match(name) {
+            if pass.failed & (1 << c) == 0 && pattern.is_match(name, &mut self.budget) {
                 pass.failed |= 1 << c;
             }
         }

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

@@ -21,7 +21,7 @@ use crate::instance::{ArrayView, Instance, Kind, ObjectView, View, str_eq};
 use crate::node::*;
 use crate::numbers::{Divisor, Num, cmp};
 use crate::options::FormatValidator;
-use crate::pattern::Pattern;
+use crate::pattern::{Pattern, PatternBudget};
 
 /// Every JSON type (a node without `type`).
 const ANY: u8 = 0x7f;
@@ -790,7 +790,8 @@ fn plan_node(p: &Program, id: NodeId, n: &SchemaNode, target: &dyn Fn(NodeId) ->
                 .iter()
                 .map(|name| {
                     let patterns = n.pattern_properties.iter().flatten().enumerate();
-                    patterns.filter(|(_, pp)| pp.pattern.is_match(name)).map(|(j, _)| j as u16).collect()
+                    let mut budget = p.compile_budget.lock().unwrap_or_else(|e| e.into_inner());
+                    patterns.filter(|(_, pp)| pp.pattern.is_match(name, &mut budget)).map(|(j, _)| j as u16).collect()
                 })
                 .collect(),
             additional: n.additional_properties.map(child),
@@ -1086,13 +1087,13 @@ impl Evaluator<'_, '_> {
     #[inline(always)]
     fn enter<'x, I: Instance<'x>>(&mut self, shape: Shape, b: &Body, x: I) -> bool {
         match shape {
-            Shape::Leaf => run_leaf(b, x),
+            Shape::Leaf => run_leaf(b, x, &mut self.budget),
             Shape::StringEnum => match (&b.values[0], x.view()) {
                 (Op::EnumStrings(values), View::String(s)) => values.contains(s),
                 _ => false,
             },
             Shape::Strings => match x.view() {
-                View::String(s) => run_string(&b.string, s),
+                View::String(s) => run_string(&b.string, s, &mut self.budget),
                 _ => true,
             },
             Shape::Object => match x.view() {
@@ -1219,7 +1220,7 @@ impl Evaluator<'_, '_> {
         }
         let ok = match view {
             View::Number(n) => b.number.is_empty() || run_number(&b.number, &n),
-            View::String(s) => b.string.is_empty() || run_string(&b.string, s),
+            View::String(s) => b.string.is_empty() || run_string(&b.string, s, &mut self.budget),
             View::Object(o) => b.object.as_ref().is_none_or(|plan| self.run_object(plan, o, x)),
             View::Array(a) => {
                 b.array.as_ref().is_none_or(|plan| self.run_array::<I>(plan, a))
@@ -1423,7 +1424,7 @@ impl Evaluator<'_, '_> {
     fn visit_pattern<'x, I: Instance<'x>>(&mut self, plan: &ObjectPlan, o: I::Object) -> bool {
         let (pattern, c) = &plan.patterns[0];
         for (k, v) in o.iter() {
-            let applies = if pattern.is_match(k) { Some(*c) } else { plan.additional };
+            let applies = if pattern.is_match(k, &mut self.budget) { Some(*c) } else { plan.additional };
             if let Some(c) = applies
                 && !self.run_child(c, v)
             {
@@ -1455,7 +1456,7 @@ impl Evaluator<'_, '_> {
                 }
             } else {
                 for (pattern, c) in plan.patterns.iter() {
-                    if pattern.is_match(k) {
+                    if pattern.is_match(k, &mut self.budget) {
                         matched = true;
                         if !self.run_child(*c, v) {
                             return None;
@@ -1557,7 +1558,7 @@ fn all_of_type<'x, I: Instance<'x>>(mut items: impl Iterator<Item = I>, types: u
 
 /// A leaf's keywords: its value constraints, then those for the instance's type.
 #[inline]
-fn run_leaf<'x, I: Instance<'x>>(b: &Body, x: I) -> bool {
+fn run_leaf<'x, I: Instance<'x>>(b: &Body, x: I, budget: &mut PatternBudget) -> bool {
     for op in b.values.iter() {
         let ok = match op {
             Op::Const(c) => json_equal(x, c),
@@ -1571,7 +1572,7 @@ fn run_leaf<'x, I: Instance<'x>>(b: &Body, x: I) -> bool {
     }
     match x.view() {
         View::Number(n) => b.number.is_empty() || run_number(&b.number, &n),
-        View::String(s) => b.string.is_empty() || run_string(&b.string, s),
+        View::String(s) => b.string.is_empty() || run_string(&b.string, s, budget),
         _ => true,
     }
 }
@@ -1590,10 +1591,10 @@ fn run_number(ops: &[NumberOp], n: &Number) -> bool {
 }
 
 #[inline(never)]
-fn run_string(ops: &[StringOp], s: &str) -> bool {
+fn run_string(ops: &[StringOp], s: &str, budget: &mut PatternBudget) -> bool {
     ops.iter().all(|op| match op {
         StringOp::Length { min, max } => length_ok(s, *min, *max),
-        StringOp::Pattern(p) => p.is_match(s),
+        StringOp::Pattern(p) => p.is_match(s, budget),
         StringOp::Format(f) => f.string(s),
         StringOp::Content(kind) => content_ok(s, *kind),
     })