schemurai 2.2.2 → 2.3.0

data/ext/schemurai_native/src/tracking.rs

@@ -0,0 +1,532 @@
+//! Evaluated locations stay in native buffers, scoped to one instance location.
+//! Keys remain borrowed VALUEs; no Ruby objects or instance trees are allocated.
+use super::*;
+use std::collections::HashSet;
+use std::hash::Hash;
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct JsonKey(pub Value, u64);
+impl JsonKey {
+    pub(super) fn new(value: Value) -> Self {
+        Self(value, string_fingerprint(value))
+    }
+}
+impl PartialEq for JsonKey {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0 || unsafe { sn_string_equal(self.0, other.0) != 0 }
+    }
+}
+impl Eq for JsonKey {}
+impl Hash for JsonKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u64(self.1);
+    }
+}
+pub(super) type KeySet = HashSet<JsonKey, BuildHasherDefault<BucketHasher>>;
+
+pub(super) struct Tracked {
+    pub status: Verdict,
+    properties: KeySet,
+    known_properties: Vec<u64>,
+    items: Vec<u64>,
+}
+impl Tracked {
+    pub(super) fn new(status: Verdict) -> Self {
+        Self {
+            status,
+            properties: KeySet::default(),
+            known_properties: vec![],
+            items: vec![],
+        }
+    }
+    pub(super) fn item(&mut self, index: usize) {
+        let word = index / 64;
+        if self.items.len() <= word {
+            self.items.resize(word + 1, 0);
+        }
+        self.items[word] |= 1_u64 << (index % 64);
+    }
+    pub(super) fn contains_item(&self, index: usize) -> bool {
+        self.items
+            .get(index / 64)
+            .is_some_and(|word| word & (1_u64 << (index % 64)) != 0)
+    }
+    fn known_property(&mut self, index: usize) {
+        let word = index / 64;
+        if self.known_properties.len() <= word {
+            self.known_properties.resize(word + 1, 0);
+        }
+        self.known_properties[word] |= 1_u64 << (index % 64);
+    }
+    fn contains_known_property(&self, index: usize) -> bool {
+        self.known_properties
+            .get(index / 64)
+            .is_some_and(|word| word & (1_u64 << (index % 64)) != 0)
+    }
+    pub(super) fn property_count(&self) -> usize {
+        self.properties.len()
+            + self
+                .known_properties
+                .iter()
+                .map(|word| word.count_ones() as usize)
+                .sum::<usize>()
+    }
+    pub(super) fn item_count(&self) -> usize {
+        self.items
+            .iter()
+            .map(|word| word.count_ones() as usize)
+            .sum()
+    }
+    pub(super) fn merge(&mut self, other: Self) -> Verdict {
+        if other.status != Valid {
+            return other.status;
+        }
+        if self.properties.is_empty() {
+            self.properties = other.properties;
+        } else {
+            self.properties.extend(other.properties);
+        }
+        merge_bits(&mut self.known_properties, other.known_properties);
+        merge_bits(&mut self.items, other.items);
+        Valid
+    }
+    pub(super) fn merge_diagnostics(&mut self, other: Self) -> Result<(), Verdict> {
+        if other.status == Unsupported {
+            return Err(Unsupported);
+        }
+        if self.status != Valid || other.status != Valid {
+            *self = Self::new(Invalid);
+        } else {
+            self.merge(other);
+        }
+        Ok(())
+    }
+    pub(super) fn property(&mut self, engine: &Engine, value: Value) {
+        let key = JsonKey::new(value);
+        if let Some(&index) = engine.property_ids.get(&key) {
+            self.known_property(index);
+        } else {
+            self.properties.insert(key);
+        }
+    }
+    pub(super) fn contains_property(&self, engine: &Engine, value: Value) -> bool {
+        let key = JsonKey::new(value);
+        engine
+            .property_ids
+            .get(&key)
+            .is_some_and(|&index| self.contains_known_property(index))
+            || self.properties.contains(&key)
+    }
+}
+fn merge_bits(target: &mut Vec<u64>, source: Vec<u64>) {
+    // Branch annotations own native buffers of location bits. Transfer an
+    // existing buffer into an empty accumulator instead of allocating a copy.
+    if target.is_empty() {
+        *target = source;
+    } else {
+        if target.len() < source.len() {
+            target.resize(source.len(), 0);
+        }
+        for (target, source) in target.iter_mut().zip(source) {
+            *target |= source;
+        }
+    }
+}
+impl Engine {
+    pub(super) fn eval_tracked(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+    ) -> Tracked {
+        if depth > MAX_EVALUATION_DEPTH {
+            return Tracked::new(Unsupported);
+        }
+        let kind = if value & self.fixnum_flag != 0 {
+            TYPE_INTEGRAL_NUMBER
+        } else {
+            unsafe { sn_kind(value) }
+        };
+        self.eval_tracked_kind(node, value, depth, active, kind)
+    }
+    // Applicator branches evaluate the same borrowed instance under the GVL.
+    // No Ruby callback can mutate it, so its guarded kind can be reused while
+    // each branch still enters its own resource scope and checks depth.
+    pub(super) fn eval_tracked_kind(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        kind: i32,
+    ) -> Tracked {
+        let frame = scope::ScopeFrame {
+            resource: self.metadata[node].resource,
+            parent: active.scope,
+            primary_binding: active
+                .scope
+                .and_then(|frame| frame.primary_binding)
+                .or(self.metadata[node].primary_binding),
+        };
+        let active = self.enter_scope(node, active, &frame);
+        if depth > MAX_EVALUATION_DEPTH {
+            return Tracked::new(Unsupported);
+        }
+        if kind == TYPE_UNSUPPORTED {
+            return Tracked::new(Unsupported);
+        }
+        let mut evaluation = Tracked::new(Valid);
+        for op in &self.nodes[node] {
+            let result = match op {
+                Op::Ref(target) => {
+                    if RefFrame::contains(active.active, node, value) {
+                        Valid
+                    } else {
+                        let frame = RefFrame {
+                            source: node,
+                            value,
+                            parent: active.active,
+                        };
+                        evaluation.merge(self.eval_tracked_kind(
+                            self.reference_target(*target, active),
+                            value,
+                            depth + 1,
+                            scope::Context {
+                                active: Some(&frame),
+                                ..active
+                            },
+                            kind,
+                        ))
+                    }
+                }
+                Op::All(nodes) => {
+                    let mut result = Valid;
+                    for &child in nodes {
+                        result = evaluation.merge(self.eval_tracked_kind(
+                            child,
+                            value,
+                            depth + 1,
+                            active,
+                            kind,
+                        ));
+                        if result != Valid {
+                            break;
+                        }
+                    }
+                    result
+                }
+                Op::Any(nodes) | Op::One(nodes) => {
+                    let mut matched = Tracked::new(Valid);
+                    let mut count = 0;
+                    let mut result = Valid;
+                    for &(child, multiplicity) in nodes {
+                        let branch = self.eval_tracked_kind(child, value, depth + 1, active, kind);
+                        if branch.status == Unsupported {
+                            result = Unsupported;
+                            break;
+                        }
+                        if branch.status == Valid {
+                            count += multiplicity;
+                            matched.merge(branch);
+                        }
+                    }
+                    if result != Valid {
+                        result
+                    } else if count == 0 || (matches!(op, Op::One(_)) && count != 1) {
+                        Invalid
+                    } else {
+                        evaluation.merge(matched)
+                    }
+                }
+                Op::Not(child) => match self.eval(*child, value, depth + 1, active) {
+                    Valid => Invalid,
+                    Invalid => Valid,
+                    Unsupported => Unsupported,
+                },
+                Op::Conditional(condition, yes, no) => {
+                    let condition =
+                        self.eval_tracked_kind(*condition, value, depth + 1, active, kind);
+                    let status = condition.status;
+                    if status == Unsupported {
+                        Unsupported
+                    } else {
+                        let branch = if status == Valid {
+                            evaluation.merge(condition);
+                            yes
+                        } else {
+                            no
+                        };
+                        if let Some(child) = branch {
+                            evaluation.merge(self.eval_tracked_kind(
+                                *child,
+                                value,
+                                depth + 1,
+                                active,
+                                kind,
+                            ))
+                        } else {
+                            Valid
+                        }
+                    }
+                }
+                Op::Array(required, rules) => {
+                    if *required != 0 && kind != TYPE_ARRAY {
+                        Invalid
+                    } else if kind != TYPE_ARRAY {
+                        Valid
+                    } else {
+                        self.array_tracked(rules, value, depth + 1, active, &mut evaluation)
+                    }
+                }
+                Op::Object(required, rules) => {
+                    if *required != 0 && kind != TYPE_OBJECT {
+                        Invalid
+                    } else if kind != TYPE_OBJECT {
+                        Valid
+                    } else {
+                        self.object_tracked(rules, value, depth + 1, active, &mut evaluation)
+                    }
+                }
+                _ => self.leaf(op, kind, value, depth),
+            };
+            if result != Valid {
+                return Tracked::new(result);
+            }
+        }
+        evaluation
+    }
+    fn array_tracked(
+        &self,
+        r: &Array,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        evaluation: &mut Tracked,
+    ) -> Verdict {
+        let len = unsafe { sn_len(value) };
+        if bounds(len, r.min, r.max) == Invalid {
+            return Invalid;
+        }
+        if r.unique {
+            let result = unique(value, depth, self.fixnum_flag);
+            if result != Valid {
+                return result;
+            }
+        }
+        for (index, &child) in r.prefix.iter().take(len).enumerate() {
+            let result = self.eval(child, unsafe { sn_entry(value, index) }, depth, active);
+            if result != Valid {
+                return result;
+            }
+            evaluation.item(index);
+        }
+        for index in 0..len {
+            let child = if r.list {
+                r.items.get(index).copied().or(r.additional)
+            } else if index >= r.prefix.len() {
+                r.items.first().copied()
+            } else {
+                None
+            };
+            if let Some(child) = child {
+                let result = self.eval(child, unsafe { sn_entry(value, index) }, depth, active);
+                if result != Valid {
+                    return result;
+                }
+                evaluation.item(index);
+            }
+        }
+        if let Some(child) = r.contains {
+            let mut count = 0;
+            for index in 0..len {
+                match self.eval(child, unsafe { sn_entry(value, index) }, depth, active) {
+                    Valid => {
+                        count += 1;
+                        evaluation.item(index);
+                    }
+                    Invalid => {}
+                    Unsupported => return Unsupported,
+                }
+            }
+            if bounds(count, Some(r.min_contains), r.max_contains) == Invalid {
+                return Invalid;
+            }
+        }
+        if let Some(child) = r.unevaluated.filter(|_| evaluation.item_count() < len) {
+            if matches!(self.nodes[child].as_slice(), [Op::Boolean(false)]) {
+                return Invalid;
+            }
+            for index in 0..len {
+                if evaluation.contains_item(index) {
+                    continue;
+                }
+                let result = self.eval(child, unsafe { sn_entry(value, index) }, depth, active);
+                if result != Valid {
+                    return result;
+                }
+                evaluation.item(index);
+            }
+        }
+        Valid
+    }
+    fn object_tracked(
+        &self,
+        r: &Object,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        evaluation: &mut Tracked,
+    ) -> Verdict {
+        let len = unsafe { sn_len(value) };
+        if bounds(len, r.min, r.max) == Invalid {
+            return Invalid;
+        }
+        for &key in &r.required {
+            if missing(value, key, self.undefined) {
+                return Invalid;
+            }
+        }
+        let mut found = 0;
+        for (index, &(key, child)) in r.properties.iter().enumerate() {
+            let item = unsafe { sn_lookup(value, key) };
+            if item == self.undefined {
+                if r.required_properties[index] {
+                    return Invalid;
+                }
+                continue;
+            }
+            found += 1;
+            let result = self.record_value(child, item, depth, active);
+            if result != Valid {
+                return result;
+            }
+            evaluation.known_property(r.property_indices[index]);
+        }
+        if r.names.is_some() || !r.patterns.is_empty() || (r.additional.is_some() && found < len) {
+            let result = self.tracked_object_walk(r, value, depth, active, evaluation, false);
+            if result != Valid {
+                return result;
+            }
+        }
+        for (name, required) in &r.dependent_required {
+            if !missing(value, *name, self.undefined) {
+                for &key in required {
+                    if missing(value, key, self.undefined) {
+                        return Invalid;
+                    }
+                }
+            }
+        }
+        for &(key, child) in &r.dependent_schemas {
+            if !missing(value, key, self.undefined) {
+                let result = evaluation.merge(self.eval_tracked(child, value, depth, active));
+                if result != Valid {
+                    return result;
+                }
+            }
+        }
+        if let Some(child) = r.unevaluated.filter(|_| evaluation.property_count() < len) {
+            if matches!(self.nodes[child].as_slice(), [Op::Boolean(false)]) {
+                return Invalid;
+            }
+            let result = self.tracked_object_walk(r, value, depth, active, evaluation, true);
+            if result != Valid {
+                return result;
+            }
+        }
+        Valid
+    }
+    fn tracked_object_walk(
+        &self,
+        rules: &Object,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+        evaluation: &mut Tracked,
+        unevaluated: bool,
+    ) -> Verdict {
+        let mut c = TrackingContext {
+            engine: self,
+            rules,
+            depth,
+            active,
+            evaluation,
+            unevaluated,
+        };
+        decode(unsafe {
+            sn_hash_each(
+                value,
+                (&mut c as *mut TrackingContext).cast(),
+                tracking_entry,
+            )
+        })
+    }
+}
+struct TrackingContext<'a> {
+    engine: &'a Engine,
+    rules: &'a Object,
+    depth: usize,
+    active: scope::Context<'a>,
+    evaluation: &'a mut Tracked,
+    unevaluated: bool,
+}
+unsafe extern "C" fn tracking_entry(context: *mut c_void, key: Value, value: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let c = unsafe { &mut *context.cast::<TrackingContext>() };
+        if unsafe { sn_kind(key) } != TYPE_STRING {
+            return Unsupported as i32;
+        }
+        let key_location = JsonKey::new(key);
+        let known = c.engine.property_ids.get(&key_location).copied();
+        let child = if c.unevaluated {
+            if known.map_or_else(
+                || c.evaluation.properties.contains(&key_location),
+                |index| c.evaluation.contains_known_property(index),
+            ) {
+                return Valid as i32;
+            }
+            c.rules.unevaluated
+        } else {
+            if let Some(child) = c.rules.names {
+                let result = c.engine.eval(child, key, c.depth, c.active);
+                if result != Valid {
+                    return result as i32;
+                }
+            }
+            let mut matched = c.rules.property_keys.contains(&key_location);
+            for (pattern, child) in &c.rules.patterns {
+                match pattern.eval(key) {
+                    Unsupported => return Unsupported as i32,
+                    Invalid => {}
+                    Valid => {
+                        matched = true;
+                        let result = c.engine.eval(*child, value, c.depth, c.active);
+                        if result != Valid {
+                            return result as i32;
+                        }
+                        if let Some(index) = known {
+                            c.evaluation.known_property(index);
+                        } else {
+                            c.evaluation.properties.insert(key_location);
+                        }
+                    }
+                }
+            }
+            if matched { None } else { c.rules.additional }
+        };
+        if let Some(child) = child {
+            let result = c.engine.eval(child, value, c.depth, c.active);
+            if result != Valid {
+                return result as i32;
+            }
+            if let Some(index) = known {
+                c.evaluation.known_property(index);
+            } else {
+                c.evaluation.properties.insert(key_location);
+            }
+        }
+        Valid as i32
+    }))
+    .unwrap_or(Unsupported as i32)
+}

data/lib/schemurai/backend.rb

@@ -3,7 +3,7 @@
 module Schemurai
   module Backend
     VM_FEATURE = "vm/evaluator"
-    CHOICES = %i[default ruby vm].freeze
+    CHOICES = %i[default ruby vm native].freeze
 
     module_function def requested
       value = ENV.fetch("SCHEMURAI_BACKEND", "default").to_sym
@@ -18,6 +18,7 @@ module Schemurai
 
       selection = production_default if selection == :default
       load_vm! if selection == :vm
+      require_relative "native/evaluator" if selection == :native
       selection
     end
 

data/lib/schemurai/native/diagnostics.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Native
+    # Render native diagnostic output using the messages shared by every backend.
+    # The instance remains an original Ruby object; this layer never traverses it.
+    module Diagnostics
+      TYPE_NAMES = {Protocol::OP_TYPE_NULL => "null", Protocol::OP_TYPE_BOOLEAN => "boolean", Protocol::OP_TYPE_OBJECT => "object",
+                    Protocol::OP_TYPE_ARRAY => "array", Protocol::OP_TYPE_NUMBER => "number", Protocol::OP_TYPE_INTEGER => "integer",
+                    Protocol::OP_TYPE_STRING => "string", Protocol::OP_TYPED_NUMBER => "number", Protocol::OP_TYPED_INTEGER => "integer",
+                    Protocol::OP_TYPED_STRING => "string", Protocol::OP_TYPED_ARRAY => "array", Protocol::OP_TYPED_OBJECT => "object"}.freeze
+      ATTRIBUTES = {"maximum" => :maximum, "minimum" => :minimum, "exclusiveMaximum" => :exclusive_maximum, "exclusiveMinimum" => :exclusive_minimum,
+                    "maxLength" => :max_length, "minLength" => :min_length, "maxItems" => :max_items, "minItems" => :min_items,
+                    "maxProperties" => :max_properties, "minProperties" => :min_properties}.freeze
+      private_constant :TYPE_NAMES, :ATTRIBUTES
+
+      module_function def error(row)
+        keyword, instance_path, schema_path, opcode, operand, instance, detail = row
+        ValidationError.new(keyword: keyword, instance_path: instance_path, schema_path: schema_path,
+          message: message(keyword, opcode, operand, instance, detail))
+      end
+
+      module_function def message(keyword, opcode, operand, instance, detail) # rubocop:disable Metrics/MethodLength
+        messages = Internal::ErrorMessage
+        case keyword
+        when "falseSchema" then messages.false_schema
+        when "type" then messages.type((opcode == Protocol::OP_TYPES) ? operand.names : TYPE_NAMES.fetch(opcode), instance)
+        when "const" then messages.const
+        when "enum" then messages.enum
+        when "maximum", "minimum", "exclusiveMaximum", "exclusiveMinimum"
+          messages.numeric_limit(keyword, operand.public_send(ATTRIBUTES.fetch(keyword)))
+        when "multipleOf" then messages.multiple_of(operand.multiple_of)
+        when "maxLength", "minLength", "maxItems", "minItems", "maxProperties", "minProperties"
+          messages.size(keyword, operand.public_send(ATTRIBUTES.fetch(keyword)), detail)
+        when "pattern" then messages.pattern(operand.pattern)
+        when "format" then messages.format(operand.format.name)
+        when "contentEncoding" then messages.content_encoding
+        when "contentMediaType" then messages.content_media_type
+        when "uniqueItems" then messages.unique_items
+        when "required" then messages.required(instance)
+        when "dependencies", "dependentRequired" then messages.dependent_required(operand, instance)
+        when "contains" then messages.contains(detail, operand.min_contains, operand.max_contains)
+        when "anyOf" then messages.any_of
+        when "oneOf" then messages.one_of(detail)
+        when "not" then messages.not
+        else raise "unknown native diagnostic #{keyword.inspect}"
+        end
+      end
+      private_class_method :message
+    end
+  end
+end

data/lib/schemurai/native/evaluator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../vm/evaluator"
+require "schemurai_native"
+require_relative "diagnostics"
+
+module Schemurai
+  module Native
+    class Evaluator
+      def backend = :native
+
+      def initialize(graph, compiler, root, content: false, format: false)
+        @program = Program.new(root, compiler, format, content)
+        @vm = VM::Evaluator.new(graph, compiler, root, content: content, format: format)
+      end
+
+      def valid?(instance)
+        result = @program.valid?(instance)
+        result.nil? ? @vm.valid?(instance) : result
+      end
+
+      def validate(instance)
+        rows = @program.diagnostics(instance)
+        return @vm.validate(instance) if rows.nil?
+
+        Result.new(rows.empty? ? rows : rows.map { |row| Diagnostics.error(row) })
+      end
+    end
+  end
+
+  private_constant :Native
+end

data/lib/schemurai/version.rb

@@ -2,5 +2,5 @@
 
 module Schemurai
   # The installed Schemurai version.
-  VERSION = "2.2.2"
+  VERSION = "2.3.0"
 end