jsi 0.3.0 → 0.4.0

data/lib/jsi/version.rb

@@ -1,3 +1,3 @@
 module JSI
-  VERSION = "0.3.0".freeze
+  VERSION = "0.4.0".freeze
 end

data/test/base_array_test.rb

@@ -9,10 +9,10 @@ base = {
     {'type' => 'array', 'items' => {}},
   ],
 }
-NamedArrayInstance = JSI.class_for_schema(base)
-NamedIdArrayInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base))
+NamedArrayInstance = JSI::Schema.new(base).jsi_schema_class
+NamedIdArrayInstance = JSI::Schema.new({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base)).jsi_schema_class
 
-describe JSI::BaseArray do
+describe 'JSI::Base array' do
   let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
   let(:schema_content) do
     {
@@ -181,43 +181,43 @@ describe JSI::BaseArray do
       end
     end
     describe '#inspect with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
       let(:subject) { schema.new_jsi(instance) }
       it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
       let(:subject) { schema.new_jsi(instance) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n  #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      it 'pretty prints' do
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end
     end
     describe '#inspect with id SortOfArray' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
       let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
       end
     end
     describe '#pretty_print with id SortOfArray' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_array_test/withid', 'items' => [{}, {}, {}]} }
       let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
       it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n  #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
       end
     end
     describe '#inspect Node' do
       let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
       it 'inspects' do
-        assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\"> \"foo\", \#{<JSI JSI::JSON::HashNode fragment=\"#/1\"> \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]}, #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"], \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}]", subject.inspect)
+        assert_equal("#[<JSI JSI::JSON::ArrayNode #> \"foo\", \#{<JSI JSI::JSON::HashNode #/1> \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]}, #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"], \#{<JSI::JSON::HashNode #/3> \"four\" => 4}]", subject.inspect)
       end
     end
     describe '#pretty_print Node' do
       let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
       it 'pretty_prints' do
-        assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\">\n  \"foo\",\n  \#{<JSI JSI::JSON::HashNode fragment=\"#/1\">\n    \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]\n  },\n  #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"],\n  \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}\n]\n", subject.pretty_inspect)
+        assert_equal("#[<JSI JSI::JSON::ArrayNode #>\n  \"foo\",\n  \#{<JSI JSI::JSON::HashNode #/1>\n    \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]\n  },\n  #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"],\n  \#{<JSI::JSON::HashNode #/3> \"four\" => 4}\n]\n", subject.pretty_inspect)
       end
     end
   end

data/test/base_hash_test.rb

@@ -8,10 +8,10 @@ base = {
     'bar' => {},
   },
 }
-NamedHashInstance = JSI.class_for_schema(base)
-NamedIdHashInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base))
+NamedHashInstance = JSI::Schema.new(base).jsi_schema_class
+NamedIdHashInstance = JSI::Schema.new({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base)).jsi_schema_class
 
-describe JSI::BaseHash do
+describe 'JSI::Base hash' do
   let(:instance) { {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]} }
   let(:schema_content) do
     {
@@ -225,43 +225,43 @@ describe JSI::BaseHash do
       end
     end
     describe '#inspect with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_hash_test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
       let(:subject) { schema.new_jsi(instance) }
       it 'inspects' do
-        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#)> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print with id' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_hash_test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
       let(:subject) { schema.new_jsi(instance) }
       it 'inspects' do
-        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#)>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end
     end
     describe '#inspect with id SortOfHash' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_hash_test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
       let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
-        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#) SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
       end
     end
     describe '#pretty_print with id SortOfHash' do
-      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/base_hash_test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
       let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
       it 'inspects' do
-        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#) SortOfHash>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/base_hash_test/withid#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
       end
     end
     describe '#inspect Node' do
       let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
       it 'inspects' do
-        assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\"> \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"}, \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9], \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]}", subject.inspect)
+        assert_equal("\#{<JSI JSI::JSON::HashNode #> \"foo\" => \#{<JSI JSI::JSON::HashNode #/foo> \"x\" => \"y\"}, \"bar\" => #[<JSI JSI::JSON::ArrayNode #/bar> 9], \"baz\" => #[<JSI::JSON::ArrayNode #/baz> true]}", subject.inspect)
       end
     end
     describe '#pretty_print Node' do
       let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
       it 'pretty_prints' do
-        assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\">\n  \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"},\n  \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9],\n  \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]\n}\n", subject.pretty_inspect)
+        assert_equal("\#{<JSI JSI::JSON::HashNode #>\n  \"foo\" => \#{<JSI JSI::JSON::HashNode #/foo> \"x\" => \"y\"},\n  \"bar\" => #[<JSI JSI::JSON::ArrayNode #/bar> 9],\n  \"baz\" => #[<JSI::JSON::ArrayNode #/baz> true]\n}\n", subject.pretty_inspect)
       end
     end
   end

data/test/base_test.rb

@@ -41,14 +41,9 @@ describe JSI::Base do
       assert_equal('NamedSchemaInstance', NamedSchemaInstance.name)
     end
   end
-  describe 'class for schema .schema' do
-    it '.schema' do
-      assert_equal(schema, JSI.class_for_schema(schema).schema)
-    end
-  end
-  describe 'class for schema .schema_id' do
-    it '.schema_id' do
-      assert_equal(schema.schema_id, JSI.class_for_schema(schema).schema_id)
+  describe 'class for schema .jsi_class_schemas' do
+    it '.jsi_class_schemas' do
+      assert_equal(Set.new << schema, schema.jsi_schema_class.jsi_class_schemas)
     end
   end
   describe 'module for schema .inspect' do
@@ -61,15 +56,15 @@ describe JSI::Base do
       assert_equal(schema, JSI::SchemaClasses.module_for_schema(schema).schema)
     end
   end
-  describe '.class_for_schema' do
+  describe '.class_for_schemas' do
     it 'returns a class from a schema' do
-      class_for_schema = JSI.class_for_schema(schema)
+      class_for_schema = JSI.class_for_schemas([schema])
       # same class every time
-      assert_equal(JSI.class_for_schema(schema), class_for_schema)
+      assert_equal(JSI.class_for_schemas([schema]), class_for_schema)
       assert_operator(class_for_schema, :<, JSI::Base)
     end
-    it 'returns a class from a hash' do
-      assert_equal(JSI.class_for_schema(schema), JSI.class_for_schema(schema_content))
+    it 'returns the same class from a hash' do
+      assert_equal(JSI.class_for_schemas([schema]), JSI.class_for_schemas([schema_content]))
     end
   end
   describe 'JSI::SchemaClasses.module_for_schema' do
@@ -86,7 +81,7 @@ describe JSI::Base do
     describe 'on Base' do
       it 'errors' do
         err = assert_raises(TypeError) { JSI::Base.new({}) }
-        assert_equal('cannot instantiate JSI::Base which has no method #schema. please use JSI.class_for_schema', err.message)
+        assert_equal('cannot instantiate JSI::Base which has no method #jsi_schemas. it is recommended to instantiate JSIs from a schema using JSI::Schema#new_jsi.', err.message)
       end
     end
     describe 'nil' do
@@ -375,7 +370,7 @@ describe JSI::Base do
       describe 'when the instance is not hashlike' do
         let(:instance) { nil }
         it 'errors' do
-          err = assert_raises(NoMethodError) { subject.foo }
+          err = assert_raises(JSI::Base::CannotSubscriptError) { subject.foo }
           assert_equal(%q(cannot subcript (using token: "foo") from instance: nil), err.message)
         end
       end
@@ -389,10 +384,10 @@ describe JSI::Base do
               'inspect' => {},        # Base
               'pretty_inspect' => {}, # Kernel
               'as_json' => {},        # Base::OverrideFromExtensions, extended on initialization
-              'each' => {},           # BaseHash / BaseArray
+              'each' => {},           # PathedHashNode / PathedArrayNode
               'instance_exec' => {},  # BasicObject
               'jsi_instance' => {},   # Base
-              'schema' => {},         # module_for_schema singleton definition
+              'jsi_schemas' => {},    # module_for_schema singleton definition
             },
           }
         end
@@ -406,7 +401,7 @@ describe JSI::Base do
             'each' => 'hi',
             'instance_exec' => 'hi',
             'jsi_instance' => 'hi',
-            'schema' => 'hi',
+            'jsi_schemas' => 'hi',
           }
         end
         it 'does not define readers' do
@@ -414,14 +409,14 @@ describe JSI::Base do
 
           assert_equal(JSI::Base, subject.method(:initialize).owner)
           assert_equal('hi', subject['initialize'])
-          assert_equal(%q(#{<JSI> "foo" => "bar", "initialize" => "hi", "inspect" => "hi", "pretty_inspect" => "hi", "as_json" => "hi", "each" => "hi", "instance_exec" => "hi", "jsi_instance" => "hi", "schema" => "hi"}), subject.inspect)
+          assert_equal(%q(#{<JSI> "foo" => "bar", "initialize" => "hi", "inspect" => "hi", "pretty_inspect" => "hi", "as_json" => "hi", "each" => "hi", "instance_exec" => "hi", "jsi_instance" => "hi", "jsi_schemas" => "hi"}), subject.inspect)
           assert_equal('hi', subject['inspect'])
-          assert_equal(%Q(\#{<JSI>\n  "foo" => "bar",\n  "initialize" => "hi",\n  "inspect" => "hi",\n  "pretty_inspect" => "hi",\n  "as_json" => "hi",\n  "each" => "hi",\n  "instance_exec" => "hi",\n  "jsi_instance" => "hi",\n  "schema" => "hi"\n}\n), subject.pretty_inspect)
+          assert_equal(%Q(\#{<JSI>\n  "foo" => "bar",\n  "initialize" => "hi",\n  "inspect" => "hi",\n  "pretty_inspect" => "hi",\n  "as_json" => "hi",\n  "each" => "hi",\n  "instance_exec" => "hi",\n  "jsi_instance" => "hi",\n  "jsi_schemas" => "hi"\n}\n), subject.pretty_inspect)
           assert_equal(instance, subject.as_json)
           assert_equal(subject, subject.each { })
           assert_equal(2, subject.instance_exec { 2 })
           assert_equal(instance, subject.jsi_instance)
-          assert_equal(schema, subject.schema)
+          assert_equal(Set.new << schema, subject.jsi_schemas)
         end
       end
     end
@@ -478,7 +473,7 @@ describe JSI::Base do
     end
   end
   describe 'equality between different classes of JSI::Base subclasses' do
-    let(:subject_subclass) { Class.new(JSI.class_for_schema(schema)).new(instance) }
+    let(:subject_subclass) { Class.new(schema.jsi_schema_class).new(instance) }
 
     it 'considers a Base subclass (class_for_schema) and subsubclass to be equal with the same instance' do
       assert_equal(subject.hash, subject_subclass.hash)

data/test/jsi_coder_test.rb

@@ -1,10 +1,10 @@
 require_relative 'test_helper'
 
 describe JSI::JSICoder do
-  let(:schema_object) do
+  let(:schema_content) do
     {properties: {foo: {}, bar: {}}}
   end
-  let(:schema) { JSI::Schema.new(schema_object) }
+  let(:schema) { JSI::Schema.new(schema_content) }
   let(:options) { {} }
   let(:schema_instance_json_coder) { JSI::JSICoder.new(schema, options) }
   describe 'json' do
@@ -34,7 +34,7 @@ describe JSI::JSICoder do
         end
       end
       describe 'array schema' do
-        let(:schema_object) { {items: {properties: {foo: {}, bar: {}}}} }
+        let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }
         it 'loads an array of hashes' do
           data = [{"foo" => "bar"}, {"foo" => "baz"}]
           assert_equal(schema.new_jsi([{'foo' => 'bar'}, {'foo' => 'baz'}]), schema_instance_json_coder.load(data))
@@ -74,7 +74,7 @@ describe JSI::JSICoder do
         end
       end
       describe 'array schema' do
-        let(:schema_object) { {items: {properties: {foo: {}, bar: {}}}} }
+        let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }
         it 'dumps a schema_instance array' do
           schema_instances = schema.new_jsi([{foo: 'x', bar: 'y'}, {foo: 'z', bar: 'q'}])
           assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], schema_instance_json_coder.dump(schema_instances))

data/test/jsi_json_node_test.rb

@@ -17,7 +17,7 @@ describe JSI::JSON::Node do
     end
     it 'initializes, node_document is another Node' do
       err = assert_raises(TypeError) { JSI::JSON::Node.new(JSI::JSON::Node.new({'a' => 'b'}, node_ptr), node_ptr) }
-      assert_equal("node_document of a Node should not be another JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" {\"a\"=>\"b\"}>", err.message)
+      assert_equal("node_document of a Node should not be another JSI::JSON::Node: #<JSI::JSON::Node # {\"a\"=>\"b\"}>", err.message)
     end
   end
   describe 'initialization by .new_by_type' do
@@ -171,7 +171,7 @@ describe JSI::JSON::Node do
       err = assert_raises(JSI::JSON::Pointer::ReferenceError) do
         root_from_sub.parent_node
       end
-      assert_match(/\Acannot access parent of root pointer: #<JSI::JSON::Pointer/, err.message)
+      assert_equal('cannot access parent of root pointer: JSI::JSON::Pointer[]', err.message)
     end
   end
   describe '#modified_copy' do
@@ -214,14 +214,14 @@ describe JSI::JSON::Node do
     let(:node_document) { {'a' => {'c' => ['d', 'e']}} }
     let(:path) { ['a'] }
     it 'inspects' do
-      assert_equal(%Q(#<JSI::JSON::Node fragment="#/a" {"c"=>["d", "e"]}>), node.inspect)
+      assert_equal(%Q(#<JSI::JSON::Node #/a {"c"=>["d", "e"]}>), node.inspect)
     end
   end
   describe '#pretty_print' do
     let(:node_document) { {'a' => {'c' => ['d', 'e']}} }
     let(:path) { ['a'] }
     it 'pretty prints' do
-      assert_equal(%Q(#<JSI::JSON::Node fragment="#/a" {"c"=>["d", "e"]}>), node.pretty_inspect.chomp)
+      assert_equal(%Q(#<JSI::JSON::Node #/a {"c"=>["d", "e"]}>), node.pretty_inspect.chomp)
     end
   end
   describe '#jsi_fingerprint' do

data/test/jsi_json_pointer_test.rb

@@ -79,18 +79,14 @@ describe JSI::JSON::Pointer do
         '#/%20',        7,
         '#/m~0n',       8,
       ]
-      evaluations.each_slice(2) do |fragment, value|
-        assert_equal(value, JSI::JSON::Pointer.from_fragment(fragment).evaluate(document))
+      evaluations.each_slice(2) do |uri, value|
+        assert_equal(value, JSI::JSON::Pointer.from_fragment(Addressable::URI.parse(uri).fragment).evaluate(document))
       end
     end
 
     it 'raises for invalid syntax' do
       err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_fragment("this does not begin with #").evaluate(document)
-      end
-      assert_equal("Invalid fragment syntax in \"this does not begin with #\": fragment must begin with #", err.message)
-      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_fragment("#this does not begin with slash").evaluate(document)
+        JSI::JSON::Pointer.from_fragment("this does not begin with slash").evaluate(document)
       end
       assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
     end

data/test/metaschema_node_test.rb

@@ -13,7 +13,7 @@ describe JSI::MetaschemaNode do
   end
   describe 'json schema draft' do
     it 'type has a schema' do
-      assert(JSI::JSONSchemaOrgDraft06.schema.type.schema)
+      assert(JSI::JSONSchemaOrgDraft06.schema.type.jsi_schemas.any?)
     end
   end
 end

data/test/schema_test.rb

@@ -22,8 +22,8 @@ describe JSI::Schema do
   end
   describe 'as an instance of metaschema' do
     let(:metaschema_jsi_module) { JSI::JSONSchemaOrgDraft04 }
-    let(:schema_object) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
-    let(:schema) { metaschema_jsi_module.new_jsi(schema_object) }
+    let(:schema_content) { {'type' => 'array', 'items' => {'description' => 'items!'}} }
+    let(:schema) { metaschema_jsi_module.new_jsi(schema_content) }
     it '#[]' do
       schema_items = schema['items']
       assert_is_a(metaschema_jsi_module, schema_items)
@@ -35,8 +35,8 @@ describe JSI::Schema do
       assert_nil(JSI::Schema.new({}).schema_id)
     end
     it 'uses a given id with a fragment' do
-      schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id#'})
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#', schema.schema_id)
+      schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/given_id_with_fragment#'})
+      assert_equal('https://schemas.jsi.unth.net/test/given_id_with_fragment#', schema.schema_id)
     end
     it 'uses a given id (adding a fragment)' do
       schema = JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/given_id'})
@@ -44,19 +44,19 @@ describe JSI::Schema do
     end
     it 'uses a pointer in the fragment' do
       schema = JSI::Schema.new({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#',
+        'id' => 'https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#',
         'properties' => {'foo' => {'type' => 'object'}},
       })
       subschema = schema['properties']['foo']
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/properties/foo', subschema.schema_id)
+      assert_equal('https://schemas.jsi.unth.net/test/uses_pointer_in_fragment#/properties/foo', subschema.schema_id)
     end
     it 'uses a pointer in the fragment relative to the fragment of the root' do
       schema = JSI::Schema.new({
-        'id' => 'https://schemas.jsi.unth.net/test/given_id#/notroot',
+        'id' => 'https://schemas.jsi.unth.net/test/id_has_pointer#/notroot',
         'properties' => {'foo' => {'type' => 'object'}},
       })
       subschema = schema['properties']['foo']
-      assert_equal('https://schemas.jsi.unth.net/test/given_id#/notroot/properties/foo', subschema.schema_id)
+      assert_equal('https://schemas.jsi.unth.net/test/id_has_pointer#/notroot/properties/foo', subschema.schema_id)
     end
   end
   describe '#jsi_schema_module' do
@@ -69,73 +69,95 @@ describe JSI::Schema do
   describe '#jsi_schema_class' do
     it 'returns the class for the schema' do
       schema = JSI::Schema.new({'id' => 'https://schemas.jsi.unth.net/test/schema_schema_class'})
-      assert_equal(JSI.class_for_schema(schema), schema.jsi_schema_class)
+      assert_equal(JSI.class_for_schemas([schema]), schema.jsi_schema_class)
     end
   end
-  describe '#subschema_for_property' do
+  describe '#subschemas_for_property_name' do
     let(:schema) do
       JSI::Schema.new({
-        properties: {foo: {description: 'foo'}},
-        patternProperties: {"^ba" => {description: 'ba*'}},
+        properties: {
+          foo: {description: 'foo'},
+          baz: {description: 'baz'},
+        },
+        patternProperties: {
+          "^b" => {description: 'ba*'},
+        },
         additionalProperties: {description: 'whatever'},
       })
     end
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_property('no'))
+    it 'has no subschemas' do
+      assert_empty(JSI::Schema.new({}).subschemas_for_property_name('no'))
     end
     it 'has a subschema by property' do
-      subschema = schema.subschema_for_property('foo')
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschema)
-      assert_equal('foo', subschema['description'])
-    end
-    it 'has a subschema by pattern property' do
-      subschema = schema.subschema_for_property('bar')
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschema)
-      assert_equal('ba*', subschema['description'])
-    end
-    it 'has a subschema by additional properties' do
-      subschema = schema.subschema_for_property('anything')
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschema)
-      assert_equal('whatever', subschema['description'])
+      subschemas = schema.subschemas_for_property_name('foo').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('foo', subschemas[0].description)
+    end
+    it 'has subschemas by patternProperties' do
+      subschemas = schema.subschemas_for_property_name('bar').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('ba*', subschemas[0].description)
+    end
+    it 'has subschemas by properties, patternProperties' do
+      subschemas = schema.subschemas_for_property_name('baz').to_a
+      assert_equal(2, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('baz', subschemas[0].description)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[1])
+      assert_equal('ba*', subschemas[1].description)
+    end
+    it 'has subschemas by additional properties' do
+      subschemas = schema.subschemas_for_property_name('anything').to_a
+      assert_equal(1, subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, subschemas[0])
+      assert_equal('whatever', subschemas[0].description)
     end
   end
-  describe '#subschema_for_index' do
-    it 'has no subschema' do
-      assert_equal(nil, JSI::Schema.new({}).subschema_for_index(0))
+  describe '#subschemas_for_index' do
+    it 'has no subschemas' do
+      assert_empty(JSI::Schema.new({}).subschemas_for_index(0))
     end
     it 'has a subschema for items' do
       schema = JSI::Schema.new({
         items: {description: 'items!'}
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
-      assert_equal('items!', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
-      assert_equal('items!', last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('items!', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal('items!', last_subschemas[0].description)
     end
     it 'has a subschema for each item by index' do
       schema = JSI::Schema.new({
         items: [{description: 'item one'}, {description: 'item two'}]
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
-      assert_equal('item two', last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('item one', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal('item two', last_subschemas[0].description)
     end
     it 'has a subschema by additional items' do
       schema = JSI::Schema.new({
         items: [{description: 'item one'}],
         additionalItems: {description: "mo' crap"},
       })
-      first_subschema = schema.subschema_for_index(0)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschema)
-      assert_equal('item one', first_subschema['description'])
-      last_subschema = schema.subschema_for_index(1)
-      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschema)
-      assert_equal("mo' crap", last_subschema['description'])
+      first_subschemas = schema.subschemas_for_index(0).to_a
+      assert_equal(1, first_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, first_subschemas[0])
+      assert_equal('item one', first_subschemas[0].description)
+      last_subschemas = schema.subschemas_for_index(1).to_a
+      assert_equal(1, last_subschemas.size)
+      assert_is_a(JSI::Schema.default_metaschema.jsi_schema_module, last_subschemas[0])
+      assert_equal("mo' crap", last_subschemas[0].description)
     end
   end
   describe 'stringification' do