senko 0.1.0

data/lib/senko/compiler/ref_resolver.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Senko
+  class Compiler
+    ResolvedRef = Struct.new(:schema, :keyword_location, :base_uri, :scope, keyword_init: true)
+
+    class RefResolver
+      ROOT_SCOPE = :__senko_root__
+      BUILTIN_METASCHEMA_URIS = [
+        'https://json-schema.org/draft/2020-12/schema',
+        'https://json-schema.org/draft/2020-12/schema#',
+        'https://json-schema.org/draft/2019-09/schema',
+        'https://json-schema.org/draft/2019-09/schema#',
+        'http://json-schema.org/draft-07/schema',
+        'http://json-schema.org/draft-07/schema#',
+        'http://json-schema.org/draft-06/schema',
+        'http://json-schema.org/draft-06/schema#',
+        'http://json-schema.org/draft-04/schema',
+        'http://json-schema.org/draft-04/schema#'
+      ].freeze
+
+      def initialize(root_schema, schemas: {}, ref_resolver: nil)
+        @root_schema = root_schema
+        @schemas = {}
+        schemas.each do |uri, schema|
+          @schemas[uri.to_s] = registered_schema(uri.to_s, schema)
+        end
+        @ref_resolver = ref_resolver
+        @resources = {}
+        @locations = {}
+        @schema_scopes = {}
+        @resource_scopes = {}
+        @anchors = {}
+        @dynamic_anchors = {}
+        @base_by_location = {}
+        @scope_base = {}
+        index_schema(@root_schema, '', root_base_uri, ROOT_SCOPE)
+        index_registered_schemas
+      end
+
+      def resolve(uri, from: '', scope: ROOT_SCOPE)
+        uri = uri.to_s
+        base_uri = base_for(from, scope)
+        absolute = absolute_ref(uri, base_uri)
+        if absolute.empty? || absolute == '#'
+          return ResolvedRef.new(schema: @root_schema, keyword_location: '', base_uri: root_base_uri, scope: ROOT_SCOPE)
+        end
+
+        base, fragment = split_fragment(absolute)
+        schema, target_scope = schema_for_base(base)
+        unless fragment
+          return ResolvedRef.new(
+            schema: schema,
+            keyword_location: location_for_schema(schema),
+            base_uri: base,
+            scope: target_scope
+          )
+        end
+
+        resolve_fragment(schema, fragment, base, target_scope)
+      end
+
+      def resolve_dynamic(uri, from: '', scope: ROOT_SCOPE)
+        uri = uri.to_s
+        base_uri = base_for(from, scope)
+        absolute = absolute_ref(uri, base_uri)
+        base, fragment = split_fragment(absolute)
+        anchor = URI::DEFAULT_PARSER.unescape(fragment.to_s)
+
+        if !anchor.empty? && !anchor.start_with?('/') && @dynamic_anchors.key?([base, anchor])
+          return @dynamic_anchors.fetch([base, anchor])
+        end
+
+        resolve(uri, from: from, scope: scope)
+      end
+
+      def base_uri_for(location, scope)
+        base_for(location, scope)
+      end
+
+      def dynamic_anchors_for(base_uri)
+        @dynamic_anchors.each_with_object({}) do |((base, anchor), resolved), result|
+          result[anchor] = resolved if base == base_uri
+        end
+      end
+
+      private
+
+      def base_for(location, scope)
+        @base_by_location.fetch([scope, location]) { @scope_base.fetch(scope, root_base_uri) }
+      end
+
+      def root_base_uri
+        schema_id = @root_schema.is_a?(Hash) ? @root_schema['$id'].to_s : ''
+        split_fragment(schema_id).first.to_s
+      end
+
+      def absolute_ref(uri, base_uri)
+        return uri if uri.empty?
+        return "#{base_uri}#{uri}" if uri.start_with?('#') && !base_uri.to_s.empty?
+        return uri if uri.start_with?('#')
+        return uri if uri.match?(/\A[a-z][a-z0-9+\-.]*:/i)
+        return uri if base_uri.to_s.empty?
+
+        URI.join(base_uri, uri).to_s
+      rescue URI::InvalidURIError
+        uri
+      end
+
+      def schema_for_base(base_uri)
+        return [@root_schema, ROOT_SCOPE] if base_uri.to_s.empty?
+        return [@resources[base_uri], @resource_scopes.fetch(base_uri)] if @resources.key?(base_uri)
+        if @schemas.key?(base_uri)
+          return [@schemas[base_uri],
+                  @schema_scopes.fetch(@schemas[base_uri].object_id, base_uri)]
+        end
+
+        schema = fetch_remote_schema(base_uri)
+        if schema
+          @schemas[base_uri] = schema
+          index_schema(schema, '', base_uri, base_uri)
+          return [schema, @schema_scopes.fetch(schema.object_id, base_uri)]
+        end
+
+        raise UnresolvableRefError, "unable to resolve ref #{base_uri.inspect}"
+      end
+
+      def fetch_remote_schema(uri)
+        return nil unless @ref_resolver
+
+        deep_stringify(@ref_resolver.call(uri))
+      end
+
+      def registered_schema(uri, schema)
+        return builtin_metaschema(uri) if schema == true && BUILTIN_METASCHEMA_URIS.include?(uri)
+
+        deep_stringify(schema)
+      end
+
+      def builtin_metaschema(uri)
+        {
+          '$id' => split_fragment(uri).first,
+          '$schema' => 'https://json-schema.org/draft/2020-12/schema',
+          'type' => %w[object boolean],
+          'properties' => {
+            'type' => {
+              'anyOf' => [
+                { 'enum' => json_type_names },
+                { 'type' => 'array', 'items' => { 'enum' => json_type_names } }
+              ]
+            },
+            'enum' => { 'type' => 'array' },
+            'const' => true,
+            'multipleOf' => { 'type' => 'number', 'exclusiveMinimum' => 0 },
+            'maximum' => { 'type' => 'number' },
+            'exclusiveMaximum' => { 'type' => 'number' },
+            'minimum' => { 'type' => 'number' },
+            'exclusiveMinimum' => { 'type' => 'number' },
+            'maxLength' => non_negative_integer_schema,
+            'minLength' => non_negative_integer_schema,
+            'pattern' => { 'type' => 'string' },
+            'maxItems' => non_negative_integer_schema,
+            'minItems' => non_negative_integer_schema,
+            'uniqueItems' => { 'type' => 'boolean' },
+            'maxContains' => non_negative_integer_schema,
+            'minContains' => non_negative_integer_schema,
+            'maxProperties' => non_negative_integer_schema,
+            'minProperties' => non_negative_integer_schema,
+            'required' => string_array_schema,
+            '$defs' => schema_map_schema,
+            'definitions' => schema_map_schema,
+            'properties' => schema_map_schema,
+            'patternProperties' => schema_map_schema,
+            'dependentRequired' => {
+              'type' => 'object',
+              'additionalProperties' => string_array_schema
+            },
+            'dependentSchemas' => schema_map_schema,
+            'propertyNames' => { '$ref' => '#' },
+            'items' => { '$ref' => '#' },
+            'additionalItems' => { '$ref' => '#' },
+            'additionalProperties' => { '$ref' => '#' },
+            'contains' => { '$ref' => '#' },
+            'not' => { '$ref' => '#' },
+            'if' => { '$ref' => '#' },
+            'then' => { '$ref' => '#' },
+            'else' => { '$ref' => '#' },
+            'unevaluatedItems' => { '$ref' => '#' },
+            'unevaluatedProperties' => { '$ref' => '#' },
+            'allOf' => schema_array_schema,
+            'anyOf' => schema_array_schema,
+            'oneOf' => schema_array_schema,
+            'prefixItems' => schema_array_schema
+          },
+          'additionalProperties' => true
+        }
+      end
+
+      def json_type_names
+        %w[null boolean object array number string integer]
+      end
+
+      def non_negative_integer_schema
+        { 'type' => 'integer', 'minimum' => 0 }
+      end
+
+      def string_array_schema
+        { 'type' => 'array', 'items' => { 'type' => 'string' } }
+      end
+
+      def schema_array_schema
+        { 'type' => 'array', 'items' => { '$ref' => '#' } }
+      end
+
+      def schema_map_schema
+        { 'type' => 'object', 'additionalProperties' => { '$ref' => '#' } }
+      end
+
+      def split_fragment(uri)
+        index = uri.index('#')
+        return [uri, nil] unless index
+
+        [uri[0...index], uri[(index + 1)..]]
+      end
+
+      def resolve_fragment(schema, fragment, base_uri, scope)
+        decoded = URI::DEFAULT_PARSER.unescape(fragment.to_s)
+        if decoded.empty?
+          return ResolvedRef.new(
+            schema: schema,
+            keyword_location: location_for_schema(schema),
+            base_uri: base_uri,
+            scope: scope
+          )
+        end
+        return resolve_pointer(schema, decoded, base_uri, scope) if decoded.start_with?('/')
+
+        resolve_anchor(schema, decoded, base_uri, scope)
+      end
+
+      def resolve_pointer(schema, pointer, base_uri, scope)
+        current = schema
+        location = location_for_schema(schema)
+
+        pointer.split('/', -1)[1..].each do |raw_token|
+          token = unescape_pointer_token(raw_token)
+          current = pointer_child(current, token, pointer)
+          location = join_pointer(location, token)
+        end
+
+        ResolvedRef.new(schema: current, keyword_location: location, base_uri: base_uri, scope: scope)
+      end
+
+      def pointer_child(current, token, pointer)
+        if current.is_a?(Hash)
+          raise UnresolvableRefError, "unable to resolve JSON Pointer #{pointer.inspect}" unless current.key?(token)
+
+          current[token]
+        elsif current.is_a?(Array)
+          index = Integer(token, exception: false)
+          unless index && index >= 0 && index < current.length
+            raise UnresolvableRefError,
+                  "unable to resolve JSON Pointer #{pointer.inspect}"
+          end
+
+          current[index]
+        else
+          raise UnresolvableRefError, "unable to resolve JSON Pointer #{pointer.inspect}"
+        end
+      end
+
+      def resolve_anchor(schema, anchor, base_uri, scope)
+        found = @anchors[[base_uri, anchor]] || @anchors[['', anchor]]
+        return found if found
+
+        found = find_anchor(schema, anchor, location_for_schema(schema), base_uri, scope)
+        raise UnresolvableRefError, "unable to resolve anchor #{anchor.inspect}" unless found
+
+        found
+      end
+
+      def find_anchor(value, anchor, location, base_uri, scope)
+        if value.is_a?(Hash)
+          if value['$anchor'] == anchor || value['$dynamicAnchor'] == anchor
+            return ResolvedRef.new(schema: value, keyword_location: location, base_uri: base_uri, scope: scope)
+          end
+
+          value.each do |key, child|
+            found = find_anchor(child, anchor, join_pointer(location, key), base_uri, scope)
+            return found if found
+          end
+        elsif value.is_a?(Array)
+          value.each_with_index do |child, index|
+            found = find_anchor(child, anchor, join_pointer(location, index.to_s), base_uri, scope)
+            return found if found
+          end
+        end
+
+        nil
+      end
+
+      def index_registered_schemas
+        @schemas.each do |uri, schema|
+          scope = split_fragment(uri).first
+          index_schema(schema, '', scope, scope)
+        end
+      end
+
+      def index_schema(value, location, current_base, scope)
+        return unless value.is_a?(Hash)
+
+        @scope_base[scope] ||= current_base
+        next_base = schema_base_uri(value, current_base)
+        @base_by_location[[scope, location]] = next_base
+        if !next_base.to_s.empty? && (location.empty? || value.key?('$id'))
+          @resources[next_base] = value
+          @resource_scopes[next_base] = scope
+        end
+        @locations[value.object_id] = location
+        @schema_scopes[value.object_id] = scope
+        index_anchor(value, '$anchor', @anchors, location, next_base, scope)
+        index_anchor(value, '$dynamicAnchor', @dynamic_anchors, location, next_base, scope)
+
+        schema_children(value).each do |child_location, child|
+          index_schema(child, join_pointer(location, *Array(child_location)), next_base, scope)
+        end
+      end
+
+      def schema_children(schema)
+        children = []
+        schema.each do |key, child|
+          key = key.to_s
+          if schema_value_keyword?(key)
+            children << [key, child] if child.is_a?(Hash)
+          elsif schema_array_keyword?(key) && child.is_a?(Array)
+            child.each_with_index { |item, index| children << [[key, index.to_s], item] if item.is_a?(Hash) }
+          elsif schema_map_keyword?(key) && child.is_a?(Hash)
+            child.each { |name, item| children << [[key, name.to_s], item] if item.is_a?(Hash) }
+          elsif key == 'dependencies' && child.is_a?(Hash)
+            child.each { |name, item| children << [[key, name.to_s], item] if item.is_a?(Hash) }
+          end
+        end
+        children
+      end
+
+      def schema_value_keyword?(key)
+        %w[
+          items additionalItems additionalProperties propertyNames contains not if then else
+          unevaluatedProperties unevaluatedItems
+        ].include?(key)
+      end
+
+      def schema_array_keyword?(key)
+        %w[allOf anyOf oneOf prefixItems].include?(key)
+      end
+
+      def schema_map_keyword?(key)
+        %w[properties patternProperties $defs definitions dependentSchemas].include?(key)
+      end
+
+      def index_anchor(schema, keyword, index, location, base_uri, scope)
+        anchor = schema[keyword]
+        return unless anchor.is_a?(String)
+
+        index[[base_uri, anchor]] =
+          ResolvedRef.new(schema: schema, keyword_location: location, base_uri: base_uri, scope: scope)
+      end
+
+      def schema_base_uri(schema, current_base)
+        return current_base unless schema.key?('$id')
+
+        id = schema['$id'].to_s
+        resolved = current_base.to_s.empty? ? id : URI.join(current_base, id).to_s
+        split_fragment(resolved).first
+      rescue URI::InvalidURIError
+        id
+      end
+
+      def location_for_schema(schema)
+        @locations.fetch(schema.object_id, '')
+      end
+
+      def deep_stringify(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, child), result|
+            result[key.to_s] = deep_stringify(child)
+          end
+        when Array
+          value.map { |child| deep_stringify(child) }
+        else
+          value
+        end
+      end
+
+      def unescape_pointer_token(token)
+        token.gsub('~1', '/').gsub('~0', '~')
+      end
+
+      def join_pointer(base, *tokens)
+        tokens.reduce(base) do |memo, token|
+          "#{memo}/#{token.to_s.gsub('~', '~0').gsub('/', '~1')}"
+        end
+      end
+    end
+  end
+end