schemurai 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1b157d6e772537cab2886ef6d89bd547992c7359b73a13a49b9d9cfcdcc9808
-  data.tar.gz: f0e8e28536c58c95cf1848db949dad8007df0c7a6550dd8b0fd76439841617cd
+  metadata.gz: 01b0c89354b90232337525b7fe75c063053fecd2965036bb7ff600d2b4e823cb
+  data.tar.gz: f45549ac8cf41eae0c2b28220ca93fe87042cec2aa7c7926382a00f8f65c105d
 SHA512:
-  metadata.gz: b6f8206124aab29ae13908951efdd011e276ca347a75c0abf79da9fb3a9988f91a0a59b0ec559b85a88f01d5975b9ea251f9f14bb7aba634b7c8f3625c288167
-  data.tar.gz: 3fcd551c456cb81b53842c0736ae9e629676ca8c7c0e43017ee43991b00b995fde7a530f1c0cb38f81d5e7bb640b68a8ad8ad388934af73b06b4ef77c4e46a34
+  metadata.gz: 618d494971d7a1745075dae9b9e6155562f9c0f0fb058e923cd457f26bb062be2858db9f2ffaf711d035ee83490179e005869106f3ae29ef0c8011512bed2af9
+  data.tar.gz: 6ecd49a7320b6b936067808a2a0bd07d6e497418427d0e1612d624dd703a71c6eae99f9ae27ab0a94c2946c3a6495fdc2c11bf665b7d59a9fad628f285af0f5e

data/README.md

@@ -3,6 +3,7 @@
 [![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
@@ -11,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"
 
@@ -284,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/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/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.1.0"
+  VERSION = "2.2.0"
 end