schemurai 3.1.0-aarch64-linux-gnu

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module SchemaDomain
+      module_function def validate!(schema, label: "schema")
+        unless schema.equal?(true) || schema.equal?(false) || schema.instance_of?(Hash)
+          invalid!(label, "must be a boolean or an object")
+        end
+
+        validate_value!(schema, label, [], {}, {})
+        schema
+      end
+
+      module_function def validate_registry!(schemas)
+        invalid!("schemas", "must be an object") unless schemas.instance_of?(Hash)
+
+        schemas.each do |uri, schema|
+          invalid!("schemas", "contains a non-string URI key") unless uri.instance_of?(String)
+
+          validate!(schema, label: "schemas[#{uri.inspect}]")
+        end
+        schemas
+      end
+
+      module_function def validate_value!(value, label, path, ancestors, completed)
+        case value
+        when nil, true, false
+          nil
+        when String, Integer
+          invalid_at!(label, path, "uses a subclass of #{value.class.superclass}") unless supported_exact_scalar?(value)
+        when Float
+          invalid_at!(label, path, "must contain only finite numbers") unless value.finite?
+          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, completed) do
+            value.each_with_index do |item, index|
+              path << index
+              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, 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, completed)
+              path.pop
+            end
+          end
+        else
+          invalid_at!(label, path, "contains unsupported #{value.class}")
+        end
+      end
+      private_class_method :validate_value!
+
+      module_function def supported_exact_scalar?(value)
+        value.instance_of?(String) || value.instance_of?(Integer)
+      end
+      private_class_method :supported_exact_scalar?
+
+      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
+      private_class_method :descend!
+
+      module_function def invalid_at!(label, path, reason)
+        location = path.reduce(label.dup) do |result, segment|
+          result << "/" << segment.to_s.gsub("~", "~0").gsub("/", "~1")
+        end
+        invalid!(location, reason)
+      end
+      private_class_method :invalid_at!
+
+      module_function def invalid!(path, reason)
+        raise Error, "invalid JSON-shaped #{path}: #{reason}"
+      end
+      private_class_method :invalid!
+    end
+  end
+end