schemurai 3.0.1 → 3.1.0

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.1.0"
 end

data/lib/schemurai/vm/compiler.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../decimal"
+require_relative "../number_checks"
+require_relative "../type_checks"
+
 module Schemurai
   module VM
     NumberRules = Data.define(
@@ -11,21 +15,21 @@ module Schemurai
       :multiple_of
     )
 
-    MAXIMUM = 1 << 0
-    MINIMUM = 1 << 1
-    EXCLUSIVE_MAXIMUM = 1 << 2
-    EXCLUSIVE_MINIMUM = 1 << 3
-    MULTIPLE_OF = 1 << 4
+    MAXIMUM = Internal::NumberChecks::MAXIMUM
+    MINIMUM = Internal::NumberChecks::MINIMUM
+    EXCLUSIVE_MAXIMUM = Internal::NumberChecks::EXCLUSIVE_MAXIMUM
+    EXCLUSIVE_MINIMUM = Internal::NumberChecks::EXCLUSIVE_MINIMUM
+    MULTIPLE_OF = Internal::NumberChecks::MULTIPLE_OF
 
     TypeRules = Data.define(:mask, :names)
 
-    TYPE_NULL = 1 << 0
-    TYPE_BOOLEAN = 1 << 1
-    TYPE_OBJECT = 1 << 2
-    TYPE_ARRAY = 1 << 3
-    TYPE_NUMBER = 1 << 4
-    TYPE_INTEGER = 1 << 5
-    TYPE_STRING = 1 << 6
+    TYPE_NULL = Internal::TypeChecks::NULL
+    TYPE_BOOLEAN = Internal::TypeChecks::BOOLEAN
+    TYPE_OBJECT = Internal::TypeChecks::OBJECT
+    TYPE_ARRAY = Internal::TypeChecks::ARRAY
+    TYPE_NUMBER = Internal::TypeChecks::NUMBER
+    TYPE_INTEGER = Internal::TypeChecks::INTEGER
+    TYPE_STRING = Internal::TypeChecks::STRING
 
     TRACKS_EVALUATION = 1 << 0
     TRACKS_DYNAMIC_SCOPE = 1 << 1
@@ -40,15 +44,7 @@ module Schemurai
     KEYWORD_OBJECT = DIALECT::OBJECT
     private_constant :DIALECT
 
-    TYPE_BITS = {
-      "null" => TYPE_NULL,
-      "boolean" => TYPE_BOOLEAN,
-      "object" => TYPE_OBJECT,
-      "array" => TYPE_ARRAY,
-      "number" => TYPE_NUMBER,
-      "integer" => TYPE_INTEGER,
-      "string" => TYPE_STRING
-    }.freeze
+    TYPE_BITS = Internal::TypeChecks::BITS
 
     TYPE_OPCODES = {
       "null" => :type_null,
@@ -145,10 +141,6 @@ module Schemurai
         freeze
       end
 
-      def tracks_evaluation?
-        @tracks_evaluation
-      end
-
       def recursive_anchor?
         @recursive_anchor
       end
@@ -411,7 +403,7 @@ module Schemurai
       private def compile_decimal(value)
         return value if value.nil? || value.is_a?(Integer) || value.is_a?(Rational)
 
-        Rational(value.to_s)
+        Internal::Decimal.parse(value)
       end
     end
   end