schemurai 3.0.1 → 3.1.0

data/lib/schemurai/evaluation_pool.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "set" # rubocop:disable Lint/RedundantRequireStatement -- Required on Ruby 3.4.
+require_relative "evaluation"
+
+module Schemurai
+  module Internal
+    class EvaluationBuffer
+      attr_reader :evaluated_properties, :evaluated_items
+
+      def initialize
+        # Applicators can overlap. Array membership makes collecting and merging
+        # their annotations quadratic in the number of instance locations.
+        @evaluated_properties = Set.new
+        @evaluated_items = Set.new
+      end
+
+      def valid? = true
+
+      def reset
+        @evaluated_properties.clear
+        @evaluated_items.clear
+        self
+      end
+
+      def record_property(name)
+        @evaluated_properties.add(name)
+        self
+      end
+
+      def record_item(index)
+        @evaluated_items.add(index)
+        self
+      end
+
+      def merge(other)
+        return Evaluation.invalid unless other.valid?
+
+        properties = other.evaluated_properties
+        items = other.evaluated_items
+        @evaluated_properties.merge(properties) unless properties.empty?
+        @evaluated_items.merge(items) unless items.empty?
+        self
+      end
+    end
+
+    class EvaluationPool
+      def initialize
+        @buffers = []
+        @index = 0
+      end
+
+      def reset
+        @index = 0
+      end
+
+      def used? = !@buffers.empty?
+
+      def acquire
+        index = @index
+        @index += 1
+        (@buffers[index] ||= EvaluationBuffer.new).reset
+      end
+    end
+  end
+end

data/lib/schemurai/evaluator.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "decimal"
+require_relative "type_checks"
 require "json"
 require "base64"
 require_relative "evaluation"
 require_relative "error_message"
 require_relative "unique_items"
+require_relative "ecma_regexp"
+require_relative "json_pointer"
 
 module Schemurai
   module Internal
@@ -747,20 +751,11 @@ module Schemurai
       end
 
       private def type?(value, type)
-        case type
-        when "null" then value.nil?
-        when "boolean" then value == true || value == false
-        when "object" then value.is_a?(Hash)
-        when "array" then value.is_a?(Array)
-        when "number" then number?(value)
-        when "integer" then number?(value) && value.finite? && value.to_i == value
-        when "string" then value.is_a?(String)
-        else false
-        end
+        TypeChecks.single?(value, TypeChecks::BITS.fetch(type, 0))
       end
 
       private def number?(value)
-        value.is_a?(Numeric) && !value.is_a?(Complex)
+        TypeChecks.number?(value)
       end
 
       private def json_equal?(left, right)
@@ -784,7 +779,7 @@ module Schemurai
       private def decimal(value)
         return value if value.is_a?(Integer) || value.is_a?(Rational)
 
-        Rational(value.to_s)
+        Internal::Decimal.parse(value)
       end
 
       # Ruby and ECMA-262 differ in their ASCII character classes, anchors, and
@@ -793,41 +788,7 @@ module Schemurai
         regexps = (@regexps ||= {})
         return regexps[pattern] if regexps.key?(pattern)
 
-        whitespace = "\\u0009-\\u000D\\u0020\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF"
-        translated = +""
-        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]"
-            when "D" then in_class ? "^0-9" : "[^0-9]"
-            when "w" then in_class ? "A-Za-z0-9_" : "[A-Za-z0-9_]"
-            when "W" then in_class ? "^A-Za-z0-9_" : "[^A-Za-z0-9_]"
-            when "s" then in_class ? whitespace : "[#{whitespace}]"
-            when "S" then in_class ? "^#{whitespace}" : "[^#{whitespace}]"
-            else "\\#{character}"
-            end
-            escaped = false
-          elsif character == "\\"
-            escaped = true
-          elsif character == "["
-            in_class = true
-            translated << character
-          elsif character == "]"
-            in_class = false
-            translated << character
-          elsif character == "^" && !in_class
-            translated << "\\A"
-          elsif character == "$" && !in_class
-            translated << "\\z"
-          else
-            translated << character
-          end
-        end
-        translated << "\\" if escaped
-        regexps[pattern] = Regexp.new(translated)
+        regexps[pattern] = Internal::EcmaRegexp.compile(pattern, @budget)
       end
 
       private def check_content(schema, value)
@@ -891,7 +852,7 @@ module Schemurai
       end
 
       private def append_pointer_segment(pointer, segment)
-        pointer << "/" << segment.to_s.gsub("~", "~0").gsub("/", "~1")
+        pointer << "/" << Internal::JsonPointer.escape(segment)
       end
 
       private_constant :MISSING_SEGMENT

data/lib/schemurai/json_pointer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module JsonPointer
+      module_function def escape(segment)
+        segment.to_s.gsub("~", "~0").gsub("/", "~1")
+      end
+    end
+  end
+end

data/lib/schemurai/limited_evaluator.rb

@@ -1,63 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "limit_exceeded"
-require_relative "limit_budget"
+require_relative "evaluation_limits"
 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
+      include EvaluationLimits
 
       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
@@ -72,20 +29,6 @@ module Schemurai
         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

data/lib/schemurai/native/diagnostics.rb

@@ -15,9 +15,9 @@ module Schemurai
       private_constant :TYPE_NAMES, :ATTRIBUTES
 
       module_function def error(row)
-        keyword, instance_path, schema_path, opcode, operand, instance, detail = row
+        keyword, instance_path, schema_path, opcode, operand, instance, detail, rendered_message = row
         ValidationError.new(keyword: keyword, instance_path: instance_path, schema_path: schema_path,
-          message: message(keyword, opcode, operand, instance, detail))
+          message: rendered_message || message(keyword, opcode, operand, instance, detail))
       end
 
       module_function def message(keyword, opcode, operand, instance, detail) # rubocop:disable Metrics/MethodLength
@@ -32,7 +32,7 @@ module Schemurai
         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 "pattern" then (detail == 1) ? messages.invalid_pattern(operand.pattern) : 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
@@ -43,6 +43,7 @@ module Schemurai
         when "anyOf" then messages.any_of
         when "oneOf" then messages.one_of(detail)
         when "not" then messages.not
+        when "$ref", "$recursiveRef", "$dynamicRef" then operand
         else raise "unknown native diagnostic #{keyword.inspect}"
         end
       end

data/lib/schemurai/native/evaluator.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "../vm/limited_evaluator"
+require_relative "../decimal"
+require_relative "../number_checks"
+require_relative "../string_checks"
+require_relative "../value_equality"
+require_relative "../container_checks"
+require_relative "../type_checks"
+require_relative "../vm/compiler"
+require_relative "../evaluation_pool"
+require_relative "../limit_budget"
+require_relative "../ecma_regexp"
+require_relative "../json_pointer"
 require "schemurai_native"
 require_relative "diagnostics"
+require_relative "null_numeric"
 
 module Schemurai
   module Native
@@ -15,29 +26,37 @@ module Schemurai
         @root = root
         @content = content
         @format = format
+        @graph_size = @graph.nodes.length
         @compiled = compiled || Program.new(root, compiler, format, content)
+        @number_state = Internal::NumberChecks::State.new
+        @regexps = {}
+        @scope_state = []
+        @report_state = [nil, Internal::EvaluationPool.new]
+        @reference_state = []
+        @active_state = {}.compare_by_identity
         @program = @compiled.runner(root)
-        @vm = VM::Evaluator.new(graph, compiler, root, content: content, format: format)
+        @program.share_scalar_state(@number_state, @regexps, @scope_state, @reference_state, @active_state, @report_state)
+        @unresolved = @compiled.unresolved_references?
       end
 
       def valid?(instance, max_errors: nil, timeout: nil)
+        refresh_unresolved
         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
+          return result
         end
-        result = @program.valid?(instance)
-        result.nil? ? @vm.valid?(instance) : result
+        @program.valid?(instance)
       end
 
       def validate(instance, max_errors: nil, timeout: nil)
+        refresh_unresolved
         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|
+          errors = (rows == false) ? nil : rows.map do |row|
             budget.reserve_error
             Diagnostics.error(row)
           end
@@ -45,12 +64,21 @@ module Schemurai
           return Result.new(errors)
         end
         rows = @program.diagnostics(instance)
-        return @vm.validate(instance) if rows.nil?
+
+        return Result.new(nil) if rows == false
 
         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)
+      private def refresh_unresolved
+        while @unresolved && @graph_size != @graph.nodes.length
+          graph_size = @graph.nodes.length
+          compiled = Program.new(@root, @compiler, @format, @content)
+          @program = compiled.runner(@root)
+          @program.share_scalar_state(@number_state, @regexps, @scope_state, @reference_state, @active_state, @report_state)
+          @compiled = compiled
+          @unresolved = @compiled.unresolved_references?
+          @graph_size = graph_size
+        end
       end
     end
   end

data/lib/schemurai/native/null_numeric.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Native
+    # Native traversal selects one reached assertion and its comparison mode.
+    # Ruby dispatch preserves the exception and method visibility for nil.
+    module NullNumeric
+      module_function def valid?(value, bit, decimal)
+        actual = if decimal && !value.is_a?(Integer) && !value.is_a?(Rational)
+          Internal::Decimal.parse(value)
+        else
+          value
+        end
+        case bit
+        when Protocol::MAXIMUM, Protocol::MINIMUM, Protocol::EXCLUSIVE_MAXIMUM, Protocol::EXCLUSIVE_MINIMUM
+          Internal::NumberChecks.bound?(actual, bit, nil)
+        when Protocol::MULTIPLE_OF then nil.positive? && actual.remainder(nil).zero?
+        else raise "unknown null numeric assertion"
+        end
+      end
+    end
+  end
+end

data/lib/schemurai/number_checks.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "decimal"
+require_relative "type_checks"
+
+module Schemurai
+  module Internal
+    module NumberChecks
+      MAXIMUM = 1 << 0
+      MINIMUM = 1 << 1
+      EXCLUSIVE_MAXIMUM = 1 << 2
+      EXCLUSIVE_MINIMUM = 1 << 3
+      MULTIPLE_OF = 1 << 4
+
+      class State
+        CACHE_LIMIT = 16
+        private_constant :CACHE_LIMIT
+
+        attr_writer :budget
+
+        def decimal(value)
+          @budget&.check_deadline!
+          result = cached_decimal(value)
+          @budget&.check_deadline!
+          result
+        end
+
+        private def cached_decimal(value)
+          return value if value.is_a?(Integer) || value.is_a?(Rational)
+
+          decimals = (@decimals ||= {})
+          return decimals[value] if decimals.key?(value)
+
+          decimals.clear if decimals.length >= CACHE_LIMIT
+          decimals[value] = Decimal.parse(value)
+        end
+
+        def multiple?(rules, value)
+          results = (@multiple_results ||= {}.compare_by_identity)
+          values = (results[rules] ||= {})
+          return values[value] if values.key?(value)
+
+          values.clear if values.length >= CACHE_LIMIT
+          divisor = rules.multiple_of
+          values[value] = divisor.positive? && decimal(value).remainder(divisor).zero?
+        end
+      end
+
+      module_function def actual(rules, value, state)
+        (rules.mask & MULTIPLE_OF).zero? ? value : state.decimal(value)
+      end
+
+      module_function def bound?(actual, bit, limit)
+        violated = case bit
+        when MAXIMUM then actual > limit
+        when MINIMUM then actual < limit
+        when EXCLUSIVE_MAXIMUM then actual >= limit
+        when EXCLUSIVE_MINIMUM then actual <= limit
+        else raise "unknown numeric bound"
+        end
+        violated ? false : true
+      end
+
+      # Both the VM and native validity frames use the same ordered rules.
+      module Evaluation
+        private def number_state
+          @number_state ||= State.new
+        end
+
+        private def valid_number?(rules, value)
+          mask = rules.mask
+          actual = (mask & MULTIPLE_OF).zero? ? value : number_state.decimal(value)
+          return false if (mask & MAXIMUM) != 0 && actual > rules.maximum
+          return false if (mask & MINIMUM) != 0 && actual < rules.minimum
+          return false if (mask & EXCLUSIVE_MAXIMUM) != 0 && actual >= rules.exclusive_maximum
+          return false if (mask & EXCLUSIVE_MINIMUM) != 0 && actual <= rules.exclusive_minimum
+          return true if (mask & MULTIPLE_OF).zero?
+
+          valid_multiple?(rules, value)
+        end
+
+        private def valid_multiple?(rules, value)
+          number_state.multiple?(rules, value)
+        end
+      end
+
+      # One native numeric instruction owns this frame while Rust yields between
+      # reached assertions. No instance method runs during construction.
+      class Frame
+        include Evaluation
+
+        def initialize(rules, value, state)
+          @rules = rules
+          @value = value
+          @number_state = state
+        end
+
+        def numeric? = TypeChecks.number?(@value)
+        def integral? = TypeChecks.integral?(@value)
+
+        def valid?(required)
+          return required.zero? unless numeric?
+          if required == TypeChecks::INTEGER
+            return false unless integral?
+          end
+
+          valid_number?(@rules, @value)
+        end
+
+        def prepare
+          @actual = NumberChecks.actual(@rules, @value, @number_state)
+          true
+        end
+
+        def check(bit)
+          case bit
+          when MAXIMUM then NumberChecks.bound?(@actual, bit, @rules.maximum)
+          when MINIMUM then NumberChecks.bound?(@actual, bit, @rules.minimum)
+          when EXCLUSIVE_MAXIMUM then NumberChecks.bound?(@actual, bit, @rules.exclusive_maximum)
+          when EXCLUSIVE_MINIMUM then NumberChecks.bound?(@actual, bit, @rules.exclusive_minimum)
+          when MULTIPLE_OF then @number_state.multiple?(@rules, @value)
+          else raise "unknown numeric assertion"
+          end
+        end
+      end
+    end
+  end
+end