jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/jsi_coder.rb

@@ -30,13 +30,15 @@ module JSI
     # @param array [Boolean] whether the dumped data represent one instance of the schema,
     #   or an array of them. note that it may be preferable to simply use an array schema.
     # @param jsi_opt [Hash] keyword arguments to pass to {Schema#new_jsi} when loading
-    def initialize(schema, array: false, jsi_opt: {})
+    # @param as_json_opt [Hash] keyword arguments to pass to `#as_json` when dumping
+    def initialize(schema, array: false, jsi_opt: Util::EMPTY_HASH, as_json_opt: Util::EMPTY_HASH)
       unless schema.respond_to?(:new_jsi)
         raise(ArgumentError, "schema param does not respond to #new_jsi: #{schema.inspect}")
       end
       @schema = schema
       @array = array
       @jsi_opt = jsi_opt
+      @as_json_opt = as_json_opt
     end
 
     # loads the database column to JSI instances of our schema
@@ -86,7 +88,7 @@ module JSI
     # @param object [JSI::Base, Object]
     # @return [Object]
     def dump_object(object)
-      JSI::Util.as_json(object)
+      JSI::Util.as_json(object, **@as_json_opt)
     end
   end
 end

data/lib/jsi/metaschema_node/bootstrap_schema.rb

@@ -1,114 +1,166 @@
 # frozen_string_literal: true
 
 module JSI
-  # internal class to bootstrap a metaschema. represents a schema without the complexity of JSI::Base. the
+  # internal class to bootstrap a meta-schema. represents a schema without the complexity of JSI::Base. the
   # schema is represented but schemas describing the schema are not.
   #
   # this class is to only be instantiated on nodes in the document that are known to be schemas.
   # 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
+  class MetaSchemaNode::BootstrapSchema
+    include(Util::FingerprintHash::Immutable)
     include Schema::SchemaAncestorNode
     include Schema
-
-    class << self
-      def inspect
-        if self == MetaschemaNode::BootstrapSchema
-          name
-        else
-          -"#{name || MetaschemaNode::BootstrapSchema.name} (#{schema_implementation_modules.map(&:inspect).join(', ')})"
-        end
-      end
-
-      alias_method :to_s, :inspect
-    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)
+      @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)
 
       super()
-
-      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
     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
 
-    def jsi_node_content
-      jsi_ptr.evaluate(jsi_document)
+    # @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}>"
+    # @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
 
-    alias_method :to_s, :inspect
-
     # 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_sub {
-        q.nest(2) {
-          q.breakable ' '
+      jsi_pp_object_group(q, jsi_object_group_text) do
           q.pp schema_content
-        }
-      }
-      q.breakable ''
-      q.text '>'
+      end
     end
 
     # @private
     # @return [Array<String>]
     def jsi_object_group_text
       [
-        self.class.name || MetaschemaNode::BootstrapSchema.name,
-        -"(#{schema_implementation_modules.map(&:inspect).join(', ')})",
+        self.class.name || MetaSchemaNode::BootstrapSchema.name,
+        dialect.id ? -"(#{dialect.id})" : nil,
+        !jsi_schema_dynamic_anchor_map.empty? ? jsi_schema_dynamic_anchor_map.anchor_schemas_identifier : nil,
         jsi_ptr.uri,
-      ]
+      ].compact.freeze
     end
 
     # see {Util::Private::FingerprintHash}
@@ -116,11 +168,18 @@ module JSI
     def jsi_fingerprint
       {
         class: self.class,
+        dialect: dialect,
         jsi_ptr: @jsi_ptr,
         jsi_document: @jsi_document,
-        jsi_schema_base_uri: jsi_schema_base_uri,
-        schema_implementation_modules: schema_implementation_modules,
-      }
+        jsi_schema_dynamic_anchor_map: jsi_schema_dynamic_anchor_map,
+        jsi_registry: jsi_registry,
+      }.freeze
+    end
+
+    private
+
+    def jsi_memomap_class
+      Util::MemoMap::Immutable
     end
   end
 end