jsi 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44d076885e1c4e9335d334262468bc6a8e21840801af3cf7a93dde6d449fcaac
-  data.tar.gz: 9a454e1f36b9fab3b03b1e51fea21c81838483bb515aa1fb109655d7008ba209
+  metadata.gz: 42c370e01587ddef37138ffb1aacc4cd6240de94c0bbd9d61e96cafcb6ba829d
+  data.tar.gz: 9e26e8e2e8d78a05018302beff7190f33e0243d4f6899f5c3f1d046ccaaa3869
 SHA512:
-  metadata.gz: 9e7ddc4b0388d64a99de5b4a79e22bbbcc9067b207e6bbcc056ddcb39c63c574b82b4ceee715d44a89c51c39006587550e60fee01e4b5b6093b70db9206c49b7
-  data.tar.gz: d16369c5b70ce80240e50d7b7f558a3c6e82099c03d7a8928e4a064489bb08f9878dc356861afbfc798a0c5a302892a8a2d2c2e16e4b220fca05a79846c95eb6
+  metadata.gz: 75c5220df82e30b9332fba96d10463ee07cc52ff60cf8dc44963dd70c2472d279180659ab782098b5bcc9066dd000e07f60b1e7fa616215bfe6e6bfa11eddcb4
+  data.tar.gz: 848ac231235bebf262502fb7966265ab6c5e477bd6bb4acab038793dd5727a357f70482a3092e161cecc76eff4b126d4cdd7841965747fc2429ee76b5121128c

data/.simplecov

@@ -1 +1,3 @@
-SimpleCov.start
+SimpleCov.start do
+  coverage_dir '{coverage}'
+end

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.4.0
+
+- a JSI::Base has multiple jsi_schemas https://github.com/notEthan/jsi/pull/88
+  - JSI.class_for_schemas replaces JSI.class_for_schema
+- fix uri/fragment nomenclature https://github.com/notEthan/jsi/pull/89
+
 # v0.3.0
 
 - a schema is a JSI instance of a metaschema
@@ -5,6 +11,7 @@
 - module JSI::Metaschema
 - class JSI::MetaschemaNode
 - JSI::JSON::Node breaking changes
+- module SimpleWrap https://github.com/notEthan/jsi/pull/87
 
 # v0.2.1
 

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copright © [Ethan](https://github.com/notEthan/)
+Copright © [Ethan](https://github.com/notEthan/) <ethan.jsi@unth.net>
 
 [<img align="right" src="https://github.com/notEthan/jsi/raw/master/resources/icons/AGPL-3.0.png">](https://www.gnu.org/licenses/agpl-3.0.html)
 

data/README.md

@@ -226,6 +226,6 @@ Issues and pull requests are welcome on GitHub at https://github.com/notEthan/js
 
 [<img align="right" src="https://github.com/notEthan/jsi/raw/master/resources/icons/AGPL-3.0.png">](https://www.gnu.org/licenses/agpl-3.0.html)
 
-JSI is Open Source Software licensed under the terms of the [GNU Affero General Public License version 3](https://www.gnu.org/licenses/agpl-3.0.html).
+JSI is licensed under the terms of the [GNU Affero General Public License version 3](https://www.gnu.org/licenses/agpl-3.0.html).
 
 Unlike the MIT or BSD licenses more commonly used with Ruby gems, this license requires that if you modify JSI and propagate your changes, e.g. by including it in a web application, your modified version must be publicly available. The common path of forking on Github should satisfy this requirement.

data/lib/jsi.rb

@@ -3,13 +3,21 @@
 require "jsi/version"
 require "pp"
 require "set"
+require "json"
 require "pathname"
+require "addressable/uri"
+
 require "jsi/json-schema-fragments"
+
 require "jsi/util"
+require "jsi/typelike_modules"
 
 module JSI
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
+  #
+  # if you've found this class because JSI has raised this error, please open an issue with the backtrace
+  # and any context you can provide at https://github.com/notEthan/jsi/issues
   class Bug < NotImplementedError
   end
 
@@ -23,8 +31,6 @@ module JSI
   autoload :Arraylike, 'jsi/typelike_modules'
   autoload :Schema, 'jsi/schema'
   autoload :Base, 'jsi/base'
-  autoload :BaseArray, 'jsi/base'
-  autoload :BaseHash, 'jsi/base'
   autoload :Metaschema, 'jsi/metaschema'
   autoload :MetaschemaNode, 'jsi/metaschema_node'
   autoload :SchemaClasses, 'jsi/schema_classes'
@@ -35,10 +41,10 @@ module JSI
 
   autoload :SimpleWrap, 'jsi/simple_wrap'
 
-  # @return [Class subclassing JSI::Base] a JSI class which represents the
-  #   given schema. instances of the class represent JSON Schema instances
-  #   for the given schema.
-  def self.class_for_schema(*a, &b)
-    SchemaClasses.class_for_schema(*a, &b)
+  # @param schemas [Enumerable<JSI::Schema, #to_hash, Boolean>] schemas to represent with the class
+  # @return [Class subclassing JSI::Base] a JSI class which represents the given schemas.
+  #   an instance of the class represents a JSON Schema instance described by all of the given schemas.
+  def self.class_for_schemas(*schemas)
+    SchemaClasses.class_for_schemas(*schemas)
   end
 end

data/lib/jsi/base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'jsi/typelike_modules'
-
 module JSI
   # the base class for representing and instantiating a JSON Schema.
   #
@@ -13,9 +10,11 @@ module JSI
   # are dynamically created for schemas using {JSI.class_for_schema}, and these
   # are what are used to instantiate and represent JSON schema instances.
   class Base
-    include Memoize
+    include Util::Memoize
     include Enumerable
     include PathedNode
+    class CannotSubscriptError < StandardError
+    end
 
     class << self
       # JSI::Base.new_jsi behaves the same as .new, and is defined for compatibility so you may call #new_jsi
@@ -33,43 +32,71 @@ module JSI
         @in_schema_classes
       end
 
-      # @return [String] absolute schema_id of the schema this class represents.
-      #   see {Schema#schema_id}.
-      def schema_id
-        schema.schema_id
-      end
-
-      # @return [String] a string representing the class, with schema_id or schema ptr fragment
+      # @return [String] a string representing the class, indicating the schemas represented by their module
+      #   name or a URI
       def inspect
-        if !respond_to?(:schema)
+        if !respond_to?(:jsi_class_schemas)
           super
         else
-          idfrag = schema_id || schema.node_ptr.fragment
+          schema_names = jsi_class_schemas.map do |schema|
+            mod = schema.jsi_schema_module
+            if mod.name && schema.schema_id
+              "#{mod.name} (#{schema.schema_id})"
+            elsif mod.name
+              mod.name
+            elsif schema.schema_id
+              schema.schema_id
+            else
+              schema.node_ptr.uri
+            end
+          end
+
           if name && !in_schema_classes
-            "#{name} (#{idfrag})"
+            if jsi_class_schemas.empty?
+              "#{name} (0 schemas)"
+            else
+              "#{name} (#{schema_names.join(', ')})"
+            end
           else
-            "(JSI Schema Class: #{idfrag})"
+            if schema_names.empty?
+              "(JSI Schema Class for 0 schemas)"
+            else
+              "(JSI Schema Class: #{schema_names.join(', ')})"
+            end
           end
         end
       end
 
       alias_method :to_s, :inspect
 
-      # @return [String] a name for a constant for this class, generated from the
-      #   schema_id. only used if the class is not assigned to another constant.
+      # @return [String, nil] a name for a constant for this class, generated from the constant name
+      #   or schema id of each schema this class represents. nil if any represented schema has no constant
+      #   name or schema id.
       def schema_classes_const_name
-        if schema_id
-          'X' + schema_id.gsub(/[^\w]/, '_')
+        if respond_to?(:jsi_class_schemas)
+          schema_names = jsi_class_schemas.map do |schema|
+            if schema.jsi_schema_module.name
+              schema.jsi_schema_module.name
+            elsif schema.schema_id
+              schema.schema_id
+            else
+              nil
+            end
+          end
+          if !schema_names.any?(&:nil?) && !schema_names.empty?
+            schema_names.sort.map { |n| 'X' + n.gsub(/[^\w]/, '_') }.join('')
+          end
         end
       end
 
       # @return [String] a constant name of this class
       def name
         unless instance_variable_defined?(:@in_schema_classes)
-          if super || !schema_id || SchemaClasses.const_defined?(schema_classes_const_name)
+          const_name = schema_classes_const_name
+          if super || !const_name || SchemaClasses.const_defined?(const_name)
             @in_schema_classes = false
           else
-            SchemaClasses.const_set(schema_classes_const_name, self)
+            SchemaClasses.const_set(const_name, self)
             @in_schema_classes = true
           end
         end
@@ -95,8 +122,8 @@ module JSI
     #   iff `jsi_document` is passed, i.e. when `instance` is `NOINSTANCE`
     # @param jsi_root_node [JSI::Base] for internal use, specifies the JSI at the root of the document
     def initialize(instance, jsi_document: nil, jsi_ptr: nil, jsi_root_node: nil)
-      unless respond_to?(:schema)
-        raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #schema. please use JSI.class_for_schema")
+      unless respond_to?(:jsi_schemas)
+        raise(TypeError, "cannot instantiate #{self.class.inspect} which has no method #jsi_schemas. it is recommended to instantiate JSIs from a schema using JSI::Schema#new_jsi.")
       end
 
       if instance.is_a?(JSI::Schema)
@@ -126,17 +153,20 @@ module JSI
       else
         raise(Bug, 'incorrect usage') if jsi_document || jsi_ptr || jsi_root_node
         @jsi_document = instance
-        @jsi_ptr = JSI::JSON::Pointer.new([])
+        @jsi_ptr = JSI::JSON::Pointer[]
         @jsi_root_node = self
       end
 
       if self.jsi_instance.respond_to?(:to_hash)
-        extend BaseHash
+        extend PathedHashNode
       elsif self.jsi_instance.respond_to?(:to_ary)
-        extend BaseArray
+        extend PathedArrayNode
       end
-      if self.schema.describes_schema?
-        extend JSI::Schema
+
+      jsi_schemas.each do |schema|
+        if schema.describes_schema?
+          extend JSI::Schema
+        end
       end
     end
 
@@ -153,11 +183,11 @@ module JSI
     alias_method :node_ptr, :jsi_ptr
     alias_method :document_root_node, :jsi_root_node
 
-    # the instance of the json-schema
+    # the instance of the json-schema - the underlying JSON data used to instantiate this JSI
     alias_method :jsi_instance, :node_content
     alias_method :instance, :node_content
 
-    # each is overridden by BaseHash or BaseArray when appropriate. the base
+    # each is overridden by PathedHashNode or PathedArrayNode when appropriate. the base
     # #each is not actually implemented, along with all the methods of Enumerable.
     def each
       raise NoMethodError, "Enumerable methods and #each not implemented for instance that is not like a hash or array: #{jsi_instance.pretty_inspect.chomp}"
@@ -192,8 +222,9 @@ module JSI
 
     # @param token [String, Integer, Object] the token to subscript
     # @return [JSI::Base, Object] the instance's subscript value at the given token.
-    #   if there is a subschema defined for that token on this JSI's schema,
-    #   returns that value as a JSI instantiation of that subschema.
+    #   if this JSI's schemas define subschemas which apply for the given token, and the value is complex,
+    #   returns the subscript value as a JSI instantiation of those subschemas. otherwise, the plain instance
+    #   value is returned.
     def [](token)
       if respond_to?(:to_hash)
         token_in_range = node_content_hash_pubsend(:key?, token)
@@ -202,29 +233,29 @@ module JSI
         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 instance: #{jsi_instance.pretty_inspect.chomp}")
+        raise(CannotSubscriptError, "cannot subcript (using token: #{token.inspect}) from instance: #{jsi_instance.pretty_inspect.chomp}")
       end
 
-      jsi_memoize(:[], token, value, token_in_range) do |token, value, token_in_range|
+      result = jsi_memoize(:[], token, value, token_in_range) do |token, value, token_in_range|
         if respond_to?(:to_ary)
-          token_schema = schema.subschema_for_index(token)
+          token_schemas = jsi_schemas.map { |schema| schema.subschemas_for_index(token) }.inject(Set.new, &:|)
         else
-          token_schema = schema.subschema_for_property(token)
+          token_schemas = jsi_schemas.map { |schema| schema.subschemas_for_property_name(token) }.inject(Set.new, &:|)
         end
-        token_schema = token_schema && token_schema.match_to_instance(value)
+        token_schemas = token_schemas.map { |schema| schema.match_to_instance(value) }.inject(Set.new, &:|)
 
         if token_in_range
-          complex_value = token_schema && (value.respond_to?(:to_hash) || value.respond_to?(:to_ary))
-          schema_value = token_schema && token_schema.describes_schema?
+          complex_value = token_schemas.any? && (value.respond_to?(:to_hash) || value.respond_to?(:to_ary))
+          schema_value = token_schemas.any? { |token_schema| token_schema.describes_schema? }
 
           if complex_value || schema_value
-            class_for_schema(token_schema).new(Base::NOINSTANCE, jsi_document: @jsi_document, jsi_ptr: @jsi_ptr[token], jsi_root_node: @jsi_root_node)
+            JSI::SchemaClasses.class_for_schemas(token_schemas).new(Base::NOINSTANCE, jsi_document: @jsi_document, jsi_ptr: @jsi_ptr[token], jsi_root_node: @jsi_root_node)
           else
             value
           end
         else
           defaults = Set.new
-          if token_schema
+          token_schemas.each do |token_schema|
             if token_schema.respond_to?(:to_hash) && token_schema.key?('default')
               defaults << token_schema['default']
             end
@@ -243,6 +274,7 @@ module JSI
           end
         end
       end
+      result
     end
 
     # assigns the subscript of the instance identified by the given token to the given value.
@@ -297,12 +329,12 @@ module JSI
 
     # @return [Array] array of schema validation errors for this instance
     def fully_validate(errors_as_objects: false)
-      schema.fully_validate_instance(jsi_instance, errors_as_objects: errors_as_objects)
+      jsi_schemas.map { |schema| schema.fully_validate_instance(jsi_instance, errors_as_objects: errors_as_objects) }.inject([], &:+)
     end
 
     # @return [true, false] whether the instance validates against its schema
     def validate
-      schema.validate_instance(jsi_instance)
+      jsi_schemas.all? { |schema| schema.validate_instance(jsi_instance) }
     end
 
     # @return [true] if this method does not raise, it returns true to
@@ -310,7 +342,8 @@ module JSI
     # @raise [::JSON::Schema::ValidationError] raises if the instance has
     #   validation errors
     def validate!
-      schema.validate_instance!(jsi_instance)
+      jsi_schemas.each { |schema| schema.validate_instance!(jsi_instance) }
+      true
     end
 
     def dup
@@ -344,18 +377,18 @@ module JSI
       class_txt = begin
         if class_name
           # ignore ID
-          schema_name = schema.jsi_schema_module.name
-          if !schema_name
+          schema_module_names = jsi_schemas.map { |schema| schema.jsi_schema_module.name }.compact
+          if schema_module_names.empty?
             class_name
           else
-            "#{class_name} (#{schema_name})"
+            "#{class_name} (#{schema_module_names.join(', ')})"
           end
         else
-          schema_name = schema.jsi_schema_module.name || schema.schema_id
-          if !schema_name
+          schema_names = jsi_schemas.map { |schema| schema.jsi_schema_module.name || schema.schema_id }.compact
+          if schema_names.empty?
             "JSI"
           else
-            "JSI (#{schema_name})"
+            "JSI (#{schema_names.join(', ')})"
           end
         end
       end
@@ -387,24 +420,6 @@ module JSI
     def jsi_fingerprint
       {class: jsi_class, jsi_document: jsi_document, jsi_ptr: jsi_ptr}
     end
-    include FingerprintHash
-
-    private
-
-    # this is an instance method in order to allow subclasses of JSI classes to
-    # override it to point to other subclasses corresponding to other schemas.
-    def class_for_schema(schema)
-      JSI.class_for_schema(schema)
-    end
-  end
-
-  # module extending a {JSI::Base} object when its instance is Hash-like (responds to #to_hash)
-  module BaseHash
-    include PathedHashNode
-  end
-
-  # module extending a {JSI::Base} object when its instance is Array-like (responds to #to_ary)
-  module BaseArray
-    include PathedArrayNode
+    include Util::FingerprintHash
   end
 end

data/lib/jsi/jsi_coder.rb

@@ -14,11 +14,11 @@ module JSI
   #     Preferences = JSI.class_for_schema(preferences_json_schema)
   #     class Foo < ActiveRecord::Base
   #       # as a single serializer, loads a Preferences instance from a json column
-  #       serialize 'preferences', JSI::JSICoder.new(Preferences)
+  #       serialize 'preferences_json', JSI::JSICoder.new(Preferences)
   #
   #       # for a text column, arms_serialize will go from JSI to JSON-compatible
   #       # objects to a string. the symbol `:jsi` is a shortcut for JSI::JSICoder.
-  #       arms_serialize 'preferences', [:jsi, Preferences], :json
+  #       arms_serialize 'preferences_txt', [:jsi, Preferences], :json
   #     end
   #
   # the column data may be either a single instance of the schema class

data/lib/jsi/json/node.rb

@@ -155,7 +155,7 @@ module JSI
       def object_group_text
         [
           self.class.inspect,
-          "fragment=#{node_ptr.fragment.inspect}",
+          node_ptr.uri.to_s,
         ] + (node_content.respond_to?(:object_group_text) ? node_content.object_group_text : [])
       end
 
@@ -185,7 +185,7 @@ module JSI
       def jsi_fingerprint
         {class: JSI::JSON::Node, node_document: node_document, node_ptr: node_ptr}
       end
-      include FingerprintHash
+      include Util::FingerprintHash
     end
 
     # a JSI::JSON::Node whose content is Array-like (responds to #to_ary)

data/lib/jsi/json/pointer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'addressable/uri'
-
 module JSI
   module JSON
     # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
@@ -33,28 +31,23 @@ module JSI
 
       # parse a URI-escaped fragment and instantiate as a JSI::JSON::Pointer
       #
-      #     ptr = JSI::JSON::Pointer.from_fragment('#/foo/bar')
-      #     => #<JSI::JSON::Pointer fragment: #/foo/bar>
+      #     ptr = JSI::JSON::Pointer.from_fragment('/foo/bar')
+      #     => #<JSI::JSON::Pointer fragment: /foo/bar>
       #     ptr.reference_tokens
       #     => ["foo", "bar"]
       #
       # with URI escaping:
       #
-      #     ptr = JSI::JSON::Pointer.from_fragment('#/foo%20bar')
-      #     => #<JSI::JSON::Pointer fragment: #/foo%20bar>
+      #     ptr = JSI::JSON::Pointer.from_fragment('/foo%20bar')
+      #     => #<JSI::JSON::Pointer fragment: /foo%20bar>
       #     ptr.reference_tokens
       #     => ["foo bar"]
       #
       # @param fragment [String] a fragment containing a pointer (starting with #)
       # @return [JSI::JSON::Pointer]
+      # @raise [JSI::JSON::Pointer::PointerSyntaxError] when the fragment does not contain a pointer with valid pointer syntax
       def self.from_fragment(fragment)
-        fragment = Addressable::URI.unescape(fragment)
-        match = fragment.match(/\A#/)
-        if match
-          from_pointer(match.post_match, type: 'fragment')
-        else
-          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
-        end
+        from_pointer(Addressable::URI.unescape(fragment), type: 'fragment')
       end
 
       # parse a pointer string and instantiate as a JSI::JSON::Pointer
@@ -72,6 +65,7 @@ module JSI
       # @param pointer_string [String] a pointer string
       # @param type (for internal use) indicates the original representation of the pointer
       # @return [JSI::JSON::Pointer]
+      # @raise [JSI::JSON::Pointer::PointerSyntaxError] when the pointer_string does not have valid pointer syntax
       def self.from_pointer(pointer_string, type: 'pointer')
         tokens = pointer_string.split('/', -1).map! do |piece|
           piece.gsub('~1', '/').gsub('~0', '~')
@@ -137,7 +131,12 @@ module JSI
 
       # @return [String] the fragment string representation of this Pointer
       def fragment
-        '#' + Addressable::URI.escape(pointer)
+        Addressable::URI.escape(pointer)
+      end
+
+      # @return [Addressable::URI] a URI consisting only of a pointer fragment
+      def uri
+        Addressable::URI.new(fragment: fragment)
       end
 
       # @return [Boolean] whether this pointer points to the root (has an empty array of reference_tokens)
@@ -197,102 +196,108 @@ module JSI
         Pointer.new(reference_tokens + [token], type: @type)
       end
 
-      # given this Pointer points to a schema in the given document, returns a pointer
-      # to a subschema of that schema for the given property name.
+      # given this Pointer points to a schema in the given document, returns a set of pointers
+      # to subschemas of that schema for the given property name.
       #
       # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
       # @param property_name [Object] the property name for which to find a subschema
-      # @return [JSI::JSON::Pointer, nil] a pointer to a subschema in the document for the property_name, or nil
-      def schema_subschema_ptr_for_property_name(document, property_name)
+      # @return [Set<JSI::JSON::Pointer>] pointers to subschemas
+      def schema_subschema_ptrs_for_property_name(document, property_name)
         ptr = self
         schema = ptr.evaluate(document)
-        if !schema.respond_to?(:to_hash)
-          nil
-        else
-          if schema.key?('properties') && schema['properties'].respond_to?(:to_hash) && schema['properties'].key?(property_name)
-            ptr['properties'][property_name]
-          else
-            # TODO this is rather incorrect handling of patternProperties and additionalProperties
+        Set.new.tap do |ptrs|
+          if schema.respond_to?(:to_hash)
+            apply_additional = true
+            if schema.key?('properties') && schema['properties'].respond_to?(:to_hash) && schema['properties'].key?(property_name)
+              apply_additional = false
+              ptrs << ptr['properties'][property_name]
+            end
             if schema['patternProperties'].respond_to?(:to_hash)
-              pattern_schema_name = schema['patternProperties'].keys.detect do |pattern|
-                property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+              schema['patternProperties'].each_key do |pattern|
+                if property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+                  apply_additional = false
+                  ptrs << ptr['patternProperties'][pattern]
+                end
               end
             end
-            if pattern_schema_name
-              ptr['patternProperties'][pattern_schema_name]
-            else
-              if schema.key?('additionalProperties')
-                ptr['additionalProperties']
-              else
-                nil
-              end
+            if apply_additional && schema.key?('additionalProperties')
+              ptrs << ptr['additionalProperties']
             end
           end
         end
       end
 
-      # given this Pointer points to a schema in the given document, returns a pointer
-      # to a subschema of that schema for the given array index.
+      # given this Pointer points to a schema in the given document, returns a set of pointers
+      # to subschemas of that schema for the given array index.
       #
       # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
-      # @param idx [Object] the array index for which to find a subschema
-      # @return [JSI::JSON::Pointer, nil] a pointer to a subschema in the document for array index idx, or nil
-      def schema_subschema_ptr_for_index(document, idx)
+      # @param idx [Object] the array index for which to find subschemas
+      # @return [Set<JSI::JSON::Pointer>] pointers to subschemas
+      def schema_subschema_ptrs_for_index(document, idx)
         ptr = self
         schema = ptr.evaluate(document)
-        if !schema.respond_to?(:to_hash)
-          nil
-        else
-          if schema.key?('items') || schema.key?('additionalItems')
+        Set.new.tap do |ptrs|
+          if schema.respond_to?(:to_hash)
             if schema['items'].respond_to?(:to_ary)
               if schema['items'].each_index.to_a.include?(idx)
-                ptr['items'][idx]
+                ptrs << ptr['items'][idx]
               elsif schema.key?('additionalItems')
-                ptr['additionalItems']
-              else
-                nil
+                ptrs << ptr['additionalItems']
               end
             elsif schema.key?('items')
-              ptr['items']
-            else
-              nil
+              ptrs << ptr['items']
             end
-          else
-            nil
           end
         end
       end
 
-      # given this Pointer points to a schema in the given document, this matches
-      # any oneOf or anyOf subschema of the schema which the given instance validates
-      # against. if a subschema is matched, a pointer to that schema is returned; if not,
-      # self is returned.
+      # given this Pointer points to a schema in the given document, this matches any
+      # applicators of the schema (oneOf, anyOf, allOf, $ref) which should be applied
+      # and returns them as a set of pointers.
       #
-      # @param document [#to_hash, #to_ary, Object] document containing the schema
-      #   this pointer points to
-      # @param instance [Object] the instance to which to attempt to match *Of subschemas
+      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
+      # @param instance [Object] the instance to check any applicators against
       # @return [JSI::JSON::Pointer] either a pointer to a *Of subschema in the document,
       #   or self if no other subschema was matched
-      def schema_match_ptr_to_instance(document, instance)
+      def schema_match_ptrs_to_instance(document, instance)
         ptr = self
         schema = ptr.evaluate(document)
-        if schema.respond_to?(:to_hash)
-          # matching oneOf is good here. one schema for one instance.
-          # matching anyOf is fine. there could be more than one schema matched but it's usually just
-          #   one. if more than one is a match, you just get the first one.
-          someof_token = %w(oneOf anyOf).detect { |k| schema[k].respond_to?(:to_ary) }
-          if someof_token
-            someof_ptr = ptr[someof_token].deref(document)
-            someof_ptr.evaluate(document).each_index do |i|
-              someof_schema_ptr = someof_ptr[i].deref(document)
-              valid = ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: someof_schema_ptr.fragment)
-              if valid
-                return someof_schema_ptr.schema_match_ptr_to_instance(document, instance)
+
+        Set.new.tap do |ptrs|
+          if schema.respond_to?(:to_hash)
+            if schema['$ref'].respond_to?(:to_str)
+              ptr.deref(document) do |deref_ptr|
+                ptrs.merge(deref_ptr.schema_match_ptrs_to_instance(document, instance))
+              end
+            else
+              ptrs << ptr
+            end
+            if schema['allOf'].respond_to?(:to_ary)
+              schema['allOf'].each_index do |i|
+                ptrs.merge(ptr['allOf'][i].schema_match_ptrs_to_instance(document, instance))
+              end
+            end
+            if schema['anyOf'].respond_to?(:to_ary)
+              schema['anyOf'].each_index do |i|
+                valid = ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: ptr['anyOf'][i].fragment)
+                if valid
+                  ptrs.merge(ptr['anyOf'][i].schema_match_ptrs_to_instance(document, instance))
+                end
+              end
+            end
+            if schema['oneOf'].respond_to?(:to_ary)
+              one_i = schema['oneOf'].each_index.detect do |i|
+                ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: ptr['oneOf'][i].fragment)
+              end
+              if one_i
+                ptrs.merge(ptr['oneOf'][one_i].schema_match_ptrs_to_instance(document, instance))
               end
             end
+            # TODO dependencies
+          else
+            ptrs << ptr
           end
         end
-        return ptr
       end
 
       # takes a document and a block. the block is yielded the content of the given document at this
@@ -378,7 +383,7 @@ module JSI
         return self unless ref.is_a?(String)
 
         if ref[/\A#/]
-          return Pointer.from_fragment(ref).tap(&block)
+          return Pointer.from_fragment(Addressable::URI.parse(ref).fragment).tap(&block)
         end
 
         # HAX for how google does refs and ids
@@ -399,7 +404,7 @@ module JSI
 
       # @return [String] string representation of this Pointer
       def inspect
-        "#<#{self.class.inspect} #{representation_s}>"
+        "#{self.class.name}[#{reference_tokens.map(&:inspect).join(", ")}]"
       end
 
       alias_method :to_s, :inspect
@@ -408,20 +413,7 @@ module JSI
       def jsi_fingerprint
         {class: JSI::JSON::Pointer, reference_tokens: reference_tokens}
       end
-      include FingerprintHash
-
-      private
-
-      # @return [String] a representation of this pointer based on @type
-      def representation_s
-        if @type == 'fragment'
-          "fragment: #{fragment}"
-        elsif @type == 'pointer'
-          "pointer: #{pointer}"
-        else
-          "reference_tokens: #{reference_tokens.inspect}"
-        end
-      end
+      include Util::FingerprintHash
     end
   end
 end