schemurai 3.1.0-aarch64-linux-gnu

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/unique_items.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module UniqueItems
+      private def unique_items?(values)
+        # 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
+        end
+
+        buckets = {}
+        # 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])
+            if bucket.is_a?(Integer)
+              return false if json_equal?(values[bucket], item)
+
+              buckets[fingerprint] = [bucket, index]
+            else
+              return false if bucket.any? { |previous| json_equal?(values[previous], item) }
+
+              bucket << index
+            end
+          else
+            buckets[fingerprint] = index
+          end
+          index += 1
+        end
+        true
+      end
+
+      private def json_fingerprint(value)
+        case value
+        when Numeric
+          # JSON numbers compare across Integer/Float. Converting integral
+          # floats to integers also preserves precision for large integers.
+          return value.hash if value.is_a?(Integer)
+
+          number = value.to_f
+          (number.finite? && number == number.to_i) ? number.to_i.hash : number.hash
+        when Array
+          # Mask before multiplication to keep intermediate values immediate
+          # integers; hash each step to retain order without temporary arrays.
+          fingerprint = value.class.hash
+          value.each { |item| fingerprint = (((fingerprint & 0x1fffffff) * 31) ^ json_fingerprint(item)).hash }
+          fingerprint
+        when Hash
+          # Object key order is immaterial. Hash collisions are resolved using
+          # json_equal?, so this fingerprint never decides equality itself.
+          entries = 0
+          value.each_pair { |key, item| entries ^= (((key.hash & 0x1fffffff) * 31) ^ json_fingerprint(item)).hash }
+          (value.class.hash ^ value.length ^ entries).hash
+        else
+          value.hash
+        end
+      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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Schemurai
+  # The installed Schemurai version.
+  VERSION = "3.1.0"
+end