schemurai 1.0.0 → 2.1.0

data/lib/schemurai/meta_schemas/draft2020_12.rb

@@ -13,8 +13,46 @@ module Schemurai
           "$dynamicAnchor" => "meta",
           "type" => ["object", "boolean"],
           "properties" => {
+            "$id" => {"type" => "string"},
+            "$schema" => {"type" => "string"},
+            "$ref" => {"type" => "string"},
+            "$anchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$dynamicRef" => {"type" => "string"},
+            "$dynamicAnchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$recursiveRef" => {"type" => "string"},
+            "$recursiveAnchor" => {"type" => "string", "pattern" => "^[A-Za-z_][-A-Za-z0-9._]*$"},
+            "$vocabulary" => {"type" => "object", "additionalProperties" => {"type" => "boolean"}},
+            "$comment" => {"type" => "string"},
             "$defs" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
             "definitions" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "prefixItems" => {
+              "type" => "array",
+              "minItems" => 1,
+              "items" => {"$dynamicRef" => "#meta"}
+            },
+            "items" => {"$dynamicRef" => "#meta"},
+            "contains" => {"$dynamicRef" => "#meta"},
+            "additionalProperties" => {"$dynamicRef" => "#meta"},
+            "properties" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "patternProperties" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "dependentSchemas" => {"type" => "object", "additionalProperties" => {"$dynamicRef" => "#meta"}},
+            "dependencies" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "anyOf" => [
+                  {"$dynamicRef" => "#meta"},
+                  {"type" => "array", "items" => {"type" => "string"}, "uniqueItems" => true}
+                ]
+              }
+            },
+            "propertyNames" => {"$dynamicRef" => "#meta"},
+            "if" => {"$dynamicRef" => "#meta"},
+            "then" => {"$dynamicRef" => "#meta"},
+            "else" => {"$dynamicRef" => "#meta"},
+            "allOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "anyOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "oneOf" => {"type" => "array", "minItems" => 1, "items" => {"$dynamicRef" => "#meta"}},
+            "not" => {"$dynamicRef" => "#meta"},
             "type" => {
               "anyOf" => [
                 {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
@@ -26,20 +64,83 @@ module Schemurai
                 }
               ]
             },
+            "enum" => {"type" => "array"},
+            "multipleOf" => {"type" => "number", "exclusiveMinimum" => 0},
+            "maximum" => {"type" => "number"},
+            "exclusiveMaximum" => {"type" => "number"},
+            "minimum" => {"type" => "number"},
+            "exclusiveMinimum" => {"type" => "number"},
             "minLength" => {"type" => "integer", "minimum" => 0},
             "maxLength" => {"type" => "integer", "minimum" => 0},
+            "pattern" => {"type" => "string"},
             "minItems" => {"type" => "integer", "minimum" => 0},
             "maxItems" => {"type" => "integer", "minimum" => 0},
+            "uniqueItems" => {"type" => "boolean"},
             "minContains" => {"type" => "integer", "minimum" => 0},
             "maxContains" => {"type" => "integer", "minimum" => 0},
             "minProperties" => {"type" => "integer", "minimum" => 0},
-            "maxProperties" => {"type" => "integer", "minimum" => 0}
+            "maxProperties" => {"type" => "integer", "minimum" => 0},
+            "required" => {
+              "type" => "array",
+              "items" => {"type" => "string"},
+              "uniqueItems" => true
+            },
+            "dependentRequired" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "type" => "array",
+                "items" => {"type" => "string"},
+                "uniqueItems" => true
+              }
+            },
+            "title" => {"type" => "string"},
+            "description" => {"type" => "string"},
+            "deprecated" => {"type" => "boolean"},
+            "readOnly" => {"type" => "boolean"},
+            "writeOnly" => {"type" => "boolean"},
+            "examples" => {"type" => "array"},
+            "format" => {"type" => "string"},
+            "contentEncoding" => {"type" => "string"},
+            "contentMediaType" => {"type" => "string"},
+            "contentSchema" => {"$dynamicRef" => "#meta"}
           }
         }.freeze
 
         MetaSchemas.register(META_SCHEMA_URI, SCHEMA)
 
-        private_constant :META_SCHEMA_URI, :SCHEMA
+        COMPONENT_KEYWORDS = {
+          "core" => %w[
+            $id $schema $ref $anchor $dynamicRef $dynamicAnchor $vocabulary $comment $defs
+          ],
+          "applicator" => %w[
+            prefixItems items contains additionalProperties properties patternProperties
+            dependentSchemas propertyNames if then else allOf anyOf oneOf not
+          ],
+          "unevaluated" => %w[unevaluatedItems unevaluatedProperties],
+          "validation" => %w[
+            type const enum multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+            maxLength minLength pattern maxItems minItems uniqueItems maxContains minContains
+            maxProperties minProperties required dependentRequired
+          ],
+          "meta-data" => %w[title description default deprecated readOnly writeOnly examples],
+          "format-annotation" => %w[format],
+          "format-assertion" => %w[format],
+          "content" => %w[contentEncoding contentMediaType contentSchema]
+        }.freeze
+
+        COMPONENT_KEYWORDS.each do |name, keywords|
+          uri = "https://json-schema.org/draft/2020-12/meta/#{name}"
+          component = {
+            "$schema" => META_SCHEMA_URI,
+            "$id" => uri,
+            "$dynamicAnchor" => "meta",
+            "type" => ["object", "boolean"],
+            "properties" => SCHEMA.fetch("properties").slice(*keywords)
+          }.freeze
+          MetaSchemas.register(uri, component)
+        end
+
+        private_constant :META_SCHEMA_URI, :SCHEMA, :COMPONENT_KEYWORDS
       end
     end
   end

data/lib/schemurai/schema_domain.rb

@@ -0,0 +1,82 @@
+# 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, 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)
+        when Float
+          invalid!(path, "must contain only finite numbers") unless value.finite?
+          invalid!(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) }
+          end
+        when Hash
+          invalid!(path, "uses a Hash subclass") unless value.instance_of?(Hash)
+          descend!(value, path, ancestors) do
+            value.each do |key, item|
+              invalid!(path, "contains a non-string object key") unless key.instance_of?(String)
+
+              validate_value!(item, pointer(path, key), ancestors)
+            end
+          end
+        else
+          invalid!(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, path, ancestors)
+        invalid!(path, "contains a recursive container") if ancestors.key?(value.object_id)
+
+        ancestors[value.object_id] = true
+        yield
+      ensure
+        ancestors.delete(value.object_id)
+      end
+      private_class_method :descend!
+
+      module_function def pointer(path, segment)
+        escaped = segment.to_s.gsub("~", "~0").gsub("/", "~1")
+        "#{path}/#{escaped}"
+      end
+      private_class_method :pointer
+
+      module_function def invalid!(path, reason)
+        raise Error, "invalid JSON-shaped #{path}: #{reason}"
+      end
+      private_class_method :invalid!
+    end
+  end
+end

data/lib/schemurai/schema_graph.rb

@@ -8,6 +8,7 @@ require_relative "meta_schemas/draft7"
 require_relative "meta_schemas/draft2019_09"
 require_relative "meta_schemas/draft2020_12"
 require_relative "schema_node"
+require_relative "schema_domain"
 
 module Schemurai
   module Internal
@@ -43,9 +44,11 @@ module Schemurai
       attr_reader :resources, :uri_registry, :nodes
 
       def initialize(schemas: {}, dialect: Dialect.resolve)
+        SchemaDomain.validate_registry!(schemas)
         @external_schemas = schemas.dup
         @indexed_external_schemas = nil
         @compiled_roots = {}.compare_by_identity
+        @meta_schema_roots = {}
         @resources = {}
         @uri_registry = {}
         @nodes = []
@@ -58,10 +61,10 @@ module Schemurai
         # evaluators sharing this graph may reach the dynamic reference.
         @dynamic_scope = !schemas.empty?
         @default_dialect = dialect
-        @shareable = false
       end
 
       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
@@ -72,12 +75,24 @@ module Schemurai
         end
       end
 
+      def meta_schema_root(schema)
+        SchemaDomain.validate!(schema)
+        uri = if schema.is_a?(Hash) && schema.key?("$schema")
+          schema["$schema"].to_s
+        else
+          @default_dialect.uri
+        end
+        root = (@meta_schema_roots[uri] ||= compile({"$ref" => uri}))
+        resolve(root, uri)
+        root
+      end
+
       def resolve(node, reference)
         if (resolved = @resolved_refs&.[](node))&.key?(reference)
           return resolved[reference]
         end
 
-        if @shareable
+        if Ractor.shareable?(self)
           raise ResolutionError, "reference #{reference.inspect} was not resolved before sharing"
         end
 
@@ -94,7 +109,7 @@ module Schemurai
       end
 
       def make_shareable
-        return self if @shareable
+        return self if Ractor.shareable?(self)
 
         @external_schemas.each_key do |uri|
           index_external(strip_fragment(uri.to_s), @default_dialect)
@@ -113,7 +128,6 @@ module Schemurai
         end
 
         @resolved_refs ||= {}
-        @shareable = true
         Ractor.make_shareable(self)
       end
 
@@ -336,9 +350,10 @@ module Schemurai
       private def index_external(document_uri, fallback_dialect)
         return if @indexed_external_schemas&.[](document_uri)
 
-        if (dialect = Dialect.resolve(document_uri)) && (meta_schema = MetaSchemas.resolve(document_uri))
+        if (meta_schema = MetaSchemas.resolve(document_uri))
+          dialect = Dialect.resolve(meta_schema["$schema"]) || fallback_dialect
           compile_atomically do |changes|
-            compile_document(meta_schema, dialect.uri, dialect, changes)
+            compile_document(meta_schema, document_uri, dialect, changes)
           end
           (@indexed_external_schemas ||= {})[document_uri] = true
           return

data/lib/schemurai/version.rb

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

data/lib/schemurai/vm/compiler.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module VM
+    NumberRules = Data.define(
+      :mask,
+      :maximum,
+      :minimum,
+      :exclusive_maximum,
+      :exclusive_minimum,
+      :multiple_of
+    )
+
+    MAXIMUM = 1 << 0
+    MINIMUM = 1 << 1
+    EXCLUSIVE_MAXIMUM = 1 << 2
+    EXCLUSIVE_MINIMUM = 1 << 3
+    MULTIPLE_OF = 1 << 4
+
+    TypeRules = Data.define(:mask, :names)
+
+    TYPE_NULL = 1 << 0
+    TYPE_BOOLEAN = 1 << 1
+    TYPE_OBJECT = 1 << 2
+    TYPE_ARRAY = 1 << 3
+    TYPE_NUMBER = 1 << 4
+    TYPE_INTEGER = 1 << 5
+    TYPE_STRING = 1 << 6
+
+    TYPE_BITS = {
+      "null" => TYPE_NULL,
+      "boolean" => TYPE_BOOLEAN,
+      "object" => TYPE_OBJECT,
+      "array" => TYPE_ARRAY,
+      "number" => TYPE_NUMBER,
+      "integer" => TYPE_INTEGER,
+      "string" => TYPE_STRING
+    }.freeze
+
+    TYPE_OPCODES = {
+      "null" => :type_null,
+      "boolean" => :type_boolean,
+      "object" => :type_object,
+      "array" => :type_array,
+      "number" => :type_number,
+      "integer" => :type_integer,
+      "string" => :type_string
+    }.freeze
+
+    ReferenceRules = Data.define(:value, :fragment)
+
+    StringRules = Data.define(
+      :max_length,
+      :has_max_length,
+      :min_length,
+      :has_min_length,
+      :pattern,
+      :has_pattern,
+      :format,
+      :format_assertion,
+      :decode_base64,
+      :parse_json
+    )
+
+    ArrayRules = Data.define(
+      :max_items,
+      :has_max_items,
+      :min_items,
+      :has_min_items,
+      :unique,
+      :prefix_items,
+      :items,
+      :items_list,
+      :additional,
+      :contains,
+      :min_contains,
+      :max_contains,
+      :count_contains,
+      :unevaluated
+    )
+
+    ObjectRules = Data.define(
+      :max_properties,
+      :has_max_properties,
+      :min_properties,
+      :has_min_properties,
+      :required,
+      :has_required,
+      :properties,
+      :patterns,
+      :additional,
+      :property_names,
+      :dependencies,
+      :dependent_required,
+      :dependent_schemas,
+      :unevaluated
+    )
+
+    ConditionalRules = Data.define(
+      :condition,
+      :then_branch,
+      :else_branch,
+      :has_then,
+      :has_else
+    )
+
+    class Program
+      attr_reader :node, :code, :dynamic_anchor
+
+      def initialize(node)
+        @node = node
+        schema = node.schema
+        @recursive_anchor = schema.is_a?(Hash) && schema["$recursiveAnchor"] == true
+        @dynamic_anchor = if schema.is_a?(Hash) && schema["$dynamicAnchor"].is_a?(String)
+          schema["$dynamicAnchor"].dup.freeze
+        end
+      end
+
+      def finish(code)
+        @code = code.map(&:freeze).freeze
+        @tracks_evaluation = code.any? do |instruction|
+          %i[array object].include?(instruction.first) && instruction[1].unevaluated
+        end
+        @tracks_dynamic_scope = code.any? do |opcode, operand|
+          opcode == :ref || opcode == :recursive_ref || opcode == :dynamic_ref || dynamic_scope_operand?(operand)
+        end
+        freeze
+      end
+
+      def tracks_evaluation?
+        @tracks_evaluation
+      end
+
+      def recursive_anchor?
+        @recursive_anchor
+      end
+
+      def tracks_dynamic_scope?
+        @tracks_dynamic_scope
+      end
+
+      private def dynamic_scope_operand?(operand)
+        case operand
+        when Program
+          operand.tracks_dynamic_scope?
+        when Array
+          operand.any? { |item| dynamic_scope_operand?(item) }
+        when Hash
+          operand.each_value { |item| return true if dynamic_scope_operand?(item) }
+          false
+        when ArrayRules
+          dynamic_scope_operand?(operand.prefix_items) ||
+            dynamic_scope_operand?(operand.items) ||
+            dynamic_scope_operand?(operand.additional) ||
+            dynamic_scope_operand?(operand.contains) ||
+            dynamic_scope_operand?(operand.unevaluated)
+        when ObjectRules
+          dynamic_scope_operand?(operand.properties) ||
+            dynamic_scope_operand?(operand.patterns) ||
+            dynamic_scope_operand?(operand.additional) ||
+            dynamic_scope_operand?(operand.property_names) ||
+            dynamic_scope_operand?(operand.dependencies) ||
+            dynamic_scope_operand?(operand.dependent_schemas) ||
+            dynamic_scope_operand?(operand.unevaluated)
+        when ConditionalRules
+          dynamic_scope_operand?(operand.condition) ||
+            dynamic_scope_operand?(operand.then_branch) ||
+            dynamic_scope_operand?(operand.else_branch)
+        else
+          false
+        end
+      end
+    end
+
+    class Compiler
+      def initialize(graph)
+        @graph = graph
+        @programs = {}.compare_by_identity
+      end
+
+      def compile(node)
+        @programs.fetch(node) do
+          program = Program.new(node)
+          @programs[node] = program
+          program.finish(compile_code(node))
+        end
+      end
+
+      def compile_all
+        @graph.nodes.each { |node| compile(node) }
+        self
+      end
+
+      def resolve(program, reference)
+        compile(@graph.resolve(program.node, reference))
+      end
+
+      private def compile_code(node)
+        schema = node.schema
+        return [[:boolean, schema]] if schema == true || schema == false
+        return [] unless schema.is_a?(Hash)
+
+        code = []
+        if schema.key?("$ref")
+          code << [:ref, compile_reference(schema["$ref"])]
+          return code unless node.dialect.ref_siblings?
+        end
+        code << [:recursive_ref, compile_reference(schema["$recursiveRef"])] if schema.key?("$recursiveRef")
+        code << [:dynamic_ref, compile_reference(schema["$dynamicRef"])] if schema.key?("$dynamicRef")
+
+        mask = node.keyword_mask
+        categories = Schemurai.const_get(:Internal)::Dialect
+        code << compile_type(schema["type"]) if (mask & categories::TYPE) != 0 && schema.key?("type")
+        if (mask & categories::ENUM) != 0
+          code << [:enum, snapshot(schema["enum"])] if schema.key?("enum")
+          code << [:const, snapshot(schema["const"])] if schema.key?("const")
+        end
+        compile_combiners(code, node, schema) if (mask & categories::COMBINER) != 0
+        code << [:number, compile_number(schema)] if (mask & categories::NUMBER) != 0
+        if (mask & categories::STRING) != 0 || node.format
+          code << [:string, compile_string(node, schema)]
+        end
+        code << [:array, compile_array(node, schema)] if (mask & categories::ARRAY) != 0
+        code << [:object, compile_object(node, schema)] if (mask & categories::OBJECT) != 0
+        code
+      end
+
+      private def compile_combiners(code, node, schema)
+        %w[allOf anyOf oneOf].each do |keyword|
+          next unless schema.key?(keyword)
+
+          children = schema[keyword].each_index.map { |index| compile(node.child(keyword, index)) }
+          code << [keyword.to_sym, children]
+        end
+        code << [:not, compile(node.child("not"))] if schema.key?("not")
+        return unless schema.key?("if")
+
+        code << [
+          :conditional,
+          ConditionalRules.new(
+            compile(node.child("if")),
+            schema.key?("then") ? compile(node.child("then")) : nil,
+            schema.key?("else") ? compile(node.child("else")) : nil,
+            schema.key?("then"),
+            schema.key?("else")
+          )
+        ]
+      end
+
+      private def compile_number(schema)
+        mask = 0
+        mask |= MAXIMUM if schema.key?("maximum")
+        mask |= MINIMUM if schema.key?("minimum")
+        mask |= EXCLUSIVE_MAXIMUM if schema.key?("exclusiveMaximum")
+        mask |= EXCLUSIVE_MINIMUM if schema.key?("exclusiveMinimum")
+        mask |= MULTIPLE_OF if schema.key?("multipleOf")
+        NumberRules.new(
+          mask: mask,
+          maximum: compile_decimal(schema["maximum"]),
+          minimum: compile_decimal(schema["minimum"]),
+          exclusive_maximum: compile_decimal(schema["exclusiveMaximum"]),
+          exclusive_minimum: compile_decimal(schema["exclusiveMinimum"]),
+          multiple_of: compile_decimal(schema["multipleOf"])
+        )
+      end
+
+      private def compile_reference(reference)
+        value = snapshot(reference)
+        separator = value.index("#")
+        fragment = separator ? value[(separator + 1)..].freeze : nil
+        ReferenceRules.new(value: value, fragment: fragment)
+      end
+
+      private def compile_type(types)
+        return [TYPE_OPCODES.fetch(types)] unless types.is_a?(Array)
+
+        mask = types.reduce(0) { |result, type| result | TYPE_BITS.fetch(type) }
+        [:types, TypeRules.new(mask: mask, names: snapshot(types))]
+      end
+
+      private def compile_string(node, schema)
+        StringRules.new(
+          schema["maxLength"],
+          schema.key?("maxLength"),
+          schema["minLength"],
+          schema.key?("minLength"),
+          snapshot(schema["pattern"]),
+          schema.key?("pattern"),
+          node.format,
+          node.dialect.format_assertion?,
+          schema["contentEncoding"] == "base64",
+          schema["contentMediaType"] == "application/json"
+        )
+      end
+
+      private def compile_array(node, schema)
+        prefix_items = if schema["prefixItems"].is_a?(Array)
+          schema["prefixItems"].each_index.map { |index| compile(node.child("prefixItems", index)) }.freeze
+        end
+        items = if schema["items"].is_a?(Array)
+          schema["items"].each_index.map { |index| compile(node.child("items", index)) }.freeze
+        elsif !schema["items"].nil?
+          compile(node.child("items"))
+        end
+        ArrayRules.new(
+          schema["maxItems"],
+          schema.key?("maxItems"),
+          schema["minItems"],
+          schema.key?("minItems"),
+          schema["uniqueItems"],
+          prefix_items,
+          items,
+          items.is_a?(Array),
+          schema.key?("additionalItems") ? compile(node.child("additionalItems")) : nil,
+          schema.key?("contains") ? compile(node.child("contains")) : nil,
+          schema.fetch("minContains", 1),
+          schema.fetch("maxContains", Float::INFINITY),
+          node.dialect.keywords.key?("minContains"),
+          schema.key?("unevaluatedItems") ? compile(node.child("unevaluatedItems")) : nil
+        )
+      end
+
+      private def compile_object(node, schema)
+        ObjectRules.new(
+          schema["maxProperties"],
+          schema.key?("maxProperties"),
+          schema["minProperties"],
+          schema.key?("minProperties"),
+          snapshot(schema["required"]),
+          schema.key?("required"),
+          compile_map(node, schema, "properties"),
+          compile_map(node, schema, "patternProperties"),
+          schema.key?("additionalProperties") ? compile(node.child("additionalProperties")) : nil,
+          schema.key?("propertyNames") ? compile(node.child("propertyNames")) : nil,
+          compile_dependencies(node, schema),
+          schema.fetch("dependentRequired", {}).map do |name, required_names|
+            [snapshot(name), snapshot(required_names)].freeze
+          end.freeze,
+          compile_map(node, schema, "dependentSchemas"),
+          schema.key?("unevaluatedProperties") ? compile(node.child("unevaluatedProperties")) : nil
+        )
+      end
+
+      private def compile_map(node, schema, keyword)
+        schema.fetch(keyword, {}).each_key.to_h do |name|
+          [snapshot(name), compile(node.child(keyword, name))]
+        end.freeze
+      end
+
+      private def compile_dependencies(node, schema)
+        schema.fetch("dependencies", {}).map do |name, dependency|
+          compiled = dependency.is_a?(Array) ? snapshot(dependency) : compile(node.child("dependencies", name))
+          [snapshot(name), compiled].freeze
+        end.freeze
+      end
+
+      private def snapshot(value)
+        case value
+        when Hash
+          value.to_h { |key, item| [snapshot(key), snapshot(item)] }.freeze
+        when Array
+          value.map { |item| snapshot(item) }.freeze
+        when String
+          value.dup.freeze
+        else
+          value
+        end
+      end
+
+      private def compile_decimal(value)
+        return value if value.nil? || value.is_a?(Integer) || value.is_a?(Rational)
+
+        Rational(value.to_s)
+      end
+    end
+  end
+end