Support refs that use ids with JSON pointers

This allows a `$ref` to look up a schema by `$id` and then apply a JSON
pointer to use a subschema.

The test suite example schema looks like this:

```json
{
  "$id": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed",
  "properties": {
    "foo": {"$ref": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed#/$defs/bar"}
  },
  "$defs": {
    "bar": {"type": "string"}
  }
}
```

Previously, ids were looked up using a URI that included the fragment
(ie, json pointer). Now if the fragment is a valid json pointer, the
schema is looked up without the fragment and the pointer is applied to
whatever is found.

I tried to simplify things as much as I could, but it still ended up
quite complicated. A slightly separate path is still necessary for refs
that start with `#` because they don't have to be encoded as URIs and
aren't always [valid URIs][0].

Refs are sent to the ref resolver if they aren't found by id and aren't
local json pointers.

`parent_uri` is a little tricky and I'm not sure I got it totally right
in all scenarios, but it's passing all the tests.

Exposed by: json-schema-org/JSON-Schema-Test-Suite#578

[0]: b91115e

Author: davishmcclurg

lib/json_schemer/schema/base.rb

@@ -91,6 +91,8 @@ def validate(data)
 
     protected
 
+      attr_reader :root
+
       def valid_instance?(instance)
         validate_instance(instance).none?
       end
@@ -229,7 +231,7 @@ def ids
 
     private
 
-      attr_reader :root, :formats, :keywords, :ref_resolver, :regexp_resolver
+      attr_reader :formats, :keywords, :ref_resolver, :regexp_resolver
 
       def id_keyword
         ID_KEYWORD
@@ -307,51 +309,41 @@ def validate_type(instance, type, &block)
       end
 
       def validate_ref(instance, ref, &block)
+        ref_uri_pointer = nil
+
         if ref.start_with?('#')
-          schema_pointer = ref.slice(1..-1)
-          if valid_json_pointer?(schema_pointer)
-            ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(schema_pointer))
-            ref_root = ids[instance.parent_uri.to_s]&.fetch(:schema) || root
-            subinstance = instance.merge(
-              schema: ref_pointer.eval(ref_root),
-              schema_pointer: schema_pointer,
-              parent_uri: (pointer_uri(ref_root, ref_pointer) || instance.parent_uri)
-            )
-            validate_instance(subinstance, &block)
-            return
+          fragment = ref.slice(1..-1)
+          if valid_json_pointer?(fragment)
+            ref = ''
+            ref_uri_pointer = fragment
           end
         end
 
         ref_uri = join_uri(instance.parent_uri, ref)
 
         if valid_json_pointer?(ref_uri.fragment)
-          ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(ref_uri.fragment))
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          subinstance = instance.merge(
-            schema: ref_pointer.eval(ref_root),
-            schema_pointer: ref_uri.fragment,
-            parent_uri: (pointer_uri(ref_root, ref_pointer) || ref_uri)
-          )
-          ref_object.validate_instance(subinstance, &block)
-        elsif id = ids[ref_uri.to_s]
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          validate_instance(subinstance, &block)
+          ref_uri_pointer ||= ref_uri.fragment
+          ref_uri.fragment = nil
+        end
+
+        ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(ref_uri_pointer || ''))
+
+        ref_object = if ids.key?(ref_uri.to_s) || (ref_uri_pointer && (ref_uri == instance.parent_uri || ref_uri.to_s.empty?))
+          self
         else
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          id = ref_object.ids[ref_uri.to_s] || { schema: ref_root, pointer: '' }
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          ref_object.validate_instance(subinstance, &block)
+          child(resolve_ref(ref_uri))
         end
+
+        ref_schema, ref_schema_pointer = ref_object.ids[ref_uri.to_s]&.fetch_values(:schema, :pointer) || [ref_object.root, '']
+        parent_uri = ref_uri_pointer ? (pointer_uri(ref_schema, ref_pointer) || instance.parent_uri) : ref_uri
+
+        subinstance = instance.merge(
+          schema: ref_pointer.eval(ref_schema),
+          schema_pointer: "#{ref_schema_pointer}#{ref_uri_pointer}",
+          parent_uri: parent_uri
+        )
+
+        ref_object.validate_instance(subinstance, &block)
       end
 
       def validate_custom_format(instance, custom_format)