jsi 0.2.1 → 0.3.0

data/lib/jsi/metaschema.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JSI
+  module Metaschema
+    include JSI::Schema::DescribesSchema
+  end
+end

data/lib/jsi/metaschema_node.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module JSI
+  # a MetaschemaNode is a PathedNode whose node_document contains a metaschema.
+  # as with any PathedNode the node_ptr points to the content of a node.
+  # the root of the metaschema is pointed to by metaschema_root_ptr.
+  # the schema of the root of the document is pointed to by root_schema_ptr.
+  #
+  # like JSI::Base, this class represents an instance of a schema, an instance
+  # which may itself be a schema. unlike JSI::Base, the document containing the
+  # schema and the instance is the same, and a schema may be an instance of itself.
+  #
+  # the document containing the metaschema, its subschemas, and instances of those
+  # subschemas is the node_document.
+  #
+  # the schema instance is the content in the document pointed to by the MetaschemaNode's node_ptr.
+  #
+  # unlike with JSI::Base, the schema is not part of the class, since a metaschema
+  # needs the ability to have its schema be the instance itself.
+  #
+  # if the MetaschemaNode's schema is its self, it will be extended with JSI::Metaschema.
+  #
+  # a MetaschemaNode is extended with JSI::Schema when it represents a schema - this is the case when
+  # its schema is the metaschema.
+  class MetaschemaNode
+    include PathedNode
+    include Memoize
+
+    # not every MetaschemaNode is actually an Enumerable, but it's better to include Enumerable on
+    # the class than to conditionally extend the instance.
+    include Enumerable
+
+    # @param node_document the document containing the metaschema
+    # @param node_ptr [JSI::JSON::Pointer] ptr to this MetaschemaNode in node_document
+    # @param metaschema_root_ptr [JSI::JSON::Pointer] ptr to the root of the metaschema in node_document
+    # @param root_schema_ptr [JSI::JSON::Pointer] ptr to the schema of the root of the node_document
+    def initialize(node_document, node_ptr: JSI::JSON::Pointer[], metaschema_root_ptr: JSI::JSON::Pointer[], root_schema_ptr: JSI::JSON::Pointer[])
+      @node_document = node_document
+      @node_ptr = node_ptr
+      @metaschema_root_ptr = metaschema_root_ptr
+      @root_schema_ptr = root_schema_ptr
+
+      node_content = self.node_content
+
+      if node_content.respond_to?(:to_hash)
+        extend PathedHashNode
+      elsif node_content.respond_to?(:to_ary)
+        extend PathedArrayNode
+      end
+
+      instance_for_schema = node_document
+      schema_ptr = node_ptr.reference_tokens.inject(root_schema_ptr) do |ptr0, tok|
+        if instance_for_schema.respond_to?(:to_ary)
+          ptr1 = ptr0 && ptr0.schema_subschema_ptr_for_index(node_document, tok)
+        else
+          ptr1 = ptr0 && ptr0.schema_subschema_ptr_for_property_name(node_document, tok)
+        end
+        instance_for_schema = instance_for_schema[tok]
+        ptr2 = ptr1 && ptr1.deref(node_document)
+        ptr3 = ptr2 && ptr2.schema_match_ptr_to_instance(node_document, instance_for_schema)
+        ptr3 # only God may judge my variable names
+      end
+
+      @schema = if schema_ptr
+        if schema_ptr == node_ptr
+          self
+        else
+          new_node(node_ptr: schema_ptr)
+        end
+      else
+        nil
+      end
+
+      if schema_ptr
+        if schema_ptr == metaschema_root_ptr
+          extend JSI::Schema
+        end
+        if schema_ptr == node_ptr
+          extend Metaschema
+        end
+      end
+
+      if @schema
+        extend(JSI::SchemaClasses.accessor_module_for_schema(@schema, conflicting_modules: [Metaschema, Schema, MetaschemaNode, PathedArrayNode, PathedHashNode]))
+      end
+
+      # workarounds
+      begin # draft 4 boolean schema workaround
+        # in draft 4, boolean schemas are not described in the root, but on anyOf schemas on
+        # properties/additionalProperties and properties/additionalItems.
+        # we need to extend those as DescribesSchema.
+        addtlPropsanyOf = metaschema_root_ptr["properties"]["additionalProperties"]["anyOf"]
+        addtlItemsanyOf = metaschema_root_ptr["properties"]["additionalItems"]["anyOf"]
+
+        if !node_ptr.root? && [addtlPropsanyOf, addtlItemsanyOf].include?(node_ptr.parent)
+          extend JSI::Schema::DescribesSchema
+        end
+      end
+    end
+
+    # document containing the metaschema. see PathedNode#node_document.
+    attr_reader :node_document
+    # ptr to this metaschema node. see PathedNode#node_ptr.
+    attr_reader :node_ptr
+    # ptr to the root of the metaschema in the node_document
+    attr_reader :metaschema_root_ptr
+    # ptr to the schema of the root of the node_document
+    attr_reader :root_schema_ptr
+    # a JSI::Schema describing this MetaschemaNode
+    attr_reader :schema
+
+    # @return [MetaschemaNode] document root MetaschemaNode
+    def document_root_node
+      new_node(node_ptr: JSI::JSON::Pointer[])
+    end
+
+    # @return [MetaschemaNode] parent MetaschemaNode
+    def parent_node
+      new_node(node_ptr: node_ptr.parent)
+    end
+
+    # @param token [String, Integer, Object] the token to subscript
+    # @return [MetaschemaNode, Object] the node content's subscript value at the given token.
+    #   if there is a subschema defined for that token on this MetaschemaNode's schema,
+    #   returns that value as a MetaschemaNode instantiation of that subschema.
+    def [](token)
+      if respond_to?(:to_hash)
+        token_in_range = node_content_hash_pubsend(:key?, token)
+        value = node_content_hash_pubsend(:[], token)
+      elsif respond_to?(:to_ary)
+        token_in_range = node_content_ary_pubsend(:each_index).include?(token)
+        value = node_content_ary_pubsend(:[], token)
+      else
+        raise(NoMethodError, "cannot subcript (using token: #{token.inspect}) from content: #{node_content.pretty_inspect.chomp}")
+      end
+
+      jsi_memoize(:[], token, value, token_in_range) do |token, value, token_in_range|
+        if token_in_range
+          value_node = new_node(node_ptr: node_ptr[token])
+
+          if value_node.is_a?(Schema) || value.respond_to?(:to_hash) || value.respond_to?(:to_ary)
+            value_node
+          else
+            value
+          end
+        else
+          # I think I will not support Hash#default/#default_proc in this case.
+          nil
+        end
+      end
+    end
+
+    # if this MetaschemaNode is a $ref then the $ref is followed. otherwise this MetaschemaNode is returned.
+    # @return [MetaschemaNode]
+    def deref(&block)
+      node_ptr_deref do |deref_ptr|
+        return new_node(node_ptr: deref_ptr).tap(&(block || Util::NOOP))
+      end
+      return self
+    end
+
+    # @yield [Object] the node content of the instance. the block should result
+    #   in a (nondestructively) modified copy of this.
+    # @return [MetaschemaNode] modified copy of self
+    def modified_copy(&block)
+      MetaschemaNode.new(node_ptr.modified_document_copy(node_document, &block), our_initialize_params)
+    end
+
+    # @return [String]
+    def inspect
+      "\#<#{object_group_text.join(' ')} #{node_content.inspect}>"
+    end
+
+    def pretty_print(q)
+      q.text '#<'
+      q.text object_group_text.join(' ')
+      q.group_sub {
+        q.nest(2) {
+          q.breakable ' '
+          q.pp node_content
+        }
+      }
+      q.breakable ''
+      q.text '>'
+    end
+
+    # @return [Array<String>]
+    def object_group_text
+      if schema
+        class_n_schema = "#{self.class} (#{schema.node_ptr.fragment})"
+      else
+        class_n_schema = self.class.to_s
+      end
+      [
+        class_n_schema,
+        is_a?(Metaschema) ? "Metaschema" : is_a?(Schema) ? "Schema" : nil,
+        *(node_content.respond_to?(:object_group_text) ? node_content.object_group_text : []),
+      ].compact
+    end
+
+    # @return [Object] an opaque fingerprint of this MetaschemaNode for FingerprintHash
+    def jsi_fingerprint
+      {class: self.class, node_document: node_document}.merge(our_initialize_params)
+    end
+    include FingerprintHash
+
+    private
+
+    def our_initialize_params
+      {node_ptr: node_ptr, metaschema_root_ptr: metaschema_root_ptr, root_schema_ptr: root_schema_ptr}
+    end
+
+    def new_node(params)
+      MetaschemaNode.new(node_document, our_initialize_params.merge(params))
+    end
+  end
+end

data/lib/jsi/pathed_node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   # including class MUST define
   # - #node_document [Object] returning the document
@@ -10,11 +12,14 @@ module JSI
   #
   # the node content (#node_content) is the result of evaluating the node document at the path.
   module PathedNode
+    # @return [Object] the content of this node
     def node_content
       content = node_ptr.evaluate(node_document)
       content
     end
 
+    # @yield [JSI::JSON::Pointer] if a block is given (optional), this will yield a deref'd pointer
+    # @return [JSI::JSON::Pointer] our node_ptr, derefed against our node_document
     def node_ptr_deref(&block)
       node_ptr.deref(node_document, &block)
     end

data/lib/jsi/schema.rb

@@ -1,80 +1,101 @@
-require 'jsi/json/node'
+# frozen_string_literal: true
 
 module JSI
   # JSI::Schema represents a JSON Schema. initialized from a Hash-like schema
   # object, JSI::Schema is a relatively simple class to abstract useful methods
   # applied to a JSON Schema.
-  class Schema
+  module Schema
+    class Error < StandardError
+    end
+
+    # an exception raised when a thing is expected to be a JSI::Schema, but is not
+    class NotASchemaError < Error
+    end
+
     include Memoize
 
+    # JSI::Schema::DescribesSchema: a schema which describes another schema. this module
+    # extends a JSI::Schema instance and indicates that JSIs which instantiate the schema
+    # are themselves also schemas.
+    #
+    # examples of a schema which describes a schema include the draft JSON Schema metaschemas and
+    # the OpenAPI schema definition which describes "A deterministic version of a JSON Schema object."
+    module DescribesSchema
+    end
+
     class << self
+      # @return [JSI::Schema] the default metaschema
+      def default_metaschema
+        JSI::JSONSchemaOrgDraft06.schema
+      end
+
+      # @return [Array<JSI::Schema>] supported metaschemas
+      def supported_metaschemas
+        [
+          JSI::JSONSchemaOrgDraft04.schema,
+          JSI::JSONSchemaOrgDraft06.schema,
+        ]
+      end
+
+      # instantiates a given schema object as a JSI::Schema.
+      #
+      # schemas are instantiated according to their '$schema' property if specified. otherwise their schema
+      # will be the {JSI::Schema.default_metaschema}.
+      #
+      # if the given schema_object is a JSI::Base but not already a JSI::Schema, an error
+      # will be raised. JSI::Base _should_ already extend a given instance with JSI::Schema
+      # when its schema describes a schema (by extending with JSI::Schema::DescribesSchema).
+      #
       # @param schema_object [#to_hash, Boolean, JSI::Schema] an object to be instantiated as a schema.
       #   if it's already a schema, it is returned as-is.
-      # @return [JSI::Schema]
+      # @return [JSI::Schema] a JSI::Schema representing the given schema_object
       def from_object(schema_object)
         if schema_object.is_a?(Schema)
           schema_object
+        elsif schema_object.is_a?(JSI::Base)
+          raise(NotASchemaError, "the given schema_object is a JSI::Base, but is not a JSI::Schema: #{schema_object.pretty_inspect.chomp}")
+        elsif schema_object.respond_to?(:to_hash)
+          schema_object = JSI.deep_stringify_symbol_keys(schema_object)
+          if schema_object.key?('$schema') && schema_object['$schema'].respond_to?(:to_str)
+            if schema_object['$schema'] == schema_object['$id'] || schema_object['$schema'] == schema_object['id']
+              MetaschemaNode.new(schema_object)
+            else
+              metaschema = supported_metaschemas.detect { |ms| schema_object['$schema'] == ms['$id'] || schema_object['$schema'] == ms['id'] }
+              unless metaschema
+                raise(NotImplementedError, "metaschema not supported: #{schema_object['$schema']}")
+              end
+              metaschema.new_jsi(schema_object)
+            end
+          else
+            default_metaschema.new_jsi(schema_object)
+          end
+        elsif [true, false].include?(schema_object)
+          default_metaschema.new_jsi(schema_object)
         else
-          new(schema_object)
+          raise(TypeError, "cannot instantiate Schema from: #{schema_object.pretty_inspect.chomp}")
         end
       end
-    end
-
-    # initializes a schema from a given JSI::Base, JSI::JSON::Node, or hash. Boolean schemas are
-    # instantiated as their equivalent hash ({} for true and {"not" => {}} for false).
-    #
-    # @param schema_object [JSI::Base, #to_hash, Boolean] the schema
-    def initialize(schema_object)
-      if schema_object.is_a?(JSI::Schema)
-        raise(TypeError, "will not instantiate Schema from another Schema: #{schema_object.pretty_inspect.chomp}")
-      elsif schema_object.is_a?(JSI::PathedNode)
-        @schema_node = JSI.deep_stringify_symbol_keys(schema_object.deref)
-      elsif schema_object.respond_to?(:to_hash)
-        @schema_node = JSI::JSON::Node.new_doc(JSI.deep_stringify_symbol_keys(schema_object))
-      elsif schema_object == true
-        @schema_node = JSI::JSON::Node.new_doc({})
-      elsif schema_object == false
-        @schema_node = JSI::JSON::Node.new_doc({"not" => {}})
-      else
-        raise(TypeError, "cannot instantiate Schema from: #{schema_object.pretty_inspect.chomp}")
-      end
-    end
 
-    # @return [JSI::PathedNode] a JSI::PathedNode (JSI::JSON::Node or JSI::Base) for the schema
-    attr_reader :schema_node
-
-    alias_method :schema_object, :schema_node
-
-    # @return [JSI::Base, JSI::JSON::Node, Object] property value from the schema_object
-    # @param property_name [String, Object] property name to access from the schema_object
-    def [](property_name)
-      schema_object[property_name]
+      alias_method :new, :from_object
     end
 
-    # @return [String] an absolute id for the schema, with a json pointer fragment
+    # @return [String, nil] an absolute id for the schema, with a json pointer fragment. nil if
+    #   no parent of this schema defines an id.
     def schema_id
-      @schema_id ||= begin
-        # start from schema_node and ascend parents looking for an 'id' property.
+      return @schema_id if instance_variable_defined?(:@schema_id)
+      @schema_id = begin
+        # start from self and ascend parents looking for an 'id' property.
         # append a fragment to that id (appending to an existing fragment if there
         # is one) consisting of the path from that parent to our schema_node.
-        node_for_id = schema_node
+        node_for_id = self
         path_from_id_node = []
         done = false
 
         while !done
-          # TODO: track what parents are schemas. somehow.
-          # look at 'id' if node_for_id is a schema, or the document root.
-          # decide whether to look at '$id' for all parent nodes or also just schemas.
-          if node_for_id.respond_to?(:to_hash)
-            if node_for_id.node_ptr.root? || node_for_id.object_id == schema_node.object_id
-              # I'm only looking at 'id' for the document root and the schema node
-              # until I track what parents are schemas.
-              parent_id = node_for_id['$id'] || node_for_id['id']
-            else
-              # will look at '$id' everywhere since it is less likely to show up outside schemas than
-              # 'id', but it will be better to only look at parents that are schemas for this too.
-              parent_id = node_for_id['$id']
-            end
+          node_content_for_id = node_for_id.node_content
+          if node_for_id.is_a?(JSI::Schema) && node_content_for_id.respond_to?(:to_hash)
+            parent_id = node_content_for_id.key?('$id') && node_content_for_id['$id'].respond_to?(:to_str) ? node_content_for_id['$id'].to_str :
+              node_content_for_id.key?('id') && node_content_for_id['id'].respond_to?(:to_str) ? node_content_for_id['id'].to_str : nil
           end
 
           if parent_id || node_for_id.node_ptr.root?
@@ -86,40 +107,45 @@ module JSI
         end
         if parent_id
           parent_auri = Addressable::URI.parse(parent_id)
-        else
-          node_for_id = schema_node.document_root_node
-          validator = ::JSON::Validator.new(Typelike.as_json(node_for_id), nil)
-          # TODO not good instance_exec'ing into another library's ivars
-          parent_auri = validator.instance_exec { @base_schema }.uri
-        end
-        if parent_auri.fragment
-          # add onto the fragment
-          parent_id_path = JSI::JSON::Pointer.from_fragment('#' + parent_auri.fragment).reference_tokens
-          path_from_id_node = parent_id_path + path_from_id_node
-          parent_auri.fragment = nil
-        #else: no fragment so parent_id good as is
-        end
+          if parent_auri.fragment
+            # add onto the fragment
+            parent_id_path = JSI::JSON::Pointer.from_fragment('#' + parent_auri.fragment).reference_tokens
+            path_from_id_node = parent_id_path + path_from_id_node
+            parent_auri.fragment = nil
+          #else: no fragment so parent_id good as is
+          end
 
-        fragment = JSI::JSON::Pointer.new(path_from_id_node).fragment
-        schema_id = parent_auri.to_s + fragment
+          fragment = JSI::JSON::Pointer.new(path_from_id_node).fragment
+          schema_id = parent_auri.to_s + fragment
 
-        schema_id
+          schema_id
+        else
+          nil
+        end
       end
     end
 
+    # @return [Module] a module representing this schema. see {JSI::SchemaClasses.module_for_schema}.
+    def jsi_schema_module
+      JSI::SchemaClasses.module_for_schema(self)
+    end
+
     # @return [Class subclassing JSI::Base] shortcut for JSI.class_for_schema(schema)
     def jsi_schema_class
       JSI.class_for_schema(self)
     end
 
-    alias_method :schema_class, :jsi_schema_class
-
     # calls #new on the class for this schema with the given arguments. for parameters,
     # see JSI::Base#initialize documentation.
     #
     # @return [JSI::Base] a JSI whose schema is this schema and whose instance is the given instance
     def new_jsi(other_instance, *a, &b)
-      jsi_schema_class.new(other_instance, *a, &b)
+      JSI.class_for_schema(match_to_instance(other_instance)).new(other_instance, *a, &b)
+    end
+
+    # @return [Boolean] does this schema itself describe a schema?
+    def describes_schema?
+      is_a?(JSI::Schema::DescribesSchema)
     end
 
     # if this schema is a oneOf, allOf, anyOf schema, #match_to_instance finds
@@ -129,60 +155,42 @@ module JSI
     # @param other_instance [Object] the instance to which to attempt to match *Of subschemas
     # @return [JSI::Schema] a matched subschema, or this schema (self)
     def match_to_instance(other_instance)
-      # matching oneOf is good here. one schema for one instance.
-      # matching anyOf is okay. there could be more than one schema matched. it's often just one. if more
-      #   than one is a match, you just get the first one.
-      %w(oneOf anyOf).select { |k| schema_node[k].respond_to?(:to_ary) }.each do |someof_key|
-        schema_node[someof_key].map(&:deref).map do |someof_node|
-          someof_schema = self.class.new(someof_node)
-          if someof_schema.validate_instance(other_instance)
-            return someof_schema.match_to_instance(other_instance)
-          end
-        end
+      ptr = node_ptr
+      ptr = ptr.deref(node_document)
+      ptr = ptr.schema_match_ptr_to_instance(node_document, other_instance)
+      if ptr
+        ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
+      else
+        self
       end
-      return self
     end
 
-    # @param property_name_ [String] the property for which to find a subschema
-    # @return [JSI::Schema, nil] a subschema from `properties`,
-    #   `patternProperties`, or `additionalProperties` for the given
-    #    property_name
-    def subschema_for_property(property_name_)
-      memoize(:subschema_for_property, property_name_) do |property_name|
-        if schema_object['properties'].respond_to?(:to_hash) && schema_object['properties'][property_name].respond_to?(:to_hash)
-          self.class.new(schema_object['properties'][property_name])
+    # @param property_name [String] the property name for which to find a subschema
+    # @return [JSI::Schema, nil] a subschema from `properties`, `patternProperties`, or `additionalProperties` for the given token
+    def subschema_for_property(property_name)
+      jsi_memoize(:subschema_for_property, property_name) do |property_name|
+        ptr = node_ptr
+        ptr = ptr.deref(node_document)
+        ptr = ptr.schema_subschema_ptr_for_property_name(node_document, property_name)
+        if ptr
+          ptr = ptr.deref(node_document)
+          ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
         else
-          if schema_object['patternProperties'].respond_to?(:to_hash)
-            _, pattern_schema_object = schema_object['patternProperties'].detect do |pattern, _|
-              property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
-            end
-          end
-          if pattern_schema_object
-            self.class.new(pattern_schema_object)
-          else
-            if schema_object['additionalProperties'].respond_to?(:to_hash)
-              self.class.new(schema_object['additionalProperties'])
-            else
-              nil
-            end
-          end
+          nil
         end
       end
     end
 
-    # @param index_ [Integer] the index for which to find a subschema
-    # @return [JSI::Schema, nil] a subschema from `items` or
-    #   `additionalItems` for the given index
-    def subschema_for_index(index_)
-      memoize(:subschema_for_index, index_) do |index|
-        if schema_object['items'].respond_to?(:to_ary)
-          if index < schema_object['items'].size
-            self.class.new(schema_object['items'][index])
-          elsif schema_object['additionalItems'].respond_to?(:to_hash)
-            self.class.new(schema_object['additionalItems'])
-          end
-        elsif schema_object['items'].respond_to?(:to_hash)
-          self.class.new(schema_object['items'])
+    # @param index [Integer] the array index for which to find a subschema
+    # @return [JSI::Schema, nil] a subschema from `items` or `additionalItems` for the given token
+    def subschema_for_index(index)
+      jsi_memoize(:subschema_for_index, index) do |index|
+        ptr = node_ptr
+        ptr = ptr.deref(node_document)
+        ptr = ptr.schema_subschema_ptr_for_index(node_document, index)
+        if ptr
+          ptr = ptr.deref(node_document)
+          ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
         else
           nil
         end
@@ -195,33 +203,33 @@ module JSI
     #   "required" property keys. if this schema has allOf subschemas, those
     #   schemas are checked (recursively) for their described object property names.
     def described_object_property_names
-      memoize(:described_object_property_names) do
+      jsi_memoize(:described_object_property_names) do
         Set.new.tap do |property_names|
-          if schema_node['properties'].respond_to?(:to_hash)
-            property_names.merge(schema_node['properties'].keys)
+          if node_content.respond_to?(:to_hash) && node_content['properties'].respond_to?(:to_hash)
+            property_names.merge(node_content['properties'].keys)
           end
-          if schema_node['required'].respond_to?(:to_ary)
-            property_names.merge(schema_node['required'].to_ary)
+          if node_content.respond_to?(:to_hash) && node_content['required'].respond_to?(:to_ary)
+            property_names.merge(node_content['required'].to_ary)
           end
           # we should look at dependencies (TODO).
-          if schema_node['allOf'].respond_to?(:to_ary)
-            schema_node['allOf'].map(&:deref).map do |allOf_node|
-              property_names.merge(self.class.new(allOf_node).described_object_property_names)
+          if respond_to?(:to_hash) && self['allOf'].respond_to?(:to_ary)
+            self['allOf'].select{ |s| s.is_a?(JSI::Schema) }.map(&:deref).map do |allOf_schema|
+              property_names.merge(allOf_schema.described_object_property_names)
             end
           end
         end
       end
     end
 
-    # @return [Array<String>] array of schema validation error messages for
+    # @return [Array] array of schema validation errors for
     #   the given instance against this schema
-    def fully_validate_instance(other_instance)
-      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
+    def fully_validate_instance(other_instance, errors_as_objects: false)
+      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(node_document), JSI::Typelike.as_json(other_instance), fragment: node_ptr.fragment, errors_as_objects: errors_as_objects)
     end
 
     # @return [true, false] whether the given instance validates against this schema
     def validate_instance(other_instance)
-      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
+      ::JSON::Validator.validate(JSI::Typelike.as_json(node_document), JSI::Typelike.as_json(other_instance), fragment: node_ptr.fragment)
     end
 
     # @return [true] if this method does not raise, it returns true to
@@ -229,19 +237,19 @@ module JSI
     # @raise [::JSON::Schema::ValidationError] raises if the instance has
     #   validation errors against this schema
     def validate_instance!(other_instance)
-      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
+      ::JSON::Validator.validate!(JSI::Typelike.as_json(node_document), JSI::Typelike.as_json(other_instance), fragment: node_ptr.fragment)
     end
 
-    # @return [Array<String>] array of schema validation error messages for
+    # @return [Array] array of schema validation errors for
     #   this schema, validated against its metaschema. a default metaschema
     #   is assumed if the schema does not specify a $schema.
-    def fully_validate_schema
-      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
+    def fully_validate_schema(errors_as_objects: false)
+      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(node_document), [], fragment: node_ptr.fragment, validate_schema: true, list: true, errors_as_objects: errors_as_objects)
     end
 
     # @return [true, false] whether this schema validates against its metaschema
     def validate_schema
-      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
+      ::JSON::Validator.validate(JSI::Typelike.as_json(node_document), [], fragment: node_ptr.fragment, validate_schema: true, list: true)
     end
 
     # @return [true] if this method does not raise, it returns true to
@@ -249,45 +257,14 @@ module JSI
     # @raise [::JSON::Schema::ValidationError] raises if this schema has
     #   validation errors against its metaschema
     def validate_schema!
-      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
-    end
-
-    # @return [String] a string for #instance and #pretty_print including the schema_id
-    def object_group_text
-      "schema_id=#{schema_id}"
-    end
-
-    # @return [String] a string representing this Schema
-    def inspect
-      "\#<#{self.class.inspect} #{object_group_text} #{schema_object.inspect}>"
+      ::JSON::Validator.validate!(JSI::Typelike.as_json(node_document), [], fragment: node_ptr.fragment, validate_schema: true, list: true)
     end
-    alias_method :to_s, :inspect
 
-    # pretty-prints a representation this Schema to the given printer
-    # @return [void]
-    def pretty_print(q)
-      q.instance_exec(self) do |obj|
-        text "\#<#{obj.class.inspect} #{obj.object_group_text}"
-        group_sub {
-          nest(2) {
-            breakable ' '
-            pp obj.schema_object
-          }
-        }
-        breakable ''
-        text '>'
+    private
+    def jsi_ensure_subschema_is_schema(subschema, ptr)
+      unless subschema.is_a?(JSI::Schema)
+        raise(NotASchemaError, "subschema not a schema at ptr #{ptr.inspect}: #{subschema.pretty_inspect.chomp}")
       end
     end
-
-    # @return [Object] returns a jsonifiable representation of this schema
-    def as_json(*opt)
-      Typelike.as_json(schema_object, *opt)
-    end
-
-    # @return [Object] an opaque fingerprint of this Schema for FingerprintHash
-    def fingerprint
-      {class: self.class, schema_ptr: schema_node.node_ptr, schema_document: JSI::Typelike.as_json(schema_node.node_document)}
-    end
-    include FingerprintHash
   end
 end