jsi 0.0.1 → 0.0.2

data/lib/jsi/base/to_rb.rb

@@ -1,5 +1,4 @@
 module JSI
-  # base class for representing an instance of an instance described by a schema
   class Base
     class << self
       def class_comment
@@ -15,7 +14,7 @@ module JSI
           lines << "#"
         end
 
-        schema.described_hash_property_names.each_with_index do |propname, i|
+        schema.described_object_property_names.each_with_index do |propname, i|
           lines << "#" unless i == 0
           lines << "# @!attribute [rw] #{propname}"
 
@@ -73,7 +72,7 @@ module JSI
           end
         end
         lines << "class #{name}"
-        schema.described_hash_property_names.each_with_index do |propname, i|
+        schema.described_object_property_names.each_with_index do |propname, i|
           lines << "" unless i == 0
           property_schema = schema['properties'].respond_to?(:to_hash) &&
             schema['properties'][propname].respond_to?(:to_hash) &&

data/lib/jsi/json-schema-fragments.rb

@@ -84,24 +84,25 @@ module JSON
       # pointed to by this pointer.
       def evaluate(document)
         reference_tokens.inject(document) do |value, token|
-          if value.is_a?(Array)
+          if value.respond_to?(:to_ary)
             if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
               token = token.to_i
             end
             unless token.is_a?(Integer)
               raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
             end
-            unless (0...value.size).include?(token)
+            unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
               raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
             end
-          elsif value.is_a?(Hash)
-            unless value.key?(token)
+            (value.respond_to?(:[]) ? value : value.to_ary)[token]
+          elsif value.respond_to?(:to_hash)
+            unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
               raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
             end
+            (value.respond_to?(:[]) ? value : value.to_hash)[token]
           else
             raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
           end
-          value[token]
         end
       end
 

data/lib/jsi/json/node.rb

@@ -2,25 +2,40 @@ module JSI
   module JSON
     # JSI::JSON::Node is an abstraction of a node within a JSON document.
     # it aims to act like the underlying data type of the node's content
-    # (Hash or Array, generally) in most cases, defining methods of Hash
-    # and Array which delegate to the content. However, destructive methods
-    # are not defined, as modifying the content of a node would change it
-    # for any other nodes in the document that contain or refer to it.
+    # (generally Hash or Array-like) in most cases.
+    #
+    # the main advantage offered by using a Node over the underlying data
+    # is in dereferencing. if a Node consists of a hash with a $ref property
+    # pointing within the same document, then the Node will transparently
+    # follow the ref and return the referenced data.
+    #
+    # in most other respects, a Node aims to act like a Hash when the content
+    # is Hash-like, an Array when the content is Array-like. methods of Hash
+    # and Array are defined and delegated to the node's content.
+    #
+    # however, destructive methods are for the most part not implemented.
+    # at the moment only #[]= is implemented. since Node thinly wraps the
+    # underlying data, you can change the data and it will be reflected in
+    # the node. implementations of destructive methods are planned.
     #
     # methods that return a modified copy such as #merge are defined, and
     # return a copy of the document with the content of the node modified.
     # the original node's document and content are untouched.
     class Node
-      # if the content of the document at the given path is a Hash, returns
-      # a HashNode; if an Array, returns ArrayNode. otherwise returns a
-      # regular Node, though, for the most part this will be called with Hash
-      # or Array content.
+      def self.new_doc(document)
+        new_by_type(document, [])
+      end
+
+      # if the content of the document at the given path is Hash-like, returns
+      # a HashNode; if Array-like, returns ArrayNode. otherwise returns a
+      # regular Node, although Nodes are for the most part instantiated from
+      # Hash or Array-like content.
       def self.new_by_type(document, path)
         node = Node.new(document, path)
         content = node.content
-        if content.is_a?(Hash)
+        if content.respond_to?(:to_hash)
           HashNode.new(document, path)
-        elsif content.is_a?(Array)
+        elsif content.respond_to?(:to_ary)
           ArrayNode.new(document, path)
         else
           node
@@ -29,9 +44,14 @@ module JSI
 
       # a Node represents the content of a document at a given path.
       def initialize(document, path)
-        raise(ArgumentError, "path must be an array. got: #{path.pretty_inspect.chomp} (#{path.class})") unless path.is_a?(Array)
+        unless path.respond_to?(:to_ary)
+          raise(ArgumentError, "path must be an array. got: #{path.pretty_inspect.chomp} (#{path.class})")
+        end
+        if document.is_a?(JSI::JSON::Node)
+          raise(TypeError, "document of a Node should not be another JSI::JSON::Node: #{document.inspect}")
+        end
         @document = document
-        @path = path.dup.freeze
+        @path = path.to_ary.dup.freeze
         @pointer = ::JSON::Schema::Pointer.new(:reference_tokens, path)
       end
 
@@ -47,60 +67,88 @@ module JSI
         pointer.evaluate(document)
       end
 
-      def [](k)
+      # returns content at the given subscript - call this the subcontent.
+      #
+      # if the content cannot be subscripted, raises TypeError.
+      #
+      # if the subcontent is Hash-like, it is wrapped as a JSI::JSON::HashNode before being returned.
+      # if the subcontent is Array-like, it is wrapped as a JSI::JSON::ArrayNode before being returned.
+      #
+      # if this node's content is a $ref - that is, a hash with a $ref attribute - and the subscript is
+      # not a key of the hash, then the $ref is followed before returning the subcontent.
+      def [](subscript)
         node = self
         content = node.content
-        if content.is_a?(Hash) && !content.key?(k)
+        if content.respond_to?(:to_hash) && !(content.respond_to?(:key?) ? content : content.to_hash).key?(subscript)
           node = node.deref
           content = node.content
         end
+        unless content.respond_to?(:[])
+          if content.respond_to?(:to_hash)
+            content = content.to_hash
+          elsif content.respond_to?(:to_ary)
+            content = content.to_ary
+          else
+            raise(NoMethodError, "undefined method `[]`\nsubscripting with #{subscript.pretty_inspect.chomp} (#{subscript.class}) from #{content.class.inspect}. content is: #{content.pretty_inspect.chomp}")
+          end
+        end
         begin
-          el = content[k]
+          subcontent = content[subscript]
         rescue TypeError => e
-          raise(e.class, e.message + "\nsubscripting with #{k.pretty_inspect.chomp} (#{k.class}) from #{content.class.inspect}. self is: #{pretty_inspect.chomp}", e.backtrace)
+          raise(e.class, e.message + "\nsubscripting with #{subscript.pretty_inspect.chomp} (#{subscript.class}) from #{content.class.inspect}. content is: #{content.pretty_inspect.chomp}", e.backtrace)
         end
-        if el.is_a?(Hash) || el.is_a?(Array)
-          self.class.new_by_type(node.document, node.path + [k])
+        if subcontent.respond_to?(:to_hash)
+          HashNode.new(node.document, node.path + [subscript])
+        elsif subcontent.respond_to?(:to_ary)
+          ArrayNode.new(node.document, node.path + [subscript])
         else
-          el
+          subcontent
         end
       end
 
-      def []=(k, v)
-        if v.is_a?(Node)
-          content[k] = v.content
+      # assigns the given subscript of the content to the given value. the document is modified in place.
+      def []=(subscript, value)
+        if value.is_a?(Node)
+          content[subscript] = value.content
         else
-          content[k] = v
+          content[subscript] = value
         end
       end
 
+      # returns a Node, dereferencing a $ref attribute if possible. if this node is not hash-like,
+      # does not have a $ref, or if what its $ref cannot be found, this node is returned.
+      #
+      # currently only $refs pointing within the same document are followed.
       def deref
         content = self.content
 
-        return self unless content.is_a?(Hash) && content['$ref'].is_a?(String)
+        if content.respond_to?(:to_hash)
+          ref = (content.respond_to?(:[]) ? content : content.to_hash)['$ref']
+        end
+        return self unless ref.is_a?(String)
 
-        if content['$ref'][/\A#/]
-          return self.class.new_by_type(document, ::JSON::Schema::Pointer.parse_fragment(content['$ref'])).deref
+        if ref[/\A#/]
+          return self.class.new_by_type(document, ::JSON::Schema::Pointer.parse_fragment(ref)).deref
         end
 
         # HAX for how google does refs and ids
         if document_node['schemas'].respond_to?(:to_hash)
-          if document_node['schemas'][content['$ref']]
-            return document_node['schemas'][content['$ref']]
+          if document_node['schemas'][ref]
+            return document_node['schemas'][ref]
           end
-          _, deref_by_id = document_node['schemas'].detect { |_k, schema| schema['id'] == content['$ref'] }
+          _, deref_by_id = document_node['schemas'].detect { |_k, schema| schema['id'] == ref }
           if deref_by_id
             return deref_by_id
           end
         end
 
-        #raise(NotImplementedError, "cannot dereference #{content['$ref']}") # TODO
+        #raise(NotImplementedError, "cannot dereference #{ref}") # TODO
         return self
       end
 
       # a Node at the root of the document
       def document_node
-        Node.new_by_type(document, [])
+        Node.new_doc(document)
       end
 
       # the parent of this node. if this node is the document root (its path is empty), raises
@@ -117,11 +165,13 @@ module JSI
       def pointer_path
         pointer.pointer
       end
+
       # the pointer fragment to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
       def fragment
         pointer.fragment
       end
 
+      # returns a jsonifiable representation of this node's content
       def as_json(*opt)
         Typelike.as_json(content, *opt)
       end
@@ -136,7 +186,7 @@ module JSI
         # or hash in the path above this node. this node's content is modified by the caller, and
         # that is recursively merged up to the document root. the recursion is done with a
         # y combinator, for no other reason than that was a fun way to implement it.
-        modified_document = JSI.ycomb do |rec|
+        modified_document = JSI::Util.ycomb do |rec|
           proc do |subdocument, subpath|
             if subpath == []
               yield(subdocument)
@@ -144,11 +194,12 @@ module JSI
               car = subpath[0]
               cdr = subpath[1..-1]
               if subdocument.respond_to?(:to_hash)
-                car_object = rec.call(subdocument[car], cdr)
-                if car_object.object_id == subdocument[car].object_id
+                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_hash)[car]
+                car_object = rec.call(subdocument_car, cdr)
+                if car_object.object_id == subdocument_car.object_id
                   subdocument
                 else
-                  subdocument.merge({car => car_object})
+                  (subdocument.respond_to?(:merge) ? subdocument : subdocument.to_hash).merge({car => car_object})
                 end
               elsif subdocument.respond_to?(:to_ary)
                 if car.is_a?(String) && car =~ /\A\d+\z/
@@ -157,11 +208,12 @@ module JSI
                 unless car.is_a?(Integer)
                   raise(TypeError, "bad subscript #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect.chomp}")
                 end
-                car_object = rec.call(subdocument[car], cdr)
-                if car_object.object_id == subdocument[car].object_id
+                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_ary)[car]
+                car_object = rec.call(subdocument_car, cdr)
+                if car_object.object_id == subdocument_car.object_id
                   subdocument
                 else
-                  subdocument.dup.tap do |arr|
+                  (subdocument.respond_to?(:[]=) ? subdocument : subdocument.to_ary).dup.tap do |arr|
                     arr[car] = car_object
                   end
                 end
@@ -174,12 +226,17 @@ module JSI
         Node.new_by_type(modified_document, path)
       end
 
+      # meta-information about the object, outside the content. used by #inspect / #pretty_print
       def object_group_text
-        "fragment=#{fragment.inspect}"
+        "fragment=#{fragment.inspect}" + (content.respond_to?(:object_group_text) ? ' ' + content.object_group_text : '')
       end
+
+      # a string representing this node
       def inspect
         "\#<#{self.class.inspect} #{object_group_text} #{content.inspect}>"
       end
+
+      # pretty-prints a representation this node to the given printer
       def pretty_print(q)
         q.instance_exec(self) do |obj|
           text "\#<#{obj.class.inspect} #{obj.object_group_text}"
@@ -194,19 +251,27 @@ module JSI
         end
       end
 
+      # fingerprint for equality (see FingerprintHash). two nodes are equal if they are both nodes
+      # (regardless of type, e.g. one may be a Node and the other may be a HashNode) within equal
+      # documents at equal paths. note that this means two nodes with the same content may not be
+      # considered equal.
       def fingerprint
         {is_node: self.is_a?(JSI::JSON::Node), document: document, path: path}
       end
       include FingerprintHash
     end
 
+    # a JSI::JSON::Node whose content is Array-like (responds to #to_ary)
+    # and includes Array methods from Arraylike
     class ArrayNode < Node
+      # iterates over each element in the same manner as Array#each
       def each
-        return to_enum(__method__) { content.size } unless block_given?
-        content.each_index { |i| yield self[i] }
+        return to_enum(__method__) { (content.respond_to?(:size) ? content : content.to_ary).size } unless block_given?
+        (content.respond_to?(:each_index) ? content : content.to_ary).each_index { |i| yield self[i] }
         self
       end
 
+      # the content of this ArrayNode, as an Array
       def to_ary
         to_a
       end
@@ -214,6 +279,7 @@ module JSI
       include Enumerable
       include Arraylike
 
+      # returns a jsonifiable representation of this node's content
       def as_json(*opt) # needs redefined after including Enumerable
         Typelike.as_json(content, *opt)
       end
@@ -221,21 +287,25 @@ module JSI
       # 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) { |*a, &b| content.public_send(method_name, *a, &b) }
+        define_method(method_name) { |*a, &b| (content.respond_to?(method_name) ? content : content.to_ary).public_send(method_name, *a, &b) }
       end
     end
 
+    # a JSI::JSON::Node whose content is Hash-like (responds to #to_hash)
+    # and includes Hash methods from Hashlike
     class HashNode < Node
+      # iterates over each element in the same manner as Array#each
       def each(&block)
-        return to_enum(__method__) { content.size } unless block_given?
+        return to_enum(__method__) { content.respond_to?(:size) ? content.size : content.to_ary.size } unless block_given?
         if block.arity > 1
-          content.each_key { |k| yield k, self[k] }
+          (content.respond_to?(:each_key) ? content : content.to_hash).each_key { |k| yield k, self[k] }
         else
-          content.each_key { |k| yield [k, self[k]] }
+          (content.respond_to?(:each_key) ? content : content.to_hash).each_key { |k| yield [k, self[k]] }
         end
         self
       end
 
+      # the content of this HashNode, as a Hash
       def to_hash
         inject({}) { |h, (k, v)| h[k] = v; h }
       end
@@ -243,13 +313,14 @@ module JSI
       include Enumerable
       include Hashlike
 
+      # returns a jsonifiable representation of this node's content
       def as_json(*opt) # needs redefined after including Enumerable
         Typelike.as_json(content, *opt)
       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) { |*a, &b| content.public_send(method_name, *a, &b) }
+        define_method(method_name) { |*a, &b| (content.respond_to?(method_name) ? content : content.to_hash).public_send(method_name, *a, &b) }
       end
     end
   end

data/lib/jsi/schema.rb

@@ -1,37 +1,50 @@
 require 'jsi/json/node'
 
 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
 
+    # 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_object = JSI.deep_stringify_symbol_keys(schema_object.deref)
-        @schema_node = @schema_object.instance
+        @schema_jsi = JSI.deep_stringify_symbol_keys(schema_object.deref)
+        @schema_node = @schema_jsi.instance
       elsif schema_object.is_a?(JSI::JSON::HashNode)
-        @schema_object = nil
+        @schema_jsi = nil
         @schema_node = JSI.deep_stringify_symbol_keys(schema_object.deref)
       elsif schema_object.respond_to?(:to_hash)
-        @schema_object = nil
-        @schema_node = JSI::JSON::Node.new_by_type(JSI.deep_stringify_symbol_keys(schema_object), [])
+        @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
-      if @schema_object
-        define_singleton_method(:instance) { schema_node } # aka schema_object.instance
-        define_singleton_method(:schema) { schema_object.schema }
-        extend BaseHash
-      else
-        define_singleton_method(:[]) { |*a, &b| schema_node.public_send(:[], *a, &b) }
-      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_object || @schema_node
+      @schema_jsi || @schema_node
+    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
     def schema_id
       @schema_id ||= begin
         # start from schema_node and ascend parents looking for an 'id' property.
@@ -87,10 +100,17 @@ module JSI
       end
     end
 
+    # @return [Class subclassing JSI::Base] shortcut for JSI.class_for_schema(schema)
     def schema_class
       JSI.class_for_schema(self)
     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.
+    #
+    # @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
@@ -109,6 +129,10 @@ module JSI
       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)
@@ -132,6 +156,9 @@ module JSI
       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)
@@ -148,44 +175,14 @@ module JSI
       end
     end
 
-    def describes_array?
-      memoize(:describes_array?) do
-        schema_node['type'] == 'array' ||
-          schema_node['items'] ||
-          schema_node['additionalItems'] ||
-          schema_node['default'].respond_to?(:to_ary) || # TODO make sure this is right
-          (schema_node['enum'].respond_to?(:to_ary) && schema_node['enum'].all? { |enum| enum.respond_to?(:to_ary) }) ||
-          schema_node['maxItems'] ||
-          schema_node['minItems'] ||
-          schema_node.key?('uniqueItems') ||
-          schema_node['oneOf'].respond_to?(:to_ary) &&
-            schema_node['oneOf'].all? { |someof_node| self.class.new(someof_node).describes_array? } ||
-          schema_node['allOf'].respond_to?(:to_ary) &&
-            schema_node['allOf'].all? { |someof_node| self.class.new(someof_node).describes_array? } ||
-          schema_node['anyOf'].respond_to?(:to_ary) &&
-            schema_node['anyOf'].all? { |someof_node| self.class.new(someof_node).describes_array? }
-      end
-    end
-    def describes_hash?
-      memoize(:describes_hash?) do
-        schema_node['type'] == 'object' ||
-          schema_node['required'].respond_to?(:to_ary) ||
-          schema_node['properties'].respond_to?(:to_hash) ||
-          schema_node['additionalProperties'] ||
-          schema_node['patternProperties'] ||
-          schema_node['default'].respond_to?(:to_hash) ||
-          (schema_node['enum'].respond_to?(:to_ary) && schema_node['enum'].all? { |enum| enum.respond_to?(:to_hash) }) ||
-          schema_node['oneOf'].respond_to?(:to_ary) &&
-            schema_node['oneOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? } ||
-          schema_node['allOf'].respond_to?(:to_ary) &&
-            schema_node['allOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? } ||
-          schema_node['anyOf'].respond_to?(:to_ary) &&
-            schema_node['anyOf'].all? { |someof_node| self.class.new(someof_node).describes_hash? }
-      end
-    end
-
-    def described_hash_property_names
-      memoize(:described_hash_property_names) do
+    # @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.
+    def described_object_property_names
+      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)
@@ -197,30 +194,65 @@ module JSI
           # 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_hash_property_names)
+              property_names.merge(self.class.new(someof_node).described_object_property_names)
             end
           end
         end
       end
     end
 
+    # @return [Array<String>] array of schema validation error messages for
+    #   the given instance against this schema
     def fully_validate(instance)
-      ::JSON::Validator.fully_validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
     end
+
+    # @return [true, false] whether the given instance validates against this schema
     def validate(instance)
-      ::JSON::Validator.validate(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.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!(schema_node.document, object_to_content(instance), fragment: schema_node.fragment)
+      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
     end
 
+    # @return [Array<String>] array of schema validation error messages 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)
+    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)
+    end
+
+    # @return [true] if this method does not raise, it returns true to
+    #   indicate this schema is valid against its metaschema
+    # @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}>"
     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}"
@@ -234,16 +266,16 @@ module JSI
         text '>'
       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
-
-    private
-    def object_to_content(object)
-      object = object.instance if object.is_a?(JSI::Base)
-      object = object.content if object.is_a?(JSI::JSON::Node)
-      object
-    end
   end
 end