jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/ref.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module JSI
+  # A reference to a JSI identified by a given URI.
+  class Ref
+    include(Util::Pretty)
+
+    # @param ref [#to_str] A reference URI, e.g. a `$ref` value of a referrer schema
+    # @param referrer [Base] A JSI from which the reference originated.
+    #
+    #   If the ref URI consists of only a fragment, it is resolved from the `referrer`'s
+    #   root (its {Schema::SchemaAncestorNode#jsi_resource_root} if resolving a {Schema::Ref}; its document root if not).
+    #   Otherwise the resource is found in the `referrer`'s
+    #   `#jsi_registry` (and any fragment is resolved from there).
+    # @param registry [Registry, nil] The registry in which the resource this ref refers to will be found.
+    #   If `referrer` is specified and `registry` is not, defaults to its `#jsi_registry`.
+    #   If neither is specified, {JSI.registry} is used.
+    def initialize(ref, referrer: nil, registry: (registry_undefined = true))
+      raise(ArgumentError, "ref is not a string") unless ref.respond_to?(:to_str)
+      @ref = ref
+      @ref_uri = Util.uri(ref, nnil: true)
+      @referrer = referrer && resolve_schema? ? Schema.ensure_schema(referrer) : referrer
+      @registry = !registry_undefined ? registry
+      : referrer ? referrer.jsi_registry
+      : JSI.registry
+      @resolved = nil
+    end
+
+    # @return [#to_str]
+    attr_reader :ref
+
+    # @return [URI]
+    attr_reader :ref_uri
+
+    # @return [Base, nil]
+    attr_reader(:referrer)
+
+    # @return [Registry, nil]
+    attr_reader(:registry)
+
+    # @return [Boolean]
+    def resolve_schema?
+      false
+    end
+
+    # Resolves the target of this reference.
+    # @return [JSI::Base]
+    # @raise [JSI::Schema::NotASchemaError] when the resolved target must be a Schema but is not
+    # @raise [ResolutionError] when this reference cannot be resolved
+    def resolve
+      return @resolved if @resolved
+
+      resource_root = nil
+      check_resource_root = proc {
+        unless resource_root
+          raise(ResolutionError.new([
+            "cannot resolve ref: #{ref}",
+            ("from: #{referrer.pretty_inspect.chomp}" if referrer),
+          ], uri: ref_uri))
+        end
+      }
+
+      ref_uri_nofrag = ref_uri.merge(fragment: nil)
+
+      if ref_uri_nofrag.empty?
+        unless referrer
+          raise(ResolutionError.new([
+            "cannot resolve ref: #{ref}",
+            "with no referrer",
+          ], uri: ref_uri))
+        end
+
+        # the URI only consists of a fragment (or is empty).
+        if resolve_schema?
+          # for a fragment pointer, resolve using Schema#resource_root_subschema on the referrer.
+          # for a fragment anchor, use the referrer's jsi_resource_root.
+          resource_root = referrer.jsi_resource_root # note: may be nil from bootstrap schema
+          resolve_fragment_ptr = referrer.method(:resource_root_subschema)
+        else
+          resource_root = referrer.jsi_root_node
+          resolve_fragment_ptr = resource_root.method(:jsi_descendent_node)
+        end
+      else
+        # find the resource_root from the non-fragment URI. we will resolve any fragment, either pointer or anchor, from there.
+
+        if ref_uri_nofrag.absolute?
+          ref_abs_uri = ref_uri_nofrag
+        elsif referrer && referrer.jsi_next_base_uri
+          ref_abs_uri = referrer.jsi_next_base_uri.join(ref_uri_nofrag)
+        else
+          ref_abs_uri = nil
+        end
+        if ref_abs_uri
+          unless registry
+            raise(ResolutionError.new([
+              "could not resolve remote ref with no registry specified",
+              "ref URI: #{ref_uri.to_s}",
+              ("from: #{referrer.pretty_inspect.chomp}" if referrer),
+            ], uri: ref_uri))
+          end
+          resource_root = registry.find(ref_abs_uri)
+        end
+
+        if !resource_root && resolve_schema?
+          # HAX for how google does refs and ids
+          if referrer && referrer.jsi_document.respond_to?(:to_hash) && referrer.jsi_document['schemas'].respond_to?(:to_hash)
+            referrer.jsi_document['schemas'].each do |k, v|
+              if URI[v['id']] == ref_uri_nofrag
+                resource_root = referrer.resource_root_subschema(['schemas', k])
+              end
+            end
+          end
+        end
+
+        check_resource_root.call
+
+        if resolve_schema? && resource_root.is_a?(Schema)
+          resolve_fragment_ptr = resource_root.method(:resource_root_subschema)
+        else
+          # Note: Schema#resource_root_subschema will reinstantiate nonschemas as schemas.
+          # not implemented for remote refs when the resource_root is not a schema.
+          resolve_fragment_ptr = proc { |ptr| resource_root.jsi_descendent_node(ptr) }
+        end
+      end
+
+      fragment = ref_uri.fragment
+
+      if fragment
+        begin
+          ptr_from_fragment = Ptr.from_fragment(fragment)
+        rescue Ptr::PointerSyntaxError
+        end
+      end
+
+      if ptr_from_fragment
+        begin
+          resolved = resolve_fragment_ptr.call(ptr_from_fragment)
+        rescue Ptr::ResolutionError
+          raise(ResolutionError.new([
+            "could not resolve pointer: #{ptr_from_fragment.pointer.inspect}",
+            ("from: #{referrer.pretty_inspect.chomp}" if referrer),
+            ("in resource root: #{resource_root.pretty_inspect.chomp}" if resource_root),
+          ], uri: ref_uri))
+        end
+      elsif fragment.nil?
+        check_resource_root.call
+        resolved = resource_root
+      elsif resolve_schema?
+        check_resource_root.call
+
+        # find an anchor that resembles the fragment
+        result_schemas = resource_root.jsi_anchor_subschemas(fragment)
+
+        if result_schemas.size == 1
+          resolved = result_schemas.first
+        elsif result_schemas.size == 0
+          raise(ResolutionError.new([
+            "could not resolve fragment: #{fragment.inspect}",
+            "in resource root: #{resource_root.pretty_inspect.chomp}",
+          ], uri: ref_uri))
+        else
+          raise(ResolutionError.new([
+            "found multiple schemas for plain name fragment #{fragment.inspect}:",
+            *result_schemas.map { |s| s.pretty_inspect.chomp },
+          ], uri: ref_uri))
+        end
+      else
+        raise(ResolutionError.new([
+          "could not resolve fragment #{fragment.inspect}. fragment must be a pointer.",
+          ("in resource root: #{resource_root.pretty_inspect.chomp}" if resource_root),
+        ], uri: ref_uri))
+      end
+
+      Schema.ensure_schema(resolved) { "object identified by uri #{ref} is not a schema:" } if resolve_schema?
+      return @resolved = resolved
+    end
+
+    # pretty-prints a representation of self to the given printer
+    # @return [void]
+    def pretty_print(q)
+      jsi_pp_object_group(q, [self.class.name, ref].freeze)
+    end
+
+    # see {Util::Private::FingerprintHash}
+    # @api private
+    def jsi_fingerprint
+      {
+        class: self.class,
+        ref: ref,
+        referrer: referrer,
+        registry: registry,
+      }.freeze
+    end
+
+    include(Util::FingerprintHash::Immutable)
+  end
+end

data/lib/jsi/registry.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+module JSI
+  class Registry
+    # an exception raised when an attempt is made to register a resource using a URI which is already
+    # registered with another resource
+    class Collision < StandardError
+    end
+
+    # @deprecated alias after v0.8
+    # an exception raised when a URI we are looking for has not been registered
+    ResourceNotFound = ResolutionError
+
+    # @private
+    Autoloader = Struct.subclass(:block, :mutex)
+
+    include(Util::Pretty)
+
+    def initialize
+      @resources = {}
+      @resource_autoloaders = {}
+      @vocabularies = {}
+      @vocabulary_autoloaders = {}
+      @dialects = {}
+      @dialect_autoloaders = {}
+      @mutex = Mutex.new
+    end
+
+    # registers the given resource and/or schema resources it contains in the registry.
+    #
+    # each descendent node of the resource (including the resource itself) is registered if it is a schema
+    # that has an absolute URI (generally defined by the '$id' keyword).
+    #
+    # the given resource itself will be registered, whether or not it is a schema, if it is the root
+    # of its document and was instantiated with the option `uri` specified.
+    #
+    # @param resource [JSI::Base] a JSI containing resources to register
+    # @return [void]
+    def register(resource)
+      register_immediate(resource) if !resource.is_a?(Schema)
+
+      resource.jsi_each_descendent_schema do |node|
+        register_immediate(node)
+      end
+    end
+
+    # @param node [Base, Schema]
+    # @return [void]
+    def register_immediate(node)
+      unless node.is_a?(Base) || node.is_a?(Schema)
+        raise(ArgumentError, "resource must be a #{Base}. got: #{node.pretty_inspect.chomp}")
+      end
+
+      node.jsi_resource_uris.each do |uri|
+        internal_store(@resources, @resource_autoloaders, uri, node)
+      end
+    end
+
+    # takes a URI identifying a resource to be loaded by the given block
+    # when a reference to the URI is followed.
+    #
+    # for example:
+    #
+    #     JSI.registry.autoload_uri('http://example.com/schema.json') do
+    #       JSI.new_schema({
+    #         '$schema' => 'http://json-schema.org/draft-07/schema#',
+    #         '$id' => 'http://example.com/schema.json',
+    #         'title' => 'my schema',
+    #       })
+    #     end
+    #
+    # the block would normally load JSON from the filesystem or similar.
+    #
+    # @param uri [#to_str]
+    # @yieldparam registry [Registry] (keyword) this registry
+    # @yieldparam uri [URI] (keyword) the URI being autoloaded
+    # @yieldreturn [JSI::Base] a JSI instance containing the resource identified by the given uri
+    # @return [void]
+    def autoload_uri(uri, &block)
+      internal_autoload(@resource_autoloaders, @resources, uri, block)
+    end
+
+    private def internal_autoload(autoloaders, store, uri, block)
+      uri = registration_uri(uri)
+      mutating
+      unless block
+        raise(ArgumentError, ["#{Registry} autoload must be invoked with a block", "URI: #{uri}"].join("\n"))
+      end
+      if autoloaders.key?(uri)
+        raise(Collision, ["already registered URI for autoload", "URI: #{uri}", "loader: #{autoloaders[uri].block}"].join("\n"))
+      end
+      if store.key?(uri)
+        raise(Collision, ["already registered URI", "URI: #{uri}", "existing: #{store[uri].pretty_inspect.chomp}"].join("\n"))
+      end
+      autoloaders[uri] = Autoloader.new(block: block, mutex: nil)
+      nil
+    end
+
+    # @param uri [URI, #to_str]
+    # @return [JSI::Base]
+    # @raise [ResolutionError]
+    def find(uri)
+      internal_find(uri, @resources, @resource_autoloaders, proc { |r| register(r) }, 'resource')
+    end
+
+    private def internal_find(uri, store, autoloaders, registerer, typename)
+      uri = registration_uri(uri)
+      autoloaded = nil
+      autoloader = autoloaders[uri]
+  if autoloader
+    mutating
+    @mutex.synchronize { autoloader.mutex ||= Mutex.new }
+    autoloader.mutex.synchronize do
+      if autoloaders.key?(uri) # check against race
+        autoload_param = {
+          registry: self,
+          uri: uri,
+        }
+        # remove params the autoload proc does not accept
+        autoload_param.select! do |name, _|
+          autoloaders[uri].block.parameters.any? do |type, pname|
+            # dblsplat (**k) ||   required (k: )  || optional (k: nil)
+            type == :keyrest || ((type == :keyreq || type == :key) && pname == name)
+          end
+        end
+        autoloaded = autoloaders[uri].block.call(**autoload_param)
+        registerer[autoloaded]
+      end # if autoloaders.key?(uri)
+    end # autoloader.mutex.synchronize
+  end # if autoloader
+
+      if !store.key?(uri)
+        if autoloaded
+          msg = [
+            "#{typename} URI #{uri} was registered for autoload but the result did not contain an entity with that URI.",
+            "autoload result was:",
+            autoloaded.pretty_inspect.chomp,
+          ]
+        else
+          msg = ["#{typename} URI #{uri} is not registered. registered URIs:", *(store.keys | autoloaders.keys)]
+        end
+        raise(ResolutionError.new(msg, uri: uri))
+      end
+      store[uri]
+    end
+
+    # @param uri [#to_str]
+    # @return [Boolean]
+    def registered?(uri)
+      uri = registration_uri(uri)
+      @resources.key?(uri) || @resource_autoloaders.key?(uri)
+    end
+
+    # @param vocabulary [Schema::Vocabulary]
+    # @param uri [#to_str]
+    # @return [void]
+    def register_vocabulary(vocabulary, uri: vocabulary.id)
+      raise(ArgumentError, "not a #{Schema::Vocabulary}: #{vocabulary.inspect}") if !vocabulary.is_a?(Schema::Vocabulary)
+      internal_store(@vocabularies, @vocabulary_autoloaders, uri, vocabulary)
+    end
+
+    # @param uri [#to_str]
+    # @yieldparam registry [Registry] (keyword) this registry
+    # @yieldparam uri [URI] (keyword) the URI being autoloaded
+    # @yieldreturn [Schema::Vocabulary]
+    # @return [void]
+    def autoload_vocabulary_uri(uri, &block)
+      internal_autoload(@vocabulary_autoloaders, @vocabularies, uri, block)
+    end
+
+    # @param uri [#to_str]
+    # @return [Schema::Vocabulary]
+    # @raise [ResolutionError]
+    def find_vocabulary(uri)
+      internal_find(uri, @vocabularies, @vocabulary_autoloaders, proc { |v| register_vocabulary(v, uri: uri) }, 'vocabulary')
+    end
+
+    # @param uri [#to_str]
+    # @return [Boolean]
+    def vocabulary_registered?(uri)
+      uri = registration_uri(uri)
+      @vocabularies.key?(uri) || @vocabulary_autoloaders.key?(uri)
+    end
+
+    # @param dialect [Schema::Dialect]
+    # @param uri [#to_str]
+    # @return [void]
+    def register_dialect(dialect, uri: dialect.id)
+      raise(ArgumentError, "not a #{Schema::Dialect}: #{dialect.inspect}") if !dialect.is_a?(Schema::Dialect)
+      internal_store(@dialects, @dialect_autoloaders, uri, dialect)
+    end
+
+    # @param uri [#to_str]
+    # @yieldparam registry [Registry] (keyword) this registry
+    # @yieldparam uri [URI] (keyword) the URI being autoloaded
+    # @yieldreturn [Schema::Dialect]
+    # @return [void]
+    def autoload_dialect_uri(uri, &block)
+      internal_autoload(@dialect_autoloaders, @dialects, uri, block)
+    end
+
+    # @param uri [#to_str]
+    # @return [Schema::Dialect]
+    # @raise [ResolutionError]
+    def find_dialect(uri)
+      internal_find(uri, @dialects, @dialect_autoloaders, proc { |v| register_dialect(v, uri: uri) }, 'dialect')
+    end
+
+    # @param uri [#to_str]
+    # @return [Boolean]
+    def dialect_registered?(uri)
+      uri = registration_uri(uri)
+      @dialects.key?(uri) || @dialect_autoloaders.key?(uri)
+    end
+
+    def pretty_print(q)
+      jsi_pp_object_group(q) do
+        labels_uris = [
+          ['resources', @resources.keys],
+          ['resources autoload', @resource_autoloaders.keys],
+          ['vocabularies', @vocabularies.keys],
+          ['vocabularies autoload', @vocabulary_autoloaders.keys],
+          ['dialects', @dialects.keys],
+          ['dialects autoload', @dialect_autoloaders.keys],
+        ]
+        q.seplist(labels_uris, q.method(:breakable)) do |label, uris|
+          q.text("#{label} (#{uris.size})")
+          if !uris.empty?
+            q.text(": <")
+            q.group do
+              q.nest(2) do
+                q.breakable('')
+                q.seplist(uris) do |uri|
+                  q.text(uri.to_s.inspect)
+                end
+              end
+              q.breakable('')
+            end
+            q.text '>'
+          end
+        end
+      end
+    end
+
+    def dup
+      self.class.new.tap do |reg|
+        reg.instance_variable_get(:@resources).update(@resources)
+        reg.instance_variable_get(:@resource_autoloaders).update(@resource_autoloaders)
+        reg.instance_variable_get(:@vocabularies).update(@vocabularies)
+        reg.instance_variable_get(:@vocabulary_autoloaders).update(@vocabulary_autoloaders)
+        reg.instance_variable_get(:@dialects).update(@dialects)
+        reg.instance_variable_get(:@dialect_autoloaders).update(@dialect_autoloaders)
+      end
+    end
+
+    def freeze
+      @resources.freeze
+      @resource_autoloaders.freeze
+      @vocabularies.freeze
+      @vocabulary_autoloaders.freeze
+      @dialects.freeze
+      @dialect_autoloaders.freeze
+      @mutex = nil
+      super
+    end
+
+    protected
+    # @param store [Hash]
+    # @param uri [URI]
+    # @param entity
+    # @return [void]
+    def internal_store(store, autoloaders, uri, entity)
+      mutating
+      @mutex.synchronize do
+        uri = registration_uri(uri)
+        if store.key?(uri)
+          if !store[uri].equal?(entity)
+            raise(Collision, "URI collision on #{uri}.\nexisting:\n#{store[uri].pretty_inspect.chomp}\nnew:\n#{entity.pretty_inspect.chomp}")
+          end
+        else
+          store[uri] = entity
+        end
+        autoloaders.delete(uri)
+      end
+      nil
+    end
+
+    private
+
+    # registration URIs are
+    # - absolute
+    #   - without fragment
+    #   - not relative
+    # - normalized
+    # - frozen
+    # @param uri [#to_str]
+    # @return [Addressable::URI]
+    def registration_uri(uri)
+      Util.uri(uri, nnil: true, yabs: true, tonorm: true)
+    end
+
+    def mutating
+      if frozen?
+        raise(FrozenError, "cannot modify frozen #{self.class}")
+      end
+    end
+  end
+
+  # @deprecated after v0.8
+  SchemaRegistry = Registry
+end

data/lib/jsi/schema/cxt/child_application.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JSI
+  class Schema::Cxt
+    ChildApplication = Block.subclass(*%i(
+      instance
+      token
+      collect_evaluated
+      collect_evaluated_validate
+      evaluated
+    ))
+
+    # @!attribute collect_evaluated
+    #   Does application need to collect successful child evaluation?
+    #   @return [Boolean]
+    # @!attribute evaluated
+    #   Was the child successfully evaluated by a child applicator?
+    #   @return [Boolean]
+    class ChildApplication < Block
+      # @param subschema_ptr [Ptr, #to_ary]
+      def child_subschema_applicate(subschema_ptr)
+        child_schema_applicate(schema.subschema(subschema_ptr))
+      end
+
+      # @param child_applicator_schema [Schema]
+      def child_schema_applicate(child_applicator_schema)
+        if collect_evaluated
+          self.evaluated ||= !collect_evaluated_validate || child_applicator_schema.instance_valid?(instance[token])
+        end
+
+        cxt_yield(child_applicator_schema)
+      end
+    end
+  end
+end

data/lib/jsi/schema/cxt/inplace_application.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JSI
+  class Schema::Cxt
+    InplaceApplication = Block.subclass(*%i(
+      visited_refs
+    ))
+
+    # @!attribute collect_evaluated
+    #   Does application need to collect successful child evaluation?
+    #   @return [Boolean]
+    class InplaceApplication < Block
+      # @param subschema_ptr [Ptr, #to_ary]
+      def inplace_subschema_applicate(subschema_ptr, **kw)
+        inplace_schema_applicate(schema.subschema(subschema_ptr), **kw)
+      end
+
+      # @param applicator_schema [Schema]
+      def inplace_schema_applicate(applicator_schema, **kw)
+        block.call(applicator_schema, **kw)
+      end
+
+      def instance
+        raise(Bug, "in-place application is being invoked without an instance; the current element needs action :inplace_application_requires_instance")
+      end
+
+      def collect_evaluated
+        false
+      end
+    end
+
+    InplaceApplication::WithInstance = InplaceApplication.subclass(*%i(
+      instance
+      collect_evaluated
+    ))
+  end
+end

data/lib/jsi/schema/cxt.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    Cxt = Struct.subclass(*%i(
+      schema
+      abort
+    ))
+
+    # A Schema::Cxt is the `self` of a {Schema::Element} action.
+    # @!attribute schema
+    #   The schema invoking an action in this context
+    #   @return [JSI::Schema]
+    class Cxt
+      def subschema(subptr)
+        schema.subschema(subptr)
+      end
+
+      def schema_content
+        schema.jsi_node_content
+      end
+
+      def keyword?(keyword)
+        schema.keyword?(keyword)
+      end
+
+      # @return [Boolean]
+      def keyword_value_hash?(keyword)
+        keyword?(keyword) && schema_content[keyword].respond_to?(:to_hash)
+      end
+
+      # @return [Boolean]
+      def keyword_value_ary?(keyword)
+        keyword?(keyword) && schema_content[keyword].respond_to?(:to_ary)
+      end
+
+      # @return [Boolean]
+      def keyword_value_str?(keyword)
+        keyword?(keyword) && schema_content[keyword].respond_to?(:to_str)
+      end
+
+      # @return [Boolean]
+      def keyword_value_bool?(keyword)
+        keyword?(keyword) && (schema_content[keyword] == true || schema_content[keyword] == false)
+      end
+
+      # @return [Boolean]
+      def keyword_value_numeric?(keyword)
+        keyword?(keyword) && schema_content[keyword].is_a?(Numeric)
+      end
+
+      # is `value` an integer?
+      # @return [Boolean]
+      def internal_integer?(value)
+        value.is_a?(Integer) || (!schema.dialect.conf[:integer_disallows_0_fraction] && value.is_a?(Numeric) && value % 1.0 == 0.0)
+      end
+    end
+
+    class Cxt
+      autoload(:InplaceApplication, 'jsi/schema/cxt/inplace_application')
+      autoload(:ChildApplication, 'jsi/schema/cxt/child_application')
+    end
+
+    Cxt::Block = Cxt.subclass(:block)
+
+    # @!attribute block
+    #   @return [#call]
+    class Cxt::Block < Cxt
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        def cxt_yield(*a)
+          block.call(*a)
+        end
+      else
+        def cxt_yield(*a, **kw)
+          block.call(*a, **kw)
+        end
+      end
+    end
+  end
+end