jsi 0.8.1 → 0.9.0

data/lib/jsi/metaschema_node/bootstrap_schema.rb

@@ -8,102 +8,148 @@ module JSI
   # Schema#subschema and Schema#resource_root_subschema are the intended mechanisms to instantiate subschemas
   # and resolve references. #[] and #jsi_root_node are not implemented.
   #
-  # schema implementation modules are included on generated subclasses of BootstrapSchema by
-  # {SchemaClasses.bootstrap_schema_class}. that subclass is instantiated with a document and
-  # pointer, representing a schema.
-  #
   # BootstrapSchema does not support mutation; its document must be immutable.
   #
   # @api private
   class MetaSchemaNode::BootstrapSchema
-    include Util::FingerprintHash
+    include(Util::FingerprintHash::Immutable)
     include Schema::SchemaAncestorNode
     include Schema
-
-    class << self
-      def inspect
-        if self == MetaSchemaNode::BootstrapSchema
-          name.freeze
-        else
-          -"#{name || MetaSchemaNode::BootstrapSchema.name} (#{schema_implementation_modules.map(&:inspect).join(', ')})"
-        end
-      end
-
-      def to_s
-        inspect
-      end
-    end
+    include(Util::Pretty)
 
     # @param jsi_ptr [JSI::Ptr] pointer to the schema in the document
     # @param jsi_document [#to_hash, #to_ary, Boolean, Object] document containing the schema
     def initialize(
-        jsi_document,
+        dialect: ,
+        jsi_document: ,
         jsi_ptr: Ptr[],
-        jsi_schema_base_uri: nil
+        jsi_base_uri: nil,
+        jsi_schema_resource_ancestors: Util::EMPTY_ARY,
+        jsi_schema_dynamic_anchor_map: Schema::DynamicAnchorMap::EMPTY,
+        jsi_registry: nil
     )
-      raise(Bug, "no #schema_implementation_modules") unless respond_to?(:schema_implementation_modules)
-
-      self.jsi_ptr = jsi_ptr
-      self.jsi_document = jsi_document
-      self.jsi_schema_base_uri = jsi_schema_base_uri
-      self.jsi_schema_resource_ancestors = Util::EMPTY_ARY
-
+      @dialect = dialect
+      #chkbug fail(Bug) unless jsi_ptr.resolve_against(jsi_document).equal?(jsi_ptr)
+      @jsi_ptr = jsi_ptr
+      @jsi_document = jsi_document
+      self.jsi_base_uri = jsi_base_uri
+      self.jsi_schema_resource_ancestors = jsi_schema_resource_ancestors
+      self.jsi_schema_dynamic_anchor_map = jsi_schema_dynamic_anchor_map
+      @jsi_registry = jsi_registry
+
+      @memos = {}
       @jsi_node_content = jsi_ptr.evaluate(jsi_document)
-      #chkbug raise(Bug, 'BootstrapSchema instance must be frozen') unless jsi_node_content.frozen?
 
       super()
     end
 
+    # @return [Schema::Dialect]
+    attr_reader(:dialect)
+
     # document containing the schema content
     attr_reader :jsi_document
 
     # JSI::Ptr pointing to this schema within the document
     attr_reader :jsi_ptr
 
+    # @return [nil]
+    def jsi_root_uri
+    end
+
+    # @return [Registry, nil]
+    attr_reader(:jsi_registry)
+
     attr_reader(:jsi_node_content)
 
     # overrides {Schema#subschema}
     def subschema(subptr)
-      self.class.new(
-        jsi_document,
+      subptr = Ptr.ary_ptr(subptr).resolve_against(jsi_node_content)
+      kw = {
+        jsi_document: jsi_document,
         jsi_ptr: jsi_ptr + subptr,
-        jsi_schema_base_uri: jsi_resource_ancestor_uri,
+        jsi_base_uri: jsi_next_base_uri,
+        jsi_schema_resource_ancestors: jsi_subschema_resource_ancestors,
+        jsi_registry: jsi_registry,
+      }
+      # determine if subschema is a resource root here, for dynamic_anchor_map.
+      # done in the same manner as Base#jsi_child_dynamic_anchor_map, when child is a schema - a bootstrap schema is instantiated
+      # to check #jsi_is_resource_root?. here, though, that bootstrap schema is usually the returned subschema.
+      subschema = dialect.bootstrap_schema(**kw,
+        jsi_schema_dynamic_anchor_map: jsi_schema_dynamic_anchor_map,
       )
+      if subschema.jsi_is_resource_root?
+        # if subschema is a resource root, it should have our jsi_next_schema_dynamic_anchor_map
+        subschema = dialect.bootstrap_schema(**kw,
+          jsi_schema_dynamic_anchor_map: jsi_next_schema_dynamic_anchor_map.without_node(self, ptr: jsi_ptr + subptr),
+        )
+      end
+      subschema
     end
 
     # overrides {Schema#resource_root_subschema}
     def resource_root_subschema(ptr)
-      # BootstrapSchema does not track jsi_schema_resource_ancestors used by Schema#schema_resource_root;
-      # resource_root_subschema is always relative to the document root.
-      # BootstrapSchema also does not implement jsi_root_node or #[]. we instantiate the ptr directly
-      # rather than as a subschema from the root.
-      self.class.new(
-        jsi_document,
-        jsi_ptr: Ptr.ary_ptr(ptr),
-        jsi_schema_base_uri: nil,
+      ptr = Ptr.ary_ptr(ptr)
+      if jsi_resource_root
+        curschema = jsi_resource_root
+        remptr = ptr.resolve_against(jsi_resource_root.jsi_node_content)
+        found = true
+        while found
+          return(curschema) if remptr.empty?
+          found = false
+          curschema.each_immediate_subschema_ptr do |subptr|
+            if subptr.ancestor_of?(remptr)
+              curschema = curschema.subschema(subptr)
+              remptr = remptr.relative_to(subptr)
+              found = true
+              break
+            end
+          end
+        end
+        # ptr indicates a location where no element indicates a subschema.
+        # TODO rm support (along with reinstantiate_as) and raise(NotASchemaError) here.
+        return(curschema.subschema(remptr))
+      end
+      # no jsi_resource_root means the root is not a schema and no parent schema has an absolute uri.
+      # result schema is instantiated relative to document root.
+      dialect.bootstrap_schema(
+        jsi_document: jsi_document,
+        jsi_ptr: ptr.resolve_against(jsi_document),
+        jsi_base_uri: nil,
+        jsi_schema_resource_ancestors: Util::EMPTY_ARY,
+        jsi_schema_dynamic_anchor_map: jsi_schema_dynamic_anchor_map,
+        jsi_registry: jsi_registry,
       )
     end
 
-    # @return [String]
-    def inspect
-      -"\#<#{jsi_object_group_text.join(' ')} #{schema_content.inspect}>"
-    end
-
-    def to_s
-      inspect
+    # @param dynamic_anchor_map [Schema::DynamicAnchorMap]
+    # @return [MetaSchemaNode::BootstrapSchema]
+    private def jsi_dynamic_root_descendent(dynamic_anchor_map)
+      resource_root = jsi_resource_root
+      if resource_root
+        dialect.bootstrap_schema(
+          jsi_document: resource_root.jsi_document,
+          jsi_ptr: resource_root.jsi_ptr,
+          jsi_base_uri: resource_root.jsi_base_uri,
+          #jsi_schema_resource_ancestors: none (new root) (though that is not significant for bootstrap),
+          jsi_schema_dynamic_anchor_map: dynamic_anchor_map,
+          jsi_registry: resource_root.jsi_registry,
+        ).resource_root_subschema(jsi_ptr.relative_to(resource_root.jsi_ptr))
+      else
+        dialect.bootstrap_schema(
+          jsi_document: jsi_document,
+          jsi_ptr: jsi_ptr,
+          jsi_schema_dynamic_anchor_map: dynamic_anchor_map,
+          jsi_registry: jsi_registry,
+        )
+      end
     end
 
     # pretty-prints a representation of self to the given printer
     # @return [void]
     def pretty_print(q)
-      q.text '#<'
-      q.text jsi_object_group_text.join(' ')
-      q.group(2) {
-          q.breakable ' '
+      jsi_pp_object_group(q, jsi_object_group_text) do
           q.pp schema_content
-      }
-      q.breakable ''
-      q.text '>'
+      end
     end
 
     # @private
@@ -111,9 +157,10 @@ module JSI
     def jsi_object_group_text
       [
         self.class.name || MetaSchemaNode::BootstrapSchema.name,
-        -"(#{schema_implementation_modules.map(&:inspect).join(', ')})",
+        dialect.id ? -"(#{dialect.id})" : nil,
+        !jsi_schema_dynamic_anchor_map.empty? ? jsi_schema_dynamic_anchor_map.anchor_schemas_identifier : nil,
         jsi_ptr.uri,
-      ].freeze
+      ].compact.freeze
     end
 
     # see {Util::Private::FingerprintHash}
@@ -121,8 +168,11 @@ module JSI
     def jsi_fingerprint
       {
         class: self.class,
+        dialect: dialect,
         jsi_ptr: @jsi_ptr,
         jsi_document: @jsi_document,
+        jsi_schema_dynamic_anchor_map: jsi_schema_dynamic_anchor_map,
+        jsi_registry: jsi_registry,
       }.freeze
     end