schemurai 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2b340649fb4d070d05390ec257487c1f37e45287ef16325f0cfe3e4fb10ae72
-  data.tar.gz: e9e93301abe43e21ff297b66a3d9cb4d43376c8ac2b80ee4e650c1705f5dbc99
+  metadata.gz: 01b0c89354b90232337525b7fe75c063053fecd2965036bb7ff600d2b4e823cb
+  data.tar.gz: f45549ac8cf41eae0c2b28220ca93fe87042cec2aa7c7926382a00f8f65c105d
 SHA512:
-  metadata.gz: a134b68cc4c6a2fc991822d63f841e6bec085a1c33109aca32e75feebd4cd95ca28dad001835591b200515170aa44bbf2c32275a610b2f7acc878d41f8a46bab
-  data.tar.gz: f9fd8b9be4432b61d153be039e39e59b0749ada777e15ebbebf007c69d237d356f5b6feea1c790d8e51201e6bedda0cc26e0c533f499e49062e461f78fa03bd3
+  metadata.gz: 618d494971d7a1745075dae9b9e6155562f9c0f0fb058e923cd457f26bb062be2858db9f2ffaf711d035ee83490179e005869106f3ae29ef0c8011512bed2af9
+  data.tar.gz: 6ecd49a7320b6b936067808a2a0bd07d6e497418427d0e1612d624dd703a71c6eae99f9ae27ab0a94c2946c3a6495fdc2c11bf665b7d59a9fad628f285af0f5e

data/README.md

@@ -1,5 +1,10 @@
 # Schemurai
 
+[![Gem Version](https://badge.fury.io/rb/schemurai.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/schemurai)
+[![test / rspec](https://github.com/oakcask/schemurai/actions/workflows/test--rspec.yaml/badge.svg)](https://github.com/oakcask/schemurai/actions/workflows/test--rspec.yaml)
+[![lint / rubocop](https://github.com/oakcask/schemurai/actions/workflows/lint--rubocop.yaml/badge.svg)](https://github.com/oakcask/schemurai/actions/workflows/lint--rubocop.yaml)
+[![lint / rbs](https://github.com/oakcask/schemurai/actions/workflows/lint--rbs.yaml/badge.svg)](https://github.com/oakcask/schemurai/actions/workflows/lint--rbs.yaml)
+
 A small, light-weight-dependency JSON Schema validator for Ruby supporting Draft 7,
 Draft 2019-09, and Draft 2020-12. It covers the required cases in the official
 JSON-Schema-Test-Suite, as well as the applicable optional tests for numeric
@@ -7,6 +12,8 @@ precision, ECMA-262 regular expressions, content validation, anchors, and dynami
 references. The dialect is selected from the schema's `$schema` URI; schemas that
 omit `$schema` use Draft 7 for compatibility.
 
+Schemurai ships RBS declarations for its public API in `sig/schemurai.rbs`.
+
 ```ruby
 require "schemurai"
 
@@ -116,6 +123,38 @@ validation for `contentEncoding` and `contentMediaType` with `content: true`.
 Enable optional format assertions with `format: true`; support for each format is
 listed separately below.
 
+### Validation errors
+
+```ruby
+result = Schemurai.validate(
+  { "$ref" => "https://example.test/positive" },
+  -1,
+  schemas: { "https://example.test/positive" => { "type" => "integer", "minimum" => 1 } }
+)
+
+validation_error = result.errors[0]
+p validation_error.keyword # => "minimum"
+p validation_error.instance_path # => ""
+p validation_error.schema_path # => "/$ref/minimum"
+p validation_error.message # => "number must be greater than or equal to 1"
+```
+
+`Result#errors` contains `Schemurai::ValidationError` objects.
+Check the following attributes to investigate schema errors:
+
+- `keyword` identifies the failed JSON Schema keyword. Schemurai uses
+  `falseSchema` for a boolean `false` schema, which has no keyword of its own.
+- `instance_path` is a JSON Pointer to the value that failed validation.
+- `schema_path` is a JSON Pointer to the schema location that produced the
+  error.
+- `message` is a human-readable `String` describing the failure.
+
+An empty path points to the instance or schema root. Error order is stable.
+The presence and type of `message` are part of the public API, but its exact
+wording is not. Use `keyword`, `instance_path`, and `schema_path`, rather than
+matching `message`, when handling errors programmatically. `ValidationError#to_h`
+returns these four attributes as a Hash.
+
 ### Thread / Ractor support
 
 To share a registry between threads or Ractors, finish registering schemas and
@@ -248,8 +287,7 @@ ruby script/oracle-cases --summary
 ```
 
 The serialized oracle tools are `script/oracle-runner` and
-`script/oracle-compare`. Ruby interpreter and YJIT baseline instructions are in
-[`benchmark/baselines/README.md`](benchmark/baselines/README.md).
+`script/oracle-compare`.
 
 Run the linter with:
 

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

@@ -34,10 +34,27 @@ module Schemurai
 
     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: (evaluated_properties | other.evaluated_properties),
-        evaluated_items: (evaluated_items | other.evaluated_items)
+        evaluated_properties: properties,
+        evaluated_items: items
       )
     end
   end

data/lib/schemurai/evaluator.rb

@@ -3,6 +3,7 @@
 require "json"
 require "base64"
 require_relative "evaluation"
+require_relative "error_message"
 
 module Schemurai
   module Internal
@@ -333,7 +334,7 @@ module Schemurai
         schema = node.schema
         return Evaluation.valid if schema == true
         if schema == false
-          add_error("falseSchema", "boolean schema is false", append_keyword: false)
+          add_error("falseSchema", append_keyword: false) { ErrorMessage.false_schema }
           return Evaluation.invalid
         end
         return Evaluation.valid unless schema.is_a?(Hash)
@@ -442,15 +443,15 @@ module Schemurai
         types = Array(schema["type"])
         return if types.any? { |type| type?(value, type) }
 
-        add_error("type", "expected #{types.join(" or ")}")
+        add_error("type") { ErrorMessage.type(types, value) }
       end
 
       private def check_enum(schema, value)
         if schema.key?("enum") && !schema["enum"].any? { |candidate| json_equal?(candidate, value) }
-          add_error("enum", "value is not in enum")
+          add_error("enum") { ErrorMessage.enum }
         end
         if schema.key?("const") && !json_equal?(schema["const"], value)
-          add_error("const", "value does not equal const")
+          add_error("const") { ErrorMessage.const }
         end
       end
 
@@ -472,7 +473,7 @@ module Schemurai
             matches << result if result.valid?
           end
           if matches.empty?
-            add_error("anyOf", "no subschema matched")
+            add_error("anyOf") { ErrorMessage.any_of }
           else
             matches.each { |result| evaluation = evaluation.merge(result) }
           end
@@ -487,12 +488,12 @@ module Schemurai
           if matches.length == 1
             evaluation = evaluation.merge(matches.first)
           else
-            add_error("oneOf", "expected exactly one match, got #{matches.length}")
+            add_error("oneOf") { ErrorMessage.one_of(matches.length) }
           end
         end
 
         if schema.key?("not") && trial_at(node.child("not"), value, MISSING_SEGMENT, "not").valid?
-          add_error("not", "subschema matched")
+          add_error("not") { ErrorMessage.not }
         end
 
         if schema.key?("if")
@@ -516,14 +517,14 @@ module Schemurai
 
         divisor = decimal(schema["multipleOf"])
         valid = divisor.positive? && decimal(value).remainder(divisor).zero?
-        add_error("multipleOf", "number is not a multiple") unless valid
+        add_error("multipleOf") { ErrorMessage.multiple_of(schema["multipleOf"]) } unless valid
       end
 
       private def compare(schema, keyword, value)
         return unless schema.key?(keyword)
         return if yield(decimal(value), decimal(schema[keyword]))
 
-        add_error(keyword, "numeric limit was exceeded")
+        add_error(keyword) { ErrorMessage.numeric_limit(keyword, schema[keyword]) }
       end
 
       private def check_string(node, value)
@@ -534,14 +535,14 @@ module Schemurai
 
         if schema.key?("pattern")
           matched = ecma_regexp(schema["pattern"]).match?(value)
-          add_error("pattern", "string does not match pattern") unless matched
+          add_error("pattern") { ErrorMessage.pattern(schema["pattern"]) } unless matched
         end
         if format_asserted?(node)
-          add_error("format", "string is not a valid #{node.format.name}") unless node.format.call(value)
+          add_error("format") { ErrorMessage.format(node.format.name) } unless node.format.call(value)
         end
         check_content(schema, value) if @validate_content
       rescue RegexpError
-        add_error("pattern", "invalid regular expression")
+        add_error("pattern") { ErrorMessage.invalid_pattern(schema["pattern"]) }
       end
 
       private def format_asserted?(node)
@@ -558,7 +559,7 @@ module Schemurai
           duplicate = value.each_with_index.any? do |item, index|
             value[0...index].any? { |previous| json_equal?(previous, item) }
           end
-          add_error("uniqueItems", "array items are not unique") if duplicate
+          add_error("uniqueItems") { ErrorMessage.unique_items } if duplicate
         end
 
         prefix_items = schema["prefixItems"]
@@ -600,7 +601,7 @@ module Schemurai
           minimum = schema.fetch("minContains", 1)
           maximum = schema.fetch("maxContains", Float::INFINITY)
           unless matched.length.between?(minimum, maximum)
-            add_error("contains", "matched #{matched.length} array items")
+            add_error("contains") { ErrorMessage.contains(matched.length, minimum, maximum) }
           end
           evaluated.concat(matched)
         end
@@ -623,7 +624,7 @@ module Schemurai
         limit(schema, "minProperties", value.length) { |actual, expected| actual >= expected }
 
         Array(schema["required"]).each do |name|
-          add_error("required", "required property #{name.inspect} is missing") unless value.key?(name)
+          add_error("required") { ErrorMessage.required(name) } unless value.key?(name)
         end
 
         properties = schema.fetch("properties", {})
@@ -657,7 +658,7 @@ module Schemurai
           next unless value.key?(name)
           if dependency.is_a?(Array)
             dependency.each do |required_name|
-              add_error("dependencies", "property #{required_name.inspect} is required by #{name.inspect}") unless value.key?(required_name)
+              add_error("dependencies") { ErrorMessage.dependent_required(name, required_name) } unless value.key?(required_name)
             end
           else
             result = evaluate_at(node.child("dependencies", name), value, MISSING_SEGMENT, "dependencies", name)
@@ -669,7 +670,7 @@ module Schemurai
           next unless value.key?(name)
           required_names.each do |required_name|
             unless value.key?(required_name)
-              add_error("dependentRequired", "property #{required_name.inspect} is required by #{name.inspect}")
+              add_error("dependentRequired") { ErrorMessage.dependent_required(name, required_name) }
             end
           end
         end
@@ -707,7 +708,7 @@ module Schemurai
         return unless schema.key?(keyword)
         return if yield(actual, schema[keyword])
 
-        add_error(keyword, "size limit was exceeded")
+        add_error(keyword) { ErrorMessage.size(keyword, schema[keyword], actual) }
       end
 
       private def type?(value, type)
@@ -803,10 +804,12 @@ module Schemurai
         JSON.parse(decoded)
       rescue ArgumentError, JSON::ParserError
         keyword = (schema["contentEncoding"] == "base64") ? "contentEncoding" : "contentMediaType"
-        add_error(keyword, "string content is invalid")
+        add_error(keyword) do
+          (keyword == "contentEncoding") ? ErrorMessage.content_encoding : ErrorMessage.content_media_type
+        end
       end
 
-      private def add_error(keyword, message, append_keyword: true)
+      private def add_error(keyword, message = nil, append_keyword: true)
         @error_count += 1
         if @error_callback
           schema_keyword = append_keyword ? keyword : MISSING_SEGMENT
@@ -815,7 +818,7 @@ module Schemurai
               keyword: keyword,
               instance_path: pointer(@instance_path),
               schema_path: pointer(@schema_path, schema_keyword),
-              message: message
+              message: message || yield
             )
           )
         end

data/lib/schemurai/schema_domain.rb

@@ -8,7 +8,7 @@ module Schemurai
           invalid!(label, "must be a boolean or an object")
         end
 
-        validate_value!(schema, label, {})
+        validate_value!(schema, label, [], {})
         schema
       end
 
@@ -23,31 +23,37 @@ module Schemurai
         schemas
       end
 
-      module_function def validate_value!(value, path, ancestors)
+      module_function def validate_value!(value, label, path, ancestors)
         case value
         when nil, true, false
           nil
         when String, Integer
-          invalid!(path, "uses a subclass of #{value.class.superclass}") unless supported_exact_scalar?(value)
+          invalid_at!(label, path, "uses a subclass of #{value.class.superclass}") unless supported_exact_scalar?(value)
         when Float
-          invalid!(path, "must contain only finite numbers") unless value.finite?
-          invalid!(path, "uses a Float subclass") unless value.instance_of?(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!(path, "uses an Array subclass") unless value.instance_of?(Array)
-          descend!(value, path, ancestors) do
-            value.each_with_index { |item, index| validate_value!(item, pointer(path, index), ancestors) }
+          invalid_at!(label, path, "uses an Array subclass") unless value.instance_of?(Array)
+          descend!(value, label, path, ancestors) do
+            value.each_with_index do |item, index|
+              path << index
+              validate_value!(item, label, path, ancestors)
+              path.pop
+            end
           end
         when Hash
-          invalid!(path, "uses a Hash subclass") unless value.instance_of?(Hash)
-          descend!(value, path, ancestors) do
+          invalid_at!(label, path, "uses a Hash subclass") unless value.instance_of?(Hash)
+          descend!(value, label, path, ancestors) do
             value.each do |key, item|
-              invalid!(path, "contains a non-string object key") unless key.instance_of?(String)
+              invalid_at!(label, path, "contains a non-string object key") unless key.instance_of?(String)
 
-              validate_value!(item, pointer(path, key), ancestors)
+              path << key
+              validate_value!(item, label, path, ancestors)
+              path.pop
             end
           end
         else
-          invalid!(path, "contains unsupported #{value.class}")
+          invalid_at!(label, path, "contains unsupported #{value.class}")
         end
       end
       private_class_method :validate_value!
@@ -57,8 +63,8 @@ module Schemurai
       end
       private_class_method :supported_exact_scalar?
 
-      module_function def descend!(value, path, ancestors)
-        invalid!(path, "contains a recursive container") if ancestors.key?(value.object_id)
+      module_function def descend!(value, label, path, ancestors)
+        invalid_at!(label, path, "contains a recursive container") if ancestors.key?(value.object_id)
 
         ancestors[value.object_id] = true
         yield
@@ -67,11 +73,13 @@ module Schemurai
       end
       private_class_method :descend!
 
-      module_function def pointer(path, segment)
-        escaped = segment.to_s.gsub("~", "~0").gsub("/", "~1")
-        "#{path}/#{escaped}"
+      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 :pointer
+      private_class_method :invalid_at!
 
       module_function def invalid!(path, reason)
         raise Error, "invalid JSON-shaped #{path}: #{reason}"

data/lib/schemurai/schema_graph.rb

@@ -13,6 +13,44 @@ require_relative "schema_domain"
 module Schemurai
   module Internal
     class SchemaGraph
+      class CompilationChanges
+        EMPTY_HASH = {}.freeze
+        EMPTY_ARRAY = [].freeze
+
+        attr_reader :nodes
+        attr_accessor :requires_dynamic_scope
+
+        def initialize
+          @nodes = []
+          @requires_dynamic_scope = false
+        end
+
+        def resources = @resources || EMPTY_HASH
+        def mutable_resources = (@resources ||= {})
+
+        def resource_nodes = @resource_nodes || EMPTY_HASH
+        def mutable_resource_nodes = (@resource_nodes ||= {})
+
+        def uri_registry = @uri_registry || EMPTY_HASH
+        def mutable_uri_registry = (@uri_registry ||= {})
+
+        def dynamic_anchors = @dynamic_anchors || EMPTY_HASH
+        def mutable_dynamic_anchors = (@dynamic_anchors ||= {})
+
+        def custom_dialects = @custom_dialects || EMPTY_HASH
+        def mutable_custom_dialects = (@custom_dialects ||= {})
+
+        def document_locations
+          @document_locations || EMPTY_ARRAY
+        end
+
+        def mutable_document_locations
+          @document_locations ||= []
+        end
+      end
+
+      private_constant :CompilationChanges
+
       class Resource
         attr_reader :uri, :root
 
@@ -65,13 +103,15 @@ module Schemurai
 
       def compile(schema, base_uri: nil, dialect: @default_dialect)
         SchemaDomain.validate!(schema)
-        roots = @compiled_roots.fetch(schema) { @compiled_roots[schema] = {} }
-        cache_key = [base_uri.to_s, dialect]
-        roots.fetch(cache_key) do
-          roots[cache_key] = compile_atomically do |changes|
-            root_dialect = dialect_for(schema, dialect, changes)
-            compile_document(schema, base_uri.to_s, root_dialect, changes)
-          end
+        roots = (@compiled_roots[schema] ||= {})
+        base_uri = base_uri.to_s
+        cache_key = [base_uri, dialect]
+        root = roots[cache_key]
+        return root if root
+
+        roots[cache_key] = compile_atomically do |changes|
+          root_dialect = dialect_for(schema, dialect, changes)
+          compile_document(schema, base_uri, root_dialect, changes)
         end
       end
 
@@ -132,16 +172,7 @@ module Schemurai
       end
 
       private def compilation_changes
-        {
-          resources: {},
-          resource_nodes: {},
-          uri_registry: {},
-          nodes: [],
-          document_locations: [],
-          dynamic_anchors: {},
-          custom_dialects: {},
-          requires_dynamic_scope: false
-        }
+        CompilationChanges.new
       end
 
       private def compile_atomically
@@ -152,22 +183,22 @@ module Schemurai
       end
 
       private def commit(changes)
-        resources.update(changes[:resources])
-        changes[:resource_nodes].each do |resource, resource_nodes|
+        resources.update(changes.resources)
+        changes.resource_nodes.each do |resource, resource_nodes|
           resource_nodes.each_value { |node| resource.add(node) }
         end
-        uri_registry.update(changes[:uri_registry])
-        nodes.concat(changes[:nodes])
+        uri_registry.update(changes.uri_registry)
+        nodes.concat(changes.nodes)
         if @nodes_by_document_location
-          changes[:document_locations].each do |document_key, schema_path, node|
+          changes.document_locations.each do |document_key, schema_path, node|
             (@nodes_by_document_location[document_key] ||= {})[schema_path] = node
           end
         end
-        changes[:dynamic_anchors].each do |resource, anchors|
+        changes.dynamic_anchors.each do |resource, anchors|
           (@dynamic_anchors[resource] ||= {}).update(anchors)
         end
-        (@custom_dialects ||= {}).update(changes[:custom_dialects]) unless changes[:custom_dialects].empty?
-        @dynamic_scope = true if changes[:requires_dynamic_scope]
+        (@custom_dialects ||= {}).update(changes.custom_dialects) unless changes.custom_dialects.empty?
+        @dynamic_scope = true if changes.requires_dynamic_scope
       end
 
       private def resolve_uncached(node, reference)
@@ -236,7 +267,7 @@ module Schemurai
       private def compile_node(schema, inherited_base, dialect, schema_path, resource_path, resource, document_key, changes)
         hash_schema = schema.is_a?(Hash)
         if hash_schema && (schema.key?("$recursiveRef") || schema.key?("$dynamicRef"))
-          changes[:requires_dynamic_scope] = true
+          changes.requires_dynamic_scope = true
         end
         dialect = dialect_for(schema, dialect, changes) if hash_schema && schema.key?("$schema")
         if hash_schema && dialect.format_assertion? && schema.key?("format") &&
@@ -263,11 +294,13 @@ module Schemurai
           resource_path: resource_path,
           document_key: document_key
         )
-        changes[:nodes] << node
-        changes[:document_locations] << [document_key, schema_path, node]
+        changes.nodes << node
+        if @nodes_by_document_location
+          changes.mutable_document_locations << [document_key, schema_path, node]
+        end
 
         if hash_schema && schema.key?("$id") && !exclusive_ref && !base.empty?
-          changes[:uri_registry][base] = node
+          changes.mutable_uri_registry[base] = node
           if starts_resource
             resource = register_resource(strip_fragment(base), node, changes)
           end
@@ -276,7 +309,7 @@ module Schemurai
         resource ||= register_resource(strip_fragment(base), node, changes)
         unless node.resource
           node.resource = resource
-          (changes[:resource_nodes][resource] ||= {})[node.resource_path] = node unless node.equal?(resource.root)
+          (changes.mutable_resource_nodes[resource] ||= {})[node.resource_path] = node unless node.equal?(resource.root)
         end
 
         if hash_schema && !exclusive_ref
@@ -315,24 +348,24 @@ module Schemurai
         return resource if resource && resource.root.equal?(root)
         return resource if resource
 
-        changes[:resources][uri] = Resource.new(uri, root)
+        changes.mutable_resources[uri] = Resource.new(uri, root)
       end
 
       private def resource_at(uri, changes)
-        changes[:resources].fetch(uri) { resources[uri] }
+        changes.resources.fetch(uri) { resources[uri] }
       end
 
       private def register_uri_unless_present(uri, node, changes)
-        return if changes[:uri_registry].key?(uri) || uri_registry.key?(uri)
+        return if changes.uri_registry.key?(uri) || uri_registry.key?(uri)
 
-        changes[:uri_registry][uri] = node
+        changes.mutable_uri_registry[uri] = node
       end
 
       private def register_anchor(node, resource, name, changes, dynamic: false)
         return unless name.is_a?(String) && !name.empty?
 
-        changes[:uri_registry]["#{resource.uri}##{name}"] = node
-        ((changes[:dynamic_anchors][resource] ||= {})[name] = node) if dynamic
+        changes.mutable_uri_registry["#{resource.uri}##{name}"] = node
+        ((changes.mutable_dynamic_anchors[resource] ||= {})[name] = node) if dynamic
       end
 
       private def node_by_document_location(document_key, schema_path)
@@ -392,7 +425,7 @@ module Schemurai
         meta_schema = @external_schemas[uri] || @external_schemas[uri.delete_suffix("#")]
         return unless meta_schema.is_a?(Hash) && meta_schema["$vocabulary"].is_a?(Hash)
 
-        custom_dialects = changes ? changes[:custom_dialects] : (@custom_dialects ||= {})
+        custom_dialects = changes ? changes.mutable_custom_dialects : (@custom_dialects ||= {})
         return custom_dialects[uri] if custom_dialects.key?(uri)
         return @custom_dialects[uri] if @custom_dialects&.key?(uri)
 

data/lib/schemurai/version.rb

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