schemurai 3.1.0-aarch64-linux-gnu

data/lib/schemurai/dialect.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    class Dialect
+      TYPE = 1
+      ENUM = 2
+      COMBINER = 4
+      NUMBER = 8
+      STRING = 16
+      ARRAY = 32
+      OBJECT = 64
+
+      Keyword = Data.define(:mask, :subschema_shape) do
+        def initialize(mask:, subschema_shape: nil)
+          super
+        end
+      end
+
+      class << self
+        def register(dialect, default: false)
+          registry[normalize_uri(dialect.uri)] = dialect
+          @default = dialect if default
+          dialect
+        end
+
+        def resolve(uri = nil)
+          return @default if uri.nil?
+
+          registry[normalize_uri(uri)]
+        end
+
+        private def registry
+          @registry ||= {}
+        end
+
+        private def normalize_uri(uri)
+          uri.to_s.delete_suffix("#")
+        end
+      end
+
+      attr_reader :name, :uri, :keywords
+
+      def initialize(name:, uri:, keywords:, ref_siblings:, format_assertion: false)
+        @name = name
+        @uri = uri
+        @keywords = keywords.freeze
+        @ref_siblings = ref_siblings
+        @format_assertion = format_assertion
+        freeze
+      end
+
+      def ref_siblings?
+        @ref_siblings
+      end
+
+      def format_assertion?
+        @format_assertion
+      end
+
+      def keyword_mask(schema)
+        schema.each_key.reduce(0) do |mask, keyword|
+          mask | (keywords[keyword]&.mask || 0)
+        end
+      end
+
+      def each_subschema(schema)
+        return enum_for(__method__, schema) unless block_given?
+        return unless schema.is_a?(Hash)
+        return if schema.key?("$ref") && !ref_siblings?
+
+        schema.each do |keyword, value|
+          specification = keywords[keyword]
+          next unless specification&.subschema_shape
+
+          case specification.subschema_shape
+          when :single
+            yield value, [keyword] if schema?(value)
+          when :single_or_list
+            if value.is_a?(Array)
+              value.each_with_index { |child, index| yield child, [keyword, index] if schema?(child) }
+            elsif schema?(value)
+              yield value, [keyword]
+            end
+          when :list
+            Array(value).each_with_index { |child, index| yield child, [keyword, index] if schema?(child) }
+          when :map
+            value.each { |name, child| yield child, [keyword, name] if schema?(child) } if value.is_a?(Hash)
+          when :dependencies
+            if value.is_a?(Hash)
+              value.each do |name, child|
+                yield child, [keyword, name] if schema?(child)
+              end
+            end
+          end
+        end
+      end
+
+      private def schema?(value)
+        value == true || value == false || value.is_a?(Hash)
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/dialect_keywords.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "dialect"
+
+module Schemurai
+  module Internal
+    module DialectKeywords
+      COMMON = {
+        "type" => Dialect::Keyword.new(mask: Dialect::TYPE),
+        "enum" => Dialect::Keyword.new(mask: Dialect::ENUM),
+        "const" => Dialect::Keyword.new(mask: Dialect::ENUM),
+        "allOf" => Dialect::Keyword.new(mask: Dialect::COMBINER, subschema_shape: :list),
+        "anyOf" => Dialect::Keyword.new(mask: Dialect::COMBINER, subschema_shape: :list),
+        "oneOf" => Dialect::Keyword.new(mask: Dialect::COMBINER, subschema_shape: :list),
+        "not" => Dialect::Keyword.new(mask: Dialect::COMBINER, subschema_shape: :single),
+        "if" => Dialect::Keyword.new(mask: Dialect::COMBINER, subschema_shape: :single),
+        "then" => Dialect::Keyword.new(mask: 0, subschema_shape: :single),
+        "else" => Dialect::Keyword.new(mask: 0, subschema_shape: :single),
+        "maximum" => Dialect::Keyword.new(mask: Dialect::NUMBER),
+        "minimum" => Dialect::Keyword.new(mask: Dialect::NUMBER),
+        "exclusiveMaximum" => Dialect::Keyword.new(mask: Dialect::NUMBER),
+        "exclusiveMinimum" => Dialect::Keyword.new(mask: Dialect::NUMBER),
+        "multipleOf" => Dialect::Keyword.new(mask: Dialect::NUMBER),
+        "maxLength" => Dialect::Keyword.new(mask: Dialect::STRING),
+        "minLength" => Dialect::Keyword.new(mask: Dialect::STRING),
+        "pattern" => Dialect::Keyword.new(mask: Dialect::STRING),
+        "contentEncoding" => Dialect::Keyword.new(mask: Dialect::STRING),
+        "contentMediaType" => Dialect::Keyword.new(mask: Dialect::STRING),
+        "maxItems" => Dialect::Keyword.new(mask: Dialect::ARRAY),
+        "minItems" => Dialect::Keyword.new(mask: Dialect::ARRAY),
+        "uniqueItems" => Dialect::Keyword.new(mask: Dialect::ARRAY),
+        "contains" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single),
+        "maxProperties" => Dialect::Keyword.new(mask: Dialect::OBJECT),
+        "minProperties" => Dialect::Keyword.new(mask: Dialect::OBJECT),
+        "required" => Dialect::Keyword.new(mask: Dialect::OBJECT),
+        "properties" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :map),
+        "patternProperties" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :map),
+        "additionalProperties" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :single),
+        "propertyNames" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :single)
+      }.freeze
+
+      LEGACY = {
+        "dependencies" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :dependencies),
+        "definitions" => Dialect::Keyword.new(mask: 0, subschema_shape: :map)
+      }.freeze
+
+      MODERN = {
+        "$defs" => Dialect::Keyword.new(mask: 0, subschema_shape: :map),
+        "$recursiveRef" => Dialect::Keyword.new(mask: Dialect::COMBINER),
+        "dependentSchemas" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :map),
+        "dependentRequired" => Dialect::Keyword.new(mask: Dialect::OBJECT),
+        "minContains" => Dialect::Keyword.new(mask: Dialect::ARRAY),
+        "maxContains" => Dialect::Keyword.new(mask: Dialect::ARRAY),
+        "unevaluatedItems" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single),
+        "unevaluatedProperties" => Dialect::Keyword.new(mask: Dialect::OBJECT, subschema_shape: :single),
+        "contentSchema" => Dialect::Keyword.new(mask: Dialect::STRING, subschema_shape: :single)
+      }.freeze
+
+      private_constant :COMMON, :LEGACY, :MODERN
+
+      module_function def draft7
+        COMMON.merge(
+          LEGACY,
+          "items" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single_or_list),
+          "additionalItems" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single)
+        ).freeze
+      end
+
+      module_function def draft2019_09
+        COMMON.merge(
+          LEGACY,
+          MODERN,
+          "items" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single_or_list),
+          "additionalItems" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single)
+        ).freeze
+      end
+
+      module_function def draft2020_12
+        COMMON.merge(
+          LEGACY,
+          MODERN,
+          "$dynamicRef" => Dialect::Keyword.new(mask: Dialect::COMBINER),
+          "prefixItems" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :list),
+          "items" => Dialect::Keyword.new(mask: Dialect::ARRAY, subschema_shape: :single)
+        ).freeze
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/dialects/draft2019_09.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../dialect_keywords"
+
+module Schemurai
+  module Internal
+    module Dialects
+      module Draft201909
+        META_SCHEMA_URI = "https://json-schema.org/draft/2019-09/schema"
+        KEYWORDS = DialectKeywords.draft2019_09
+
+        DIALECT = Dialect.new(
+          name: :draft2019_09,
+          uri: META_SCHEMA_URI,
+          keywords: KEYWORDS,
+          ref_siblings: true
+        )
+
+        Dialect.register(DIALECT)
+
+        private_constant :META_SCHEMA_URI, :KEYWORDS
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/dialects/draft2020_12.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../dialect_keywords"
+
+module Schemurai
+  module Internal
+    module Dialects
+      module Draft202012
+        META_SCHEMA_URI = "https://json-schema.org/draft/2020-12/schema"
+        KEYWORDS = DialectKeywords.draft2020_12
+
+        DIALECT = Dialect.new(
+          name: :draft2020_12,
+          uri: META_SCHEMA_URI,
+          keywords: KEYWORDS,
+          ref_siblings: true
+        )
+
+        Dialect.register(DIALECT)
+
+        private_constant :META_SCHEMA_URI, :KEYWORDS
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/dialects/draft7.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../dialect_keywords"
+
+module Schemurai
+  module Internal
+    module Dialects
+      module Draft7
+        META_SCHEMA_URI = "http://json-schema.org/draft-07/schema"
+        KEYWORDS = DialectKeywords.draft7
+
+        DIALECT = Dialect.new(
+          name: :draft7,
+          uri: META_SCHEMA_URI,
+          keywords: KEYWORDS,
+          ref_siblings: false
+        )
+
+        Dialect.register(DIALECT, default: true)
+
+        private_constant :META_SCHEMA_URI, :KEYWORDS
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/ecma_regexp.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    # Shared ECMA character classes and absolute anchors for Ruby's Regexp.
+    module EcmaRegexp
+      module_function def compile(pattern, budget = nil)
+        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
+        Regexp.new(translated)
+      end
+    end
+  end
+end

data/lib/schemurai/error_message.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    # Builds validation messages shared by every evaluator backend.
+    module ErrorMessage
+      module_function def false_schema = "value is not allowed by this schema"
+
+      module_function def type(expected, value)
+        expected = Array(expected).map { |name| name.inspect }.join(" or ")
+        "value has type #{json_type(value).inspect}, but must have type #{expected}"
+      end
+
+      module_function def enum = "value must equal one of the values defined by `enum`"
+      module_function def const = "value must equal the value defined by `const`"
+
+      module_function def numeric_limit(keyword, limit)
+        comparison = {
+          "maximum" => "less than or equal to",
+          "minimum" => "greater than or equal to",
+          "exclusiveMaximum" => "less than",
+          "exclusiveMinimum" => "greater than"
+        }.fetch(keyword)
+        "number must be #{comparison} #{display_number(limit)}"
+      end
+
+      module_function def multiple_of(divisor) = "number must be a multiple of #{display_number(divisor)}"
+
+      module_function def size(keyword, limit, actual)
+        subject, unit, comparison = {
+          "maxLength" => ["string", "characters", "at most"],
+          "minLength" => ["string", "characters", "at least"],
+          "maxItems" => ["array", "items", "at most"],
+          "minItems" => ["array", "items", "at least"],
+          "maxProperties" => ["object", "properties", "at most"],
+          "minProperties" => ["object", "properties", "at least"]
+        }.fetch(keyword)
+        unit = {"characters" => "character", "items" => "item", "properties" => "property"}.fetch(unit) if limit == 1
+        "#{subject} must contain #{comparison} #{limit} #{unit} (found #{actual})"
+      end
+
+      module_function def pattern(pattern) = "string must match pattern #{pattern.inspect}"
+      module_function def invalid_pattern(pattern) = "schema pattern #{pattern.inspect} is not a valid regular expression"
+      module_function def format(name) = "string must match the #{name} format"
+      module_function def content_encoding = "string must be valid base64"
+      module_function def content_media_type = "string must contain valid JSON"
+      module_function def unique_items = "array items must be unique"
+
+      module_function def contains(actual, minimum, maximum)
+        expected = if maximum.infinite?
+          "at least #{minimum}"
+        elsif minimum == maximum
+          "exactly #{minimum}"
+        elsif minimum.zero?
+          "at most #{maximum}"
+        else
+          "between #{minimum} and #{maximum}"
+        end
+        "array must contain #{expected} items matching `contains` (found #{actual})"
+      end
+
+      module_function def required(name) = "object is missing required property #{name.inspect}"
+
+      module_function def dependent_required(name, required_name)
+        "property #{required_name.inspect} is required when property #{name.inspect} is present"
+      end
+
+      module_function def any_of = "value must match at least one subschema"
+      module_function def one_of(matches) = "value must match exactly one subschema (matched #{matches})"
+      module_function def not = "value must not match the subschema"
+
+      module_function def json_type(value)
+        case value
+        when nil then "null"
+        when true, false then "boolean"
+        when Hash then "object"
+        when Array then "array"
+        when String then "string"
+        when Numeric
+          if value.is_a?(Complex)
+            value.class.name
+          elsif value.finite? && value.to_i == value
+            "integer"
+          else
+            "number"
+          end
+        else
+          value.class.name
+        end
+      end
+      private_class_method :json_type
+
+      module_function def display_number(value)
+        rational = value.is_a?(Rational) ? value : Rational(value.to_s)
+        return rational.numerator.to_s if rational.denominator == 1
+
+        rational.to_f.to_s
+      end
+      private_class_method :display_number
+    end
+  end
+end

data/lib/schemurai/evaluation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Schemurai
+  # Internal result of evaluating one schema location. Draft 7 only needs the
+  # validity bit, but newer drafts also propagate the instance locations
+  # consumed by applicators for unevaluatedProperties and unevaluatedItems.
+  class Evaluation
+    EMPTY_LOCATIONS = [].freeze
+
+    attr_reader :evaluated_properties, :evaluated_items
+
+    def self.valid(evaluated_properties: EMPTY_LOCATIONS, evaluated_items: EMPTY_LOCATIONS)
+      if evaluated_properties.equal?(EMPTY_LOCATIONS) && evaluated_items.equal?(EMPTY_LOCATIONS)
+        return @valid ||= new(true, EMPTY_LOCATIONS, EMPTY_LOCATIONS)
+      end
+
+      new(true, evaluated_properties, evaluated_items)
+    end
+
+    def self.invalid
+      @invalid ||= new(false, EMPTY_LOCATIONS, EMPTY_LOCATIONS)
+    end
+
+    def initialize(valid, evaluated_properties, evaluated_items)
+      @valid = valid
+      @evaluated_properties = evaluated_properties.freeze
+      @evaluated_items = evaluated_items.freeze
+      freeze
+    end
+
+    def valid?
+      @valid
+    end
+
+    def merge(other)
+      return self.class.invalid unless valid? && other.valid?
+      return self if other.evaluated_properties.empty? && other.evaluated_items.empty?
+      return other if evaluated_properties.empty? && evaluated_items.empty?
+
+      properties = if evaluated_properties.empty?
+        other.evaluated_properties
+      elsif other.evaluated_properties.empty?
+        evaluated_properties
+      else
+        evaluated_properties | other.evaluated_properties
+      end
+      items = if evaluated_items.empty?
+        other.evaluated_items
+      elsif other.evaluated_items.empty?
+        evaluated_items
+      else
+        evaluated_items | other.evaluated_items
+      end
+
+      self.class.valid(
+        evaluated_properties: properties,
+        evaluated_items: items
+      )
+    end
+  end
+
+  private_constant :Evaluation
+end

data/lib/schemurai/evaluation_limits.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "limit_budget"
+
+module Schemurai
+  module Internal
+    # Limit policy shared by evaluators; error storage and scalar state stay local.
+    module EvaluationLimits
+      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
+        with_budget(max_errors, timeout, budget) { super(instance) }
+      end
+
+      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
+        with_budget(max_errors, timeout, budget) { super(instance) }
+      end
+
+      private def with_budget(max_errors, timeout, budget)
+        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        result = yield
+        @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
+
+      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 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
+    end
+  end
+end

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