schemurai 2.3.0 → 3.0.0

data/lib/schemurai/evaluator.rb

@@ -148,11 +148,13 @@ module Schemurai
         schema = node.schema
         if schema.key?("allOf")
           schema["allOf"].each_index do |index|
+            @budget&.checkpoint
             return false unless evaluate_valid(node.child("allOf", index), value)
           end
         end
         if schema.key?("anyOf")
           matched = schema["anyOf"].each_index.any? do |index|
+            @budget&.checkpoint
             evaluate_valid(node.child("anyOf", index), value)
           end
           return false unless matched
@@ -160,6 +162,7 @@ module Schemurai
         if schema.key?("oneOf")
           matches = 0
           schema["oneOf"].each_index do |index|
+            @budget&.checkpoint
             matches += 1 if evaluate_valid(node.child("oneOf", index), value)
             return false if matches > 1
           end
@@ -234,6 +237,7 @@ module Schemurai
         prefix_items = schema["prefixItems"]
         if prefix_items.is_a?(Array)
           prefix_items.each_index do |index|
+            @budget&.checkpoint
             break if index >= length
             return false unless evaluate_valid(node.child("prefixItems", index), value[index])
           end
@@ -242,12 +246,14 @@ module Schemurai
         items = schema["items"]
         if items.is_a?(Array)
           items.each_index do |index|
+            @budget&.checkpoint
             break if index >= length
             return false unless evaluate_valid(node.child("items", index), value[index])
           end
           if length > items.length && schema.key?("additionalItems")
             additional = node.child("additionalItems")
             (items.length...length).each do |index|
+              @budget&.checkpoint
               return false unless evaluate_valid(additional, value[index])
             end
           end
@@ -255,6 +261,7 @@ module Schemurai
           child = node.child("items")
           start = prefix_items.is_a?(Array) ? prefix_items.length : 0
           (start...length).each do |index|
+            @budget&.checkpoint
             return false unless evaluate_valid(child, value[index])
           end
         end
@@ -277,12 +284,16 @@ module Schemurai
         length = value.length
         return false if schema.key?("maxProperties") && length > schema["maxProperties"]
         return false if schema.key?("minProperties") && length < schema["minProperties"]
-        return false if schema.key?("required") && !schema["required"].all? { |name| value.key?(name) }
+        return false if schema.key?("required") && !schema["required"].all? do |name|
+          @budget&.checkpoint
+          value.key?(name)
+        end
 
         properties = schema["properties"]
         patterns = schema["patternProperties"]
         additional = node.child("additionalProperties") if schema.key?("additionalProperties")
         value.each do |name, property_value|
+          @budget&.checkpoint
           matched = false
           if properties&.key?(name)
             matched = true
@@ -290,6 +301,7 @@ module Schemurai
           end
           if patterns
             patterns.each_key do |pattern|
+              @budget&.checkpoint
               next unless ecma_regexp(pattern).match?(name)
               matched = true
               return false unless evaluate_valid(node.child("patternProperties", pattern), property_value)
@@ -305,9 +317,13 @@ module Schemurai
 
         if schema.key?("dependencies")
           schema["dependencies"].each do |name, dependency|
+            @budget&.checkpoint
             next unless value.key?(name)
             if dependency.is_a?(Array)
-              return false unless dependency.all? { |required_name| value.key?(required_name) }
+              return false unless dependency.all? do |required_name|
+                @budget&.checkpoint
+                value.key?(required_name)
+              end
             else
               return false unless evaluate_valid(node.child("dependencies", name), value)
             end
@@ -315,13 +331,18 @@ module Schemurai
         end
         if schema.key?("dependentRequired")
           schema["dependentRequired"].each do |name, required_names|
+            @budget&.checkpoint
             next unless value.key?(name)
-            return false unless required_names.all? { |required_name| value.key?(required_name) }
+            return false unless required_names.all? do |required_name|
+              @budget&.checkpoint
+              value.key?(required_name)
+            end
           end
         end
 
         if schema.key?("dependentSchemas")
           schema["dependentSchemas"].each_key do |name|
+            @budget&.checkpoint
             next unless value.key?(name)
             return false unless evaluate_valid(node.child("dependentSchemas", name), value)
           end
@@ -425,6 +446,7 @@ module Schemurai
         return target unless target.schema.is_a?(Hash) && target.schema["$dynamicAnchor"] == raw_fragment
 
         Array(@dynamic_scope).each do |resource|
+          @budget&.checkpoint
           dynamic = @graph.dynamic_anchor(resource, raw_fragment)
           return dynamic if dynamic
         end
@@ -459,6 +481,7 @@ module Schemurai
         evaluation = Evaluation.valid
         if schema.key?("allOf")
           schema["allOf"].each_index do |index|
+            @budget&.checkpoint
             evaluation = evaluation.merge(
               evaluate_at(node.child("allOf", index), value, MISSING_SEGMENT, "allOf", index)
             )
@@ -468,6 +491,7 @@ module Schemurai
         if schema.key?("anyOf")
           matches = []
           schema["anyOf"].each_index do |index|
+            @budget&.checkpoint
             result = trial_at(node.child("anyOf", index), value, MISSING_SEGMENT, "anyOf", index)
             matches << result if result.valid?
           end
@@ -481,6 +505,7 @@ module Schemurai
         if schema.key?("oneOf")
           matches = []
           schema["oneOf"].each_index do |index|
+            @budget&.checkpoint
             result = trial_at(node.child("oneOf", index), value, MISSING_SEGMENT, "oneOf", index)
             matches << result if result.valid?
           end
@@ -559,6 +584,7 @@ module Schemurai
         prefix_items = schema["prefixItems"]
         if prefix_items.is_a?(Array)
           prefix_items.each_index do |index|
+            @budget&.checkpoint
             break if index >= value.length
             evaluate_at(node.child("prefixItems", index), value[index], index, "prefixItems", index)
             evaluated << index
@@ -568,6 +594,7 @@ module Schemurai
         items = schema["items"]
         if items.is_a?(Array)
           items.each_index do |index|
+            @budget&.checkpoint
             break if index >= value.length
             evaluate_at(node.child("items", index), value[index], index, "items", index)
             evaluated << index
@@ -575,6 +602,7 @@ module Schemurai
           if value.length > items.length && schema.key?("additionalItems")
             additional = node.child("additionalItems")
             (items.length...value.length).each do |index|
+              @budget&.checkpoint
               evaluate_at(additional, value[index], index, "additionalItems")
               evaluated << index
             end
@@ -582,6 +610,7 @@ module Schemurai
         elsif !items.nil?
           start = prefix_items.is_a?(Array) ? prefix_items.length : 0
           value.each_with_index do |item, index|
+            @budget&.checkpoint
             next if index < start
             evaluate_at(node.child("items"), item, index, "items")
             evaluated << index
@@ -590,6 +619,7 @@ module Schemurai
 
         if schema.key?("contains")
           matched = value.each_index.select do |index|
+            @budget&.checkpoint
             trial_at(node.child("contains"), value[index], index, "contains").valid?
           end
           minimum = schema.fetch("minContains", 1)
@@ -604,6 +634,7 @@ module Schemurai
         if schema.key?("unevaluatedItems")
           unevaluated = (0...value.length).to_a - combined
           unevaluated.each do |index|
+            @budget&.checkpoint
             evaluate_at(node.child("unevaluatedItems"), value[index], index, "unevaluatedItems")
           end
           evaluated.concat(unevaluated)
@@ -618,12 +649,14 @@ module Schemurai
         limit(schema, "minProperties", value.length) { |actual, expected| actual >= expected }
 
         Array(schema["required"]).each do |name|
+          @budget&.checkpoint
           add_error("required") { ErrorMessage.required(name) } unless value.key?(name)
         end
 
         properties = schema.fetch("properties", {})
         patterns = schema.fetch("patternProperties", {})
         value.each do |name, property_value|
+          @budget&.checkpoint
           matched = false
           if properties.key?(name)
             matched = true
@@ -631,6 +664,7 @@ module Schemurai
             evaluated << name
           end
           patterns.each do |pattern, subschema|
+            @budget&.checkpoint
             next unless ecma_regexp(pattern).match?(name)
             matched = true
             evaluate_at(node.child("patternProperties", pattern), property_value, name, "patternProperties", pattern)
@@ -644,14 +678,17 @@ module Schemurai
 
         if schema.key?("propertyNames")
           value.each_key do |name|
+            @budget&.checkpoint
             evaluate_at(node.child("propertyNames"), name, name, "propertyNames")
           end
         end
 
         schema.fetch("dependencies", {}).each do |name, dependency|
+          @budget&.checkpoint
           next unless value.key?(name)
           if dependency.is_a?(Array)
             dependency.each do |required_name|
+              @budget&.checkpoint
               add_error("dependencies") { ErrorMessage.dependent_required(name, required_name) } unless value.key?(required_name)
             end
           else
@@ -661,8 +698,10 @@ module Schemurai
         end
 
         schema.fetch("dependentRequired", {}).each do |name, required_names|
+          @budget&.checkpoint
           next unless value.key?(name)
           required_names.each do |required_name|
+            @budget&.checkpoint
             unless value.key?(required_name)
               add_error("dependentRequired") { ErrorMessage.dependent_required(name, required_name) }
             end
@@ -670,6 +709,7 @@ module Schemurai
         end
 
         schema.fetch("dependentSchemas", {}).each_key do |name|
+          @budget&.checkpoint
           next unless value.key?(name)
           result = evaluate_at(node.child("dependentSchemas", name), value, MISSING_SEGMENT, "dependentSchemas", name)
           evaluated.concat(result.evaluated_properties) if result.valid?
@@ -679,6 +719,7 @@ module Schemurai
         if schema.key?("unevaluatedProperties")
           unevaluated = value.keys - combined
           unevaluated.each do |name|
+            @budget&.checkpoint
             evaluate_at(node.child("unevaluatedProperties"), value[name], name, "unevaluatedProperties")
           end
           evaluated.concat(unevaluated)
@@ -757,6 +798,7 @@ module Schemurai
         escaped = false
         in_class = false
         pattern.each_char do |character|
+          @budget&.checkpoint
           if escaped
             translated << case character
             when "d" then in_class ? "0-9" : "[0-9]"

data/lib/schemurai/limit_budget.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    # Mutable state owned by one validation call, including native/VM fallback.
+    class LimitBudget
+      CHECK_INTERVAL = 256
+
+      def self.validate_options!(max_errors, timeout)
+        valid_errors = max_errors.nil? || (max_errors.is_a?(Integer) && max_errors >= 0)
+        unless valid_errors
+          raise ArgumentError, "max_errors must be a nonnegative Integer or nil"
+        end
+        valid_timeout = timeout.nil? || ((timeout.is_a?(Integer) || timeout.is_a?(Float)) && timeout >= 0 && timeout.to_f.finite?)
+        unless valid_timeout
+          raise ArgumentError, "timeout must be finite nonnegative seconds or nil"
+        end
+      end
+
+      def initialize(max_errors: nil, timeout: nil)
+        @max_errors = max_errors
+        @timeout = timeout
+        @errors = 0
+        @checks = 0
+        if timeout
+          @started = monotonic_time
+          @deadline = @started + timeout
+          check_deadline!
+        end
+      end
+
+      # Synchronous polling only; never inject exceptions into another thread.
+      def checkpoint
+        return unless @deadline
+
+        @checks += 1
+        check_deadline! if (@checks % CHECK_INTERVAL).zero?
+      end
+
+      def check_deadline!
+        return unless @deadline
+
+        now = monotonic_time
+        raise LimitExceeded.new(:timeout, @timeout, now - @started) if now >= @deadline
+      end
+
+      # Ruby retains the original deadline through native execution and fallback.
+      def native_duration
+        check_deadline!
+        @deadline && [@deadline - monotonic_time, 0.0].max
+      end
+
+      def native_max_errors
+        @max_errors && [@max_errors, (1 << (0.size * 8)) - 1].min
+      end
+
+      def raise_native_limit(kind, attempted)
+        if kind == 2
+          raise LimitExceeded.new(:timeout, @timeout, monotonic_time - @started)
+        end
+        raise LimitExceeded.new(:max_errors, @max_errors, attempted)
+      end
+
+      # Check before constructing the next message and JSON Pointers.
+      def reserve_error
+        checkpoint
+        attempted = @errors + 1
+        raise LimitExceeded.new(:max_errors, @max_errors, attempted) if @max_errors && attempted > @max_errors
+
+        @errors = attempted
+      end
+
+      private def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/schemurai/limit_exceeded.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Schemurai
+  # Raised when validation cannot finish within an application-supplied limit.
+  # This is an incomplete evaluation, not a JSON Schema validation failure.
+  class LimitExceeded < Error
+    # Limit name, configured maximum and attempted count (or elapsed seconds).
+    attr_reader :limit, :maximum, :attempted
+
+    # Creates an interruption error without embedding the input or partial errors.
+    def initialize(limit, maximum, attempted)
+      @limit = limit
+      @maximum = maximum
+      @attempted = attempted
+      super("validation exceeded #{limit} (maximum #{maximum}, attempted #{attempted})")
+    end
+  end
+end

data/lib/schemurai/limited_evaluator.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "limit_exceeded"
+require_relative "limit_budget"
+require_relative "evaluator"
+
+module Schemurai
+  module Internal
+    # Ruby evaluation with invocation-local limits.
+    class LimitedEvaluator < Evaluator
+      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
+        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        errors = []
+        each_error(instance) do |error|
+          errors << error
+        end
+        @budget.check_deadline!
+        Result.new(errors)
+      ensure
+        @budget = nil
+      end
+
+      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
+        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        result = super(instance)
+        @budget.check_deadline!
+        result
+      ensure
+        @budget = nil
+      end
+
+      private def evaluate(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def evaluate_valid(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def add_error(keyword, message = nil, append_keyword: true, &block)
+        @budget.reserve_error if @error_callback
+        super
+      end
+
+      private def valid_string?(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_string(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def decimal(value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def ecma_regexp(pattern)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def valid_content?(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_content(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def json_equal?(left, right)
+        @budget.checkpoint
+        super
+      end
+
+      private def json_fingerprint(value)
+        @budget.checkpoint
+        super
+      end
+    end
+  end
+end

data/lib/schemurai/native/evaluator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../vm/evaluator"
+require_relative "../vm/limited_evaluator"
 require "schemurai_native"
 require_relative "diagnostics"
 
@@ -9,22 +9,49 @@ module Schemurai
     class Evaluator
       def backend = :native
 
-      def initialize(graph, compiler, root, content: false, format: false)
-        @program = Program.new(root, compiler, format, content)
+      def initialize(graph, compiler, root, content: false, format: false, compiled: nil)
+        @graph = graph
+        @compiler = compiler
+        @root = root
+        @content = content
+        @format = format
+        @compiled = compiled || Program.new(root, compiler, format, content)
+        @program = @compiled.runner(root)
         @vm = VM::Evaluator.new(graph, compiler, root, content: content, format: format)
       end
 
-      def valid?(instance)
+      def valid?(instance, max_errors: nil, timeout: nil)
+        if !max_errors.nil? || !timeout.nil?
+          budget = Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+          result = @program.valid_with_budget(instance, budget)
+          budget.check_deadline!
+          return result.nil? ? limited_vm.valid?(instance, budget: budget) : result
+        end
         result = @program.valid?(instance)
         result.nil? ? @vm.valid?(instance) : result
       end
 
-      def validate(instance)
+      def validate(instance, max_errors: nil, timeout: nil)
+        if !max_errors.nil? || !timeout.nil?
+          budget = Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
+          rows = @program.diagnostics_with_budget(instance, budget)
+          return limited_vm.validate(instance, budget: budget) if rows.nil?
+
+          errors = rows.map do |row|
+            budget.reserve_error
+            Diagnostics.error(row)
+          end
+          budget.check_deadline!
+          return Result.new(errors)
+        end
         rows = @program.diagnostics(instance)
         return @vm.validate(instance) if rows.nil?
 
         Result.new(rows.empty? ? rows : rows.map { |row| Diagnostics.error(row) })
       end
+      private def limited_vm
+        VM::LimitedEvaluator.new(@graph, @compiler, @root, content: @content, format: @format)
+      end
     end
   end
 

data/lib/schemurai/schema_domain.rb

@@ -8,7 +8,7 @@ module Schemurai
           invalid!(label, "must be a boolean or an object")
         end
 
-        validate_value!(schema, label, [], {})
+        validate_value!(schema, label, [], {}, {})
         schema
       end
 
@@ -23,7 +23,7 @@ module Schemurai
         schemas
       end
 
-      module_function def validate_value!(value, label, path, ancestors)
+      module_function def validate_value!(value, label, path, ancestors, completed)
         case value
         when nil, true, false
           nil
@@ -34,21 +34,21 @@ module Schemurai
           invalid_at!(label, path, "uses a Float subclass") unless value.instance_of?(Float)
         when Array
           invalid_at!(label, path, "uses an Array subclass") unless value.instance_of?(Array)
-          descend!(value, label, path, ancestors) do
+          descend!(value, label, path, ancestors, completed) do
             value.each_with_index do |item, index|
               path << index
-              validate_value!(item, label, path, ancestors)
+              validate_value!(item, label, path, ancestors, completed)
               path.pop
             end
           end
         when Hash
           invalid_at!(label, path, "uses a Hash subclass") unless value.instance_of?(Hash)
-          descend!(value, label, path, ancestors) do
+          descend!(value, label, path, ancestors, completed) do
             value.each do |key, item|
               invalid_at!(label, path, "contains a non-string object key") unless key.instance_of?(String)
 
               path << key
-              validate_value!(item, label, path, ancestors)
+              validate_value!(item, label, path, ancestors, completed)
               path.pop
             end
           end
@@ -63,11 +63,16 @@ module Schemurai
       end
       private_class_method :supported_exact_scalar?
 
-      module_function def descend!(value, label, path, ancestors)
+      module_function def descend!(value, label, path, ancestors, completed)
+        # A completed subtree cannot contain a cycle back to this path. Only
+        # publish after the entire subtree passes, preserving first-error paths.
+        return if completed.key?(value.object_id)
+
         invalid_at!(label, path, "contains a recursive container") if ancestors.key?(value.object_id)
 
         ancestors[value.object_id] = true
         yield
+        completed[value.object_id] = true
       ensure
         ancestors.delete(value.object_id)
       end

data/lib/schemurai/schema_graph.rb

@@ -53,8 +53,10 @@ module Schemurai
 
       class Resource
         attr_reader :uri, :root
+        attr_accessor :dynamic_anchor_count
 
         def initialize(uri, root)
+          @dynamic_anchor_count = 0
           @uri = uri
           @root = root
           @nodes = nil
@@ -144,6 +146,12 @@ module Schemurai
         @dynamic_anchors.dig(resource, name)
       end
 
+      # Anchor tables grow in insertion order, including late external indexing.
+      # Native compilation uses this snapshot to avoid absent pair lookups.
+      def dynamic_anchor_names(resource)
+        @dynamic_anchors[resource]&.keys || []
+      end
+
       def dynamic_scope?
         @dynamic_scope
       end
@@ -195,7 +203,8 @@ module Schemurai
           end
         end
         changes.dynamic_anchors.each do |resource, anchors|
-          (@dynamic_anchors[resource] ||= {}).update(anchors)
+          merged = (@dynamic_anchors[resource] ||= {}).update(anchors)
+          resource.dynamic_anchor_count = merged.size
         end
         (@custom_dialects ||= {}).update(changes.custom_dialects) unless changes.custom_dialects.empty?
         @dynamic_scope = true if changes.requires_dynamic_scope

data/lib/schemurai/unique_items.rb

@@ -7,6 +7,7 @@ module Schemurai
         # Avoid building an index for small arrays and early duplicates.
         if values.length <= 16
           values.each_with_index do |item, index|
+            @budget&.checkpoint
             index.times { |previous| return false if json_equal?(values[previous], item) }
           end
           return true
@@ -16,6 +17,7 @@ module Schemurai
         # Store a single index until a collision needs a bucket array.
         index = 0
         while index < values.length
+          @budget&.checkpoint
           item = values[index]
           fingerprint = json_fingerprint(item)
           if (bucket = buckets[fingerprint])

data/lib/schemurai/version.rb

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

data/lib/schemurai/vm/compiler.rb

@@ -391,12 +391,16 @@ module Schemurai
         compiled.freeze unless compiled.empty?
       end
 
-      private def snapshot(value)
+      # Keep aliases inside one operand while copying away from caller-owned
+      # containers. A fresh identity table also rechecks later compilations.
+      private def snapshot(value, copies = {}.compare_by_identity)
+        return copies[value] if copies.key?(value)
+
         case value
         when Hash
-          value.to_h { |key, item| [snapshot(key), snapshot(item)] }.freeze
+          copies[value] = value.to_h { |key, item| [snapshot(key, copies), snapshot(item, copies)] }.freeze
         when Array
-          value.map { |item| snapshot(item) }.freeze
+          copies[value] = value.map { |item| snapshot(item, copies) }.freeze
         when String
           -value
         else