schemurai 3.0.1 → 3.0.2

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/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

data/lib/schemurai/string_checks.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "ipaddr"
+require_relative "ecma_regexp"
+require_relative "error_message"
+
+module Schemurai
+  module Internal
+    module StringChecks
+      module Regexps
+        private def ecma_regexp(pattern)
+          regexps = regexp_cache
+          return regexps[pattern] if regexps.key?(pattern)
+
+          regexps[pattern] = EcmaRegexp.compile(pattern, @budget)
+        end
+
+        private def regexp_cache = (@regexps ||= {})
+      end
+
+      module TimedRegexps
+        private def regexp_budget = @budget
+
+        private def ecma_regexp(pattern)
+          budget = regexp_budget
+          budget.check_deadline!
+          result = super
+          budget.check_deadline!
+          result
+        end
+      end
+
+      module Evaluation
+        private def valid_string?(rules, value)
+          length = value.length
+          return false if rules.max_length && length > rules.max_length
+          return false if rules.min_length && length < rules.min_length
+          return false if rules.pattern && !ecma_regexp(rules.pattern).match?(value)
+          if rules.format && (@validate_format || rules.format_assertion)
+            return false unless rules.format.call(value)
+          end
+          if @validate_content && (rules.decode_base64 || rules.parse_json)
+            return valid_content?(rules, value)
+          end
+
+          true
+        rescue RegexpError, IPAddr::InvalidAddressError
+          false
+        end
+
+        private def valid_content?(rules, value)
+          decoded = rules.decode_base64 ? Base64.strict_decode64(value) : value
+          JSON.parse(decoded) if rules.parse_json
+          true
+        rescue ArgumentError, JSON::ParserError
+          false
+        end
+      end
+
+      class State
+        include Regexps
+
+        attr_reader :budget
+
+        def ecma_regexp(pattern)
+          @budget&.check_deadline!
+          result = super
+          @budget&.check_deadline!
+          result
+        end
+
+        def initialize(regexps, budget)
+          @regexps = regexps
+          @budget = budget
+        end
+      end
+
+      # Rust owns traversal and error limits; this frame retains arbitrary Ruby
+      # length results and the VM's rescue state between reached assertions.
+      class Frame
+        include Evaluation
+
+        def initialize(rules, value, state, flags)
+          @rules = rules
+          @value = value
+          @state = state
+          @budget = state.budget
+          @validate_format = (flags & 1) != 0
+          @validate_content = (flags & 2) != 0
+          @required = (flags & 64) != 0
+          @invalid_pattern = false
+        end
+
+        def string? = @value.is_a?(String)
+        def invalid_pattern? = @invalid_pattern
+
+        def valid?
+          return !@required unless string?
+
+          valid_string?(@rules, @value)
+        end
+
+        def prepare
+          @budget&.check_deadline!
+          check(2)
+        end
+
+        def check(step)
+          case step
+          when 2
+            @length = @value.length
+            true
+          when 3
+            exceeded = @length > @rules.max_length
+            exceeded ? false : true
+          when 4
+            below = @length < @rules.min_length
+            below ? false : true
+          when 5 then (!ecma_regexp(@rules.pattern).match?(@value)) ? false : true
+          when 6 then (!@rules.format.call(@value)) ? false : true
+          when 7 then valid_content?(@rules, @value)
+          else raise "unknown string assertion"
+          end
+        rescue RegexpError
+          @invalid_pattern = true
+          false
+        end
+
+        def message(keyword, rescued)
+          return ErrorMessage.invalid_pattern(@rules.pattern) if rescued
+
+          case keyword
+          when "type" then ErrorMessage.type("string", @value)
+          when "maxLength" then ErrorMessage.size(keyword, @rules.max_length, @length)
+          when "minLength" then ErrorMessage.size(keyword, @rules.min_length, @length)
+          when "pattern" then @invalid_pattern ? ErrorMessage.invalid_pattern(@rules.pattern) : ErrorMessage.pattern(@rules.pattern)
+          when "format" then ErrorMessage.format(@rules.format.name)
+          when "contentEncoding" then ErrorMessage.content_encoding
+          when "contentMediaType" then ErrorMessage.content_media_type
+          else raise "unknown string diagnostic"
+          end
+        end
+
+        private def valid_string?(rules, value)
+          @budget&.check_deadline!
+          result = super
+          @budget&.check_deadline!
+          result
+        end
+
+        private def valid_content?(rules, value)
+          @budget&.check_deadline!
+          result = super
+          @budget&.check_deadline!
+          result
+        end
+
+        private def ecma_regexp(pattern)
+          @state.ecma_regexp(pattern)
+        end
+      end
+    end
+  end
+end

data/lib/schemurai/type_checks.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module TypeChecks
+      NULL = 1 << 0
+      BOOLEAN = 1 << 1
+      OBJECT = 1 << 2
+      ARRAY = 1 << 3
+      NUMBER = 1 << 4
+      INTEGER = 1 << 5
+      STRING = 1 << 6
+      BITS = {"null" => NULL, "boolean" => BOOLEAN, "object" => OBJECT, "array" => ARRAY,
+              "number" => NUMBER, "integer" => INTEGER, "string" => STRING}.freeze
+
+      module_function def number?(value)
+        value.is_a?(Numeric) && !value.is_a?(Complex)
+      end
+
+      module_function def integer?(value)
+        number?(value) && integral?(value)
+      end
+
+      module_function def integral?(value)
+        value.finite? && value.to_i == value
+      end
+
+      module_function def single?(value, mask)
+        case mask
+        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 integer?(value)
+        when STRING then value.is_a?(String)
+        else false
+        end
+      end
+
+      # The VM's union opcode classifies in this order, even for a one-name union.
+      module_function def instance_mask(value, integer:)
+        return NULL if value.nil?
+        return BOOLEAN if value == true || value == false
+        return OBJECT if value.is_a?(Hash)
+        return ARRAY if value.is_a?(Array)
+        return STRING if value.is_a?(String)
+        return 0 unless number?(value)
+        return NUMBER unless integer
+
+        integral?(value) ? NUMBER | INTEGER : NUMBER
+      end
+
+      module_function def valid?(value, mask, union)
+        union ? (mask & instance_mask(value, integer: (mask & INTEGER) != 0)) != 0 : single?(value, mask)
+      end
+    end
+  end
+end

data/lib/schemurai/value_equality.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "unique_items"
+
+module Schemurai
+  module Internal
+    # Ruby method order for VM/native value comparisons. This traverses values,
+    # not schema instructions, and retains custom collection/equality methods.
+    module ValueEquality
+      private def json_equal?(left, right)
+        if left.is_a?(Numeric) && !left.is_a?(Complex)
+          return right.is_a?(Numeric) && !right.is_a?(Complex) && left == right
+        end
+        return false unless left.instance_of?(right.class)
+
+        case left
+        when Hash
+          left.length == right.length && left.all? do |key, value|
+            @budget&.checkpoint
+            right.key?(key) && json_equal?(value, right[key])
+          end
+        when Array
+          return false unless left.length == right.length
+
+          index = 0
+          while index < left.length
+            @budget&.checkpoint
+            return false unless json_equal?(left[index], right[index])
+            index += 1
+          end
+          true
+        else
+          left == right
+        end
+      end
+
+      module Checkpoints
+        private def json_equal?(left, right)
+          @budget.checkpoint
+          super
+        end
+
+        private def json_fingerprint(value)
+          @budget.checkpoint
+          super
+        end
+      end
+
+      class Runtime
+        include ValueEquality
+        include UniqueItems
+
+        def initialize(budget)
+          @budget = budget
+        end
+
+        def evaluate(operation, operand, instance)
+          case operation
+          when 0 then json_equal?(operand, instance)
+          when 1 then operand.any? { |candidate| json_equal?(candidate, instance) }
+          when 2 then unique_items?(instance)
+          else raise "unknown equality operation"
+          end
+        end
+      end
+
+      class LimitedRuntime < Runtime
+        include Checkpoints
+      end
+    end
+  end
+end

data/lib/schemurai/version.rb

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