jsi 0.0.4 → 0.4.0

data/lib/jsi/pathed_node.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module JSI
+  # including class MUST define
+  # - #node_document [Object] returning the document
+  # - #node_ptr [JSI::JSON::Pointer] returning a pointer for the node path in the document
+  # - #document_root_node [JSI::PathedNode] returning a PathedNode pointing at the document root
+  # - #parent_node [JSI::PathedNode] returning the parent node of this PathedNode
+  # - #deref [JSI::PathedNode] following a $ref
+  #
+  # given these, this module represents the node in the document at the path.
+  #
+  # 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
+  end
+
+  # module extending a {JSI::PathedNode} object when its node_content is Hash-like (responds to #to_hash)
+  module PathedHashNode
+    # yields each hash key and value of this node.
+    #
+    # each yielded key is the same as a key of the node content hash,
+    # and each yielded value is the result of self[key] (see #[]).
+    #
+    # returns an Enumerator if no block is given.
+    #
+    # @yield [Object, Object] each key and value of this hash node
+    # @return [self, Enumerator]
+    def each(&block)
+      return to_enum(__method__) { node_content_hash_pubsend(:size) } unless block_given?
+      if block.arity > 1
+        node_content_hash_pubsend(:each_key) { |k| yield k, self[k] }
+      else
+        node_content_hash_pubsend(:each_key) { |k| yield [k, self[k]] }
+      end
+      self
+    end
+
+    # @return [Hash] a hash in which each key is a key of the node_content hash and
+    #   each value is the result of self[key] (see #[]).
+    def to_hash
+      {}.tap { |h| each_key { |k| h[k] = self[k] } }
+    end
+
+    include Hashlike
+
+    # @param method_name [String, Symbol]
+    # @param *a, &b are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the node_content or its #to_hash
+    def node_content_hash_pubsend(method_name, *a, &b)
+      if node_content.respond_to?(method_name)
+        node_content.public_send(method_name, *a, &b)
+      else
+        node_content.to_hash.public_send(method_name, *a, &b)
+      end
+    end
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
+    SAFE_KEY_ONLY_METHODS.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        node_content_hash_pubsend(method_name, *a, &b)
+      end
+    end
+  end
+
+  module PathedArrayNode
+    # yields each array element of this node.
+    #
+    # each yielded element is the result of self[index] for each index of our array (see #[]).
+    #
+    # returns an Enumerator if no block is given.
+    #
+    # @yield [Object] each element of this array node
+    # @return [self, Enumerator]
+    def each
+      return to_enum(__method__) { node_content_ary_pubsend(:size) } unless block_given?
+      node_content_ary_pubsend(:each_index) { |i| yield(self[i]) }
+      self
+    end
+
+    # @return [Array] an array, the same size as the node_content, in which the
+    #   element at each index is the result of self[index] (see #[])
+    def to_ary
+      to_a
+    end
+
+    include Arraylike
+
+    # @param method_name [String, Symbol]
+    # @param *a, &b are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the node_content or its #to_ary
+    def node_content_ary_pubsend(method_name, *a, &b)
+      if node_content.respond_to?(method_name)
+        node_content.public_send(method_name, *a, &b)
+      else
+        node_content.to_ary.public_send(method_name, *a, &b)
+      end
+    end
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
+    # we override these methods from Arraylike
+    SAFE_INDEX_ONLY_METHODS.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        node_content_ary_pubsend(method_name, *a, &b)
+      end
+    end
+  end
+end

data/lib/jsi/schema.rb

@@ -1,262 +1,238 @@
-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
-    include Memoize
+  # JSI::Schema is a module which extends instances which represent JSON schemas.
+  #
+  # the content of an instance which is a JSI::Schema (referred to in this context as schema_content) is
+  # expected to be a Hash (JSON object) or a Boolean.
+  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
+
+    # 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] 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.
-    # @param schema_object [JSI::Base, #to_hash] 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::Base)
-        @schema_jsi = JSI.deep_stringify_symbol_keys(schema_object.deref)
-        @schema_node = @schema_jsi.instance
-      elsif schema_object.is_a?(JSI::JSON::HashNode)
-        @schema_jsi = nil
-        @schema_node = JSI.deep_stringify_symbol_keys(schema_object.deref)
-      elsif schema_object.respond_to?(:to_hash)
-        @schema_jsi = nil
-        @schema_node = JSI::JSON::Node.new_doc(JSI.deep_stringify_symbol_keys(schema_object))
-      else
-        raise(TypeError, "cannot instantiate Schema from: #{schema_object.pretty_inspect.chomp}")
-      end
-    end
 
-    # @return [JSI::JSON::Node] a JSI::JSON::Node for the schema
-    attr_reader :schema_node
-
-    # @return [JSI::Base, nil] a JSI for this schema, if a metaschema is known; otherwise nil
-    attr_reader :schema_jsi
-
-    # @return [JSI::Base, JSI::JSON::Node] either a JSI::Base subclass or a
-    #   JSI::JSON::Node for the schema
-    def schema_object
-      @schema_jsi || @schema_node
+      alias_method :new, :from_object
     end
 
-    # @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]
-    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.path.empty? || 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.path.empty?
+          if parent_id || node_for_id.node_ptr.root?
             done = true
           else
-            path_from_id_node.unshift(node_for_id.path.last)
+            path_from_id_node.unshift(node_for_id.node_ptr.reference_tokens.last)
             node_for_id = node_for_id.parent_node
           end
         end
         if parent_id
           parent_auri = Addressable::URI.parse(parent_id)
+          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
+
+          schema_id = parent_auri.merge(fragment: JSI::JSON::Pointer.new(path_from_id_node).fragment).to_s
+
+          schema_id
         else
-          node_for_id = schema_node.document_node
-          validator = ::JSON::Validator.new(node_for_id.content, 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 = ::JSON::Schema::Pointer.new(: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
+          nil
         end
+      end
+    end
 
-        fragment = ::JSON::Schema::Pointer.new(:reference_tokens, path_from_id_node).fragment
-        schema_id = parent_auri.to_s + fragment
+    # @return [Module] a module representing this schema. see {JSI::SchemaClasses.module_for_schema}.
+    def jsi_schema_module
+      JSI::SchemaClasses.module_for_schema(self)
+    end
 
-        schema_id
-      end
+    # @return [Class < JSI::Base] a JSI class for this one schema
+    def jsi_schema_class
+      JSI.class_for_schemas(Set[self])
+    end
+
+    # instantiates the given other_instance as a JSI::Base class for schemas matched from this schema to the
+    # other_instance.
+    #
+    # any parameters are passed to JSI::Base#initialize, but none are normally used.
+    #
+    # @return [JSI::Base] a JSI whose instance is the given instance and whose schemas are matched from this
+    #   schema.
+    def new_jsi(other_instance, *a, &b)
+      JSI.class_for_schemas(match_to_instance(other_instance)).new(other_instance, *a, &b)
     end
 
-    # @return [Class subclassing JSI::Base] shortcut for JSI.class_for_schema(schema)
-    def schema_class
-      JSI.class_for_schema(self)
+    # @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
-    # one of the subschemas that matches the given instance and returns it. if
-    # there are no matching *Of schemas, this schema is returned.
+    # checks this schema for applicators ($ref, allOf, etc.) which should be applied to the given instance.
+    # returns these as a Set of {JSI::Schema}s.
     #
-    # @param 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(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, the problems of allOf occur.
-      # matching allOf is questionable. all of the schemas must be matched but we just return the first match.
-      #   there isn't really a better answer with the current implementation. merging the schemas together
-      #   is a thought but is not practical.
-      instance = instance.deref if instance.is_a?(JSI::JSON::Node)
-      %w(oneOf allOf 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)
-            return someof_schema.match_to_instance(instance)
-          end
-        end
-      end
-      return self
+    # the returned set will contain this schema itself, unless this schema contains a $ref keyword.
+    #
+    # @param other_instance [Object] the instance to check any applicators against
+    # @return [Set<JSI::Schema>] matched applicator schemas
+    def match_to_instance(other_instance)
+      node_ptr.schema_match_ptrs_to_instance(node_document, other_instance).map do |ptr|
+        ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
+      end.to_set
     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])
-        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
-        end
+    # returns a set of subschemas of this schema for the given property name, from keywords
+    #   `properties`, `patternProperties`, and `additionalProperties`.
+    #
+    # @param property_name [String] the property name for which to find subschemas
+    # @return [Set<JSI::Schema>] subschemas of this schema for the given property_name
+    def subschemas_for_property_name(property_name)
+      jsi_memoize(:subschemas_for_property_name, property_name) do |property_name|
+        node_ptr.schema_subschema_ptrs_for_property_name(node_document, property_name).map do |ptr|
+          ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
+        end.to_set
       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'])
-        else
-          nil
-        end
+    # returns a set of subschemas of this schema for the given array index, from keywords
+    #   `items` and `additionalItems`.
+    #
+    # @param index [Integer] the array index for which to find subschemas
+    # @return [Set<JSI::Schema>] subschemas of this schema for the given array index
+    def subschemas_for_index(index)
+      jsi_memoize(:subschemas_for_index, index) do |index|
+        node_ptr.schema_subschema_ptrs_for_index(node_document, index).map do |ptr|
+          ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
+        end.to_set
       end
     end
 
-    # @return [Set] any object property names this schema indicates may be
-    #   present on its instances. this includes, if present: keys of this
-    #   schema's "properties" object; entries of this schema's array of
-    #   "required" property keys. if this schema has oneOf/allOf/anyOf
-    #   subschemas, those schemas are checked (recursively) for their
-    #   described object property names.
+    # @return [Set] any object property names this schema indicates may be present on its instances.
+    #   this includes any keys of this schema's "properties" object and any entries of this schema's
+    #   array of "required" property keys.
     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)
-          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['properties'].respond_to?(:to_hash)
+            property_names.merge(node_content['properties'].keys)
           end
-          # we _could_ look at the properties of 'default' and each 'enum' but ... nah.
-          # we should look at dependencies (TODO).
-          %w(oneOf allOf anyOf).select { |k| schema_node[k].respond_to?(:to_ary) }.each do |schemas_key|
-            schema_node[schemas_key].map(&:deref).map do |someof_node|
-              property_names.merge(self.class.new(someof_node).described_object_property_names)
-            end
+          if node_content.respond_to?(:to_hash) && node_content['required'].respond_to?(:to_ary)
+            property_names.merge(node_content['required'].to_ary)
           end
         end
       end
     end
 
-    def default_value
-      if schema_node.key?('default')
-        if schema_node['default'].respond_to?(:to_ary) || schema_node['default'].respond_to?(:to_hash)
-          schema_class.new(schema_node['default'])
-        else
-          schema_node['default']
-        end
-      else
-        nil
-      end
-    end
-
-    def default_value?
-      schema_node.key?('default')
-    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)
-      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.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)
-      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
+    def validate_instance(other_instance)
+      ::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
     #   indicate the instance is valid against this schema
     # @raise [::JSON::Schema::ValidationError] raises if the instance has
     #   validation errors against this schema
-    def validate!(instance)
-      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
+    def validate_instance!(other_instance)
+      ::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.document), [], fragment: schema_node.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.document), [], fragment: schema_node.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
@@ -264,45 +240,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.document), [], fragment: schema_node.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_node: schema_node}
-    end
-    include FingerprintHash
   end
 end