schemurai 1.0.0

data/lib/schemurai/schema_graph.rb

@@ -0,0 +1,481 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "dialects/draft7"
+require_relative "dialects/draft2019_09"
+require_relative "dialects/draft2020_12"
+require_relative "meta_schemas/draft7"
+require_relative "meta_schemas/draft2019_09"
+require_relative "meta_schemas/draft2020_12"
+require_relative "schema_node"
+
+module Schemurai
+  module Internal
+    class SchemaGraph
+      class Resource
+        attr_reader :uri, :root
+
+        def initialize(uri, root)
+          @uri = uri
+          @root = root
+          @nodes = nil
+        end
+
+        def add(node)
+          (@nodes ||= {})[node.resource_path] = node unless node.equal?(root)
+          node.resource = self unless node.resource.equal?(self)
+        end
+
+        def node_at(pointer)
+          return root if pointer.empty?
+
+          @nodes&.[](pointer)
+        end
+
+        def nodes
+          @nodes || EMPTY_NODES
+        end
+
+        EMPTY_NODES = {}.freeze
+        private_constant :EMPTY_NODES
+      end
+
+      attr_reader :resources, :uri_registry, :nodes
+
+      def initialize(schemas: {}, dialect: Dialect.resolve)
+        @external_schemas = schemas.dup
+        @indexed_external_schemas = nil
+        @compiled_roots = {}.compare_by_identity
+        @resources = {}
+        @uri_registry = {}
+        @nodes = []
+        @nodes_by_document_location = nil
+        @resolved_refs = nil
+        @dynamic_anchors = {}
+        # External schemas are indexed lazily, so their references are not yet
+        # available to compile_node. Track conservatively from the caller.
+        # Once required, dynamic scope tracking must remain enabled because all
+        # 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)
+        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
+        end
+      end
+
+      def resolve(node, reference)
+        if (resolved = @resolved_refs&.[](node))&.key?(reference)
+          return resolved[reference]
+        end
+
+        if @shareable
+          raise ResolutionError, "reference #{reference.inspect} was not resolved before sharing"
+        end
+
+        target = resolve_uncached(node, reference)
+        ((@resolved_refs ||= {})[node] ||= {})[reference] = target
+      end
+
+      def dynamic_anchor(resource, name)
+        @dynamic_anchors.dig(resource, name)
+      end
+
+      def dynamic_scope?
+        @dynamic_scope
+      end
+
+      def make_shareable
+        return self if @shareable
+
+        @external_schemas.each_key do |uri|
+          index_external(strip_fragment(uri.to_s), @default_dialect)
+        end
+
+        index = 0
+        while index < nodes.length
+          node = nodes[index]
+          schema = node.schema
+          if schema.is_a?(Hash)
+            ["$ref", "$recursiveRef", "$dynamicRef"].each do |keyword|
+              resolve(node, schema[keyword]) if schema.key?(keyword)
+            end
+          end
+          index += 1
+        end
+
+        @resolved_refs ||= {}
+        @shareable = true
+        Ractor.make_shareable(self)
+      end
+
+      private def compilation_changes
+        {
+          resources: {},
+          resource_nodes: {},
+          uri_registry: {},
+          nodes: [],
+          document_locations: [],
+          dynamic_anchors: {},
+          custom_dialects: {},
+          requires_dynamic_scope: false
+        }
+      end
+
+      private def compile_atomically
+        changes = compilation_changes
+        result = yield changes
+        commit(changes)
+        result
+      end
+
+      private def commit(changes)
+        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])
+        if @nodes_by_document_location
+          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|
+          (@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]
+      end
+
+      private def resolve_uncached(node, reference)
+        uri = absolute_uri(node.base_uri, reference)
+        document_uri = strip_fragment(uri)
+        index_external(document_uri, node.dialect)
+
+        if (target = uri_registry[uri])
+          return target
+        end
+
+        resource = if node.resource.uri == document_uri
+          node.resource
+        else
+          resources[document_uri]
+        end
+        raise ResolutionError, "unresolvable reference #{reference.inspect}" unless resource
+
+        raw_fragment = fragment(uri)
+        return resource.root if raw_fragment.empty?
+
+        decoded = URI.decode_uri_component(raw_fragment)
+        unless decoded.start_with?("/")
+          raise ResolutionError, "unsupported plain-name fragment ##{raw_fragment}"
+        end
+
+        pointer = canonical_pointer(decoded)
+        return resource.node_at(pointer) if resource.node_at(pointer)
+
+        schema_path = "#{resource.root.schema_path}#{pointer}"
+        if (target = node_by_document_location(resource.root.document_key, schema_path))
+          return target
+        end
+
+        target = pointer_target(resource.root.schema, pointer)
+        compile_atomically do |changes|
+          compile_node(
+            target,
+            resource.root.base_uri,
+            resource.root.dialect,
+            schema_path,
+            pointer,
+            resource,
+            resource.root.document_key,
+            changes
+          )
+        end
+      rescue URI::Error
+        raise ResolutionError, "unresolvable reference #{reference.inspect}"
+      end
+
+      def node_at(uri)
+        uri_registry[uri.to_s]
+      end
+
+      private def compile_document(schema, retrieval_uri, dialect, changes)
+        document_key = retrieval_uri.empty? ? Object.new : retrieval_uri
+        root = compile_node(schema, retrieval_uri, dialect, "", "", nil, document_key, changes)
+        document_uri = strip_fragment(retrieval_uri)
+        register_resource(document_uri, root, changes) unless document_uri.empty? || resource_at(document_uri, changes)
+        register_uri_unless_present(retrieval_uri, root, changes) unless retrieval_uri.empty?
+        register_uri_unless_present(document_uri, root, changes) unless document_uri.empty?
+        root
+      end
+
+      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
+        end
+        dialect = dialect_for(schema, dialect, changes) if hash_schema && schema.key?("$schema")
+        if hash_schema && dialect.format_assertion? && schema.key?("format") &&
+            Formats.resolve(schema["format"]).name.nil?
+          raise UnsupportedFormatError,
+            "unsupported format #{schema["format"].inspect} required by Format-Assertion vocabulary"
+        end
+        exclusive_ref = hash_schema && schema.key?("$ref") && !dialect.ref_siblings?
+        base = if hash_schema && !exclusive_ref && schema.key?("$id")
+          absolute_uri(inherited_base, schema["$id"])
+        else
+          inherited_base
+        end
+        base = inherited_base if base.empty?
+        starts_resource = hash_schema && schema.key?("$id") && !exclusive_ref &&
+          !base.empty? && fragment(base).empty?
+        resource_path = "" if starts_resource
+
+        node = SchemaNode.new(
+          schema: schema,
+          dialect: dialect,
+          base_uri: base,
+          schema_path: schema_path,
+          resource_path: resource_path,
+          document_key: document_key
+        )
+        changes[:nodes] << node
+        changes[:document_locations] << [document_key, schema_path, node]
+
+        if hash_schema && schema.key?("$id") && !exclusive_ref && !base.empty?
+          changes[:uri_registry][base] = node
+          if starts_resource
+            resource = register_resource(strip_fragment(base), node, changes)
+          end
+        end
+
+        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)
+        end
+
+        if hash_schema && !exclusive_ref
+          register_anchor(node, resource, schema["$anchor"], changes) if schema.key?("$anchor")
+          if schema.key?("$dynamicAnchor")
+            register_anchor(node, resource, schema["$dynamicAnchor"], changes, dynamic: true)
+          end
+        end
+
+        dialect.each_subschema(schema) do |child_schema, segments|
+          child_schema_path = append_segments(schema_path, segments)
+          child_resource_path = if resource_path == schema_path
+            child_schema_path
+          else
+            append_segments(resource_path, segments)
+          end
+          child = compile_node(
+            child_schema,
+            base,
+            dialect,
+            child_schema_path,
+            child_resource_path,
+            resource,
+            document_key,
+            changes
+          )
+          node.add_child(*segments, child: child)
+        end
+        node.freeze
+      end
+
+      private def register_resource(uri, root, changes)
+        return Resource.new(uri, root) if uri.empty?
+
+        resource = resource_at(uri, changes)
+        return resource if resource && resource.root.equal?(root)
+        return resource if resource
+
+        changes[:resources][uri] = Resource.new(uri, root)
+      end
+
+      private def resource_at(uri, changes)
+        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)
+
+        changes[: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
+      end
+
+      private def node_by_document_location(document_key, schema_path)
+        unless @nodes_by_document_location
+          target = nodes.find { |node| node.document_key == document_key && node.schema_path == schema_path }
+          return unless target
+
+          @nodes_by_document_location = nodes.each_with_object({}) do |node, result|
+            (result[node.document_key] ||= {})[node.schema_path] = node
+          end
+        end
+        @nodes_by_document_location.dig(document_key, schema_path)
+      end
+
+      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))
+          compile_atomically do |changes|
+            compile_document(meta_schema, dialect.uri, dialect, changes)
+          end
+          (@indexed_external_schemas ||= {})[document_uri] = true
+          return
+        end
+        if @external_schemas.key?(document_uri)
+          external_schema = @external_schemas[document_uri]
+          compile_atomically do |changes|
+            dialect = dialect_for(external_schema, fallback_dialect, changes)
+            compile_document(external_schema, document_uri, dialect, changes)
+          end
+          (@indexed_external_schemas ||= {})[document_uri] = true
+          return
+        end
+
+        matches = @external_schemas.select do |external_uri, _schema|
+          strip_fragment(external_uri.to_s) == document_uri
+        end
+        compile_atomically do |changes|
+          matches.each do |external_uri, external_schema|
+            external_uri = external_uri.to_s
+            dialect = dialect_for(external_schema, fallback_dialect, changes)
+            compile_document(external_schema, external_uri, dialect, changes)
+          end
+        end
+        (@indexed_external_schemas ||= {})[document_uri] = true
+      end
+
+      private def dialect_for(schema, fallback, changes = nil)
+        return fallback unless schema.is_a?(Hash) && schema.key?("$schema")
+
+        uri = schema["$schema"].to_s
+        Dialect.resolve(uri) || custom_dialect(uri, fallback, changes) || fallback
+      end
+
+      private def custom_dialect(uri, fallback, changes)
+        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 ||= {})
+        return custom_dialects[uri] if custom_dialects.key?(uri)
+        return @custom_dialects[uri] if @custom_dialects&.key?(uri)
+
+        custom_dialects[uri] ||= begin
+          vocabulary = meta_schema["$vocabulary"]
+          validation = vocabulary.any? { |name, enabled| enabled && name.end_with?("/validation") }
+          format_assertion = vocabulary.any? { |name, _| name.end_with?("/format-assertion") }
+          keywords = if validation
+            fallback.keywords
+          else
+            fallback.keywords.except(*VALIDATION_KEYWORDS)
+          end
+          if format_assertion
+            keywords = keywords.merge("format" => Dialect::Keyword.new(mask: Dialect::STRING))
+          end
+          Dialect.new(
+            name: fallback.name,
+            uri: uri,
+            keywords: keywords,
+            ref_siblings: fallback.ref_siblings?,
+            format_assertion: format_assertion
+          )
+        end
+      end
+
+      VALIDATION_KEYWORDS = %w[
+        type enum const multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+        maxLength minLength pattern maxItems minItems uniqueItems maxContains minContains
+        maxProperties minProperties required dependentRequired
+      ].freeze
+      private_constant :VALIDATION_KEYWORDS
+
+      private def absolute_uri(base, identifier)
+        base = base.to_s
+        return base if identifier.nil?
+
+        identifier = identifier.to_s
+        return identifier if base.empty? || identifier.match?(/\A[A-Za-z][A-Za-z0-9+.-]*:/)
+        return strip_fragment(base) if identifier.empty?
+        return "#{strip_fragment(base)}#{identifier}" if identifier.start_with?("#")
+
+        URI.join(base, identifier).to_s
+      rescue URI::Error
+        begin
+          URI.join("resolve:///", base, identifier).to_s.delete_prefix("resolve:///")
+        rescue URI::Error
+          identifier
+        end
+      end
+
+      private def strip_fragment(uri)
+        index = uri.index("#")
+        index ? uri[0, index] : uri
+      end
+
+      private def fragment(uri)
+        index = uri.index("#")
+        index ? uri[(index + 1)..] : ""
+      end
+
+      private def append_segments(path, segments)
+        segments.reduce(path) do |result, segment|
+          encoded = segment.to_s
+          encoded = encoded.gsub("~", "~0") if encoded.include?("~")
+          encoded = encoded.gsub("/", "~1") if encoded.include?("/")
+          "#{result}/#{encoded}"
+        end
+      end
+
+      private def canonical_pointer(pointer)
+        return "" if pointer.empty?
+
+        tokens = pointer.split("/", -1).drop(1).map do |token|
+          decoded = token.gsub("~1", "/").gsub("~0", "~")
+          decoded.gsub("~", "~0").gsub("/", "~1")
+        end
+        "/#{tokens.join("/")}"
+      end
+
+      private def pointer_target(document, pointer)
+        pointer.split("/", -1).drop(1).reduce(document) do |current, token|
+          key = token.gsub("~1", "/").gsub("~0", "~")
+          if current.is_a?(Array)
+            unless key.match?(/\A(?:0|[1-9]\d*)\z/)
+              raise ResolutionError, "invalid JSON Pointer index #{key.inspect}"
+            end
+            current.fetch(key.to_i)
+          elsif current.is_a?(Hash)
+            current.fetch(key)
+          else
+            raise ResolutionError, "JSON Pointer traverses a scalar"
+          end
+        end
+      rescue IndexError
+        raise ResolutionError, "JSON Pointer target does not exist"
+      end
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/schema_node.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "formats"
+
+module Schemurai
+  module Internal
+    class SchemaNode
+      MISSING_SEGMENT = Object.new.freeze
+
+      attr_reader :schema, :dialect, :base_uri, :schema_path, :resource_path,
+        :keyword_mask, :document_key, :format
+      attr_accessor :resource
+
+      def initialize(schema:, dialect:, base_uri:, schema_path:, resource_path:, document_key:)
+        @schema = schema
+        @dialect = dialect
+        @base_uri = base_uri
+        @schema_path = schema_path
+        @resource_path = resource_path
+        @document_key = document_key
+        @keyword_mask = schema.is_a?(Hash) ? dialect.keyword_mask(schema) : 0
+        @format = Formats.resolve(schema["format"]) if schema.is_a?(Hash) && schema.key?("format")
+        @children = nil
+      end
+
+      def add_child(keyword, segment = MISSING_SEGMENT, child:)
+        children = (@children ||= {})
+        if segment.equal?(MISSING_SEGMENT)
+          children[keyword] = child
+        else
+          (children[keyword] ||= {})[segment] = child
+        end
+      end
+
+      def child(keyword, segment = MISSING_SEGMENT)
+        return unless @children
+        return @children[keyword] if segment.equal?(MISSING_SEGMENT)
+
+        @children.dig(keyword, segment)
+      end
+
+      def freeze
+        if @children
+          @children.each_value { |value| value.freeze if value.is_a?(Hash) }
+          @children.freeze
+        end
+        super
+      end
+
+      private_constant :MISSING_SEGMENT
+    end
+  end
+
+  private_constant :Internal
+end

data/lib/schemurai/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Schemurai
+  VERSION = "1.0.0"
+end

data/lib/schemurai.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "schemurai/version"
+require_relative "schemurai/formats"
+require_relative "schemurai/schema_graph"
+require_relative "schemurai/evaluator"
+
+module Schemurai
+  class Error < StandardError; end
+  class ResolutionError < Error; end
+  class UnsupportedFormatError < Error; end
+
+  ValidationError = Data.define(:keyword, :instance_path, :schema_path, :message) do
+    def to_h
+      {keyword: keyword, instance_path: instance_path, schema_path: schema_path, message: message}
+    end
+  end
+
+  class Result
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors.freeze
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    alias_method :success?, :valid?
+  end
+
+  class SchemaRegistry
+    def initialize(schemas: {})
+      @graph = Internal::SchemaGraph.new(schemas: schemas)
+      @shareable = false
+    end
+
+    def compile(schema, base_uri: nil, content: false, format: false)
+      raise Error, "cannot compile schemas after the registry is made shareable" if @shareable
+
+      root = @graph.compile(schema, base_uri: base_uri)
+      Validator.new(@graph, root, content: content, format: format)
+    end
+
+    def make_shareable
+      return self if @shareable
+
+      @graph.make_shareable
+      @shareable = true
+      Ractor.make_shareable(self)
+    end
+
+    def shareable?
+      @shareable
+    end
+
+    def validator_for(uri, content: false, format: false)
+      raise Error, "make_shareable must be called before retrieving validators by URI" unless @shareable
+
+      root = @graph.node_at(uri)
+      raise ResolutionError, "unregistered schema URI #{uri.inspect}" unless root
+
+      Validator.new(@graph, root, content: content, format: format)
+    end
+  end
+
+  class Validator
+    def initialize(graph, root, content:, format:)
+      @evaluator = Internal::Evaluator.new(graph, root, content: content, format: format)
+    end
+
+    def validate(instance)
+      @evaluator.validate(instance)
+    end
+
+    def valid?(instance)
+      @evaluator.valid?(instance)
+    end
+  end
+
+  module_function def compile(schema, schemas: {}, base_uri: nil, content: false, format: false)
+    SchemaRegistry.new(schemas: schemas).compile(
+      schema,
+      base_uri: base_uri,
+      content: content,
+      format: format
+    )
+  end
+
+  module_function def validate(schema, instance, schemas: {}, base_uri: nil, content: false, format: false)
+    compile(
+      schema,
+      schemas: schemas,
+      base_uri: base_uri,
+      content: content,
+      format: format
+    ).validate(instance)
+  end
+
+  module_function def valid?(schema, instance, schemas: {}, base_uri: nil, content: false, format: false)
+    compile(
+      schema,
+      schemas: schemas,
+      base_uri: base_uri,
+      content: content,
+      format: format
+    ).valid?(instance)
+  end
+end