jsi 0.0.4 → 0.4.0

data/test/jsi_coder_test.rb

@@ -0,0 +1,85 @@
+require_relative 'test_helper'
+
+describe JSI::JSICoder do
+  let(:schema_content) do
+    {properties: {foo: {}, bar: {}}}
+  end
+  let(:schema) { JSI::Schema.new(schema_content) }
+  let(:options) { {} }
+  let(:schema_instance_json_coder) { JSI::JSICoder.new(schema, options) }
+  describe 'json' do
+    describe 'load' do
+      it 'loads nil' do
+        assert_nil(schema_instance_json_coder.load(nil))
+      end
+      it 'loads a hash' do
+        assert_equal(schema.new_jsi('foo' => 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
+      end
+      it 'loads something else' do
+        assert_equal(schema.new_jsi([[]]), schema_instance_json_coder.load([[]]))
+      end
+      describe 'array' do
+        let(:options) { {array: true} }
+        it 'loads an array of hashes' do
+          data = [{"foo" => "bar"}, {"foo" => "baz"}]
+          assert_equal([schema.new_jsi('foo' => 'bar'), schema.new_jsi('foo' => 'baz')], schema_instance_json_coder.load(data))
+        end
+        it 'loads an empty array' do
+          assert_equal([], schema_instance_json_coder.load([]))
+        end
+        it 'loads a not an array' do
+          assert_raises(TypeError) do
+            schema_instance_json_coder.load(Object.new)
+          end
+        end
+      end
+      describe 'array schema' do
+        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))
+        end
+        it 'loads an empty array' do
+          assert_equal(schema.new_jsi([]), schema_instance_json_coder.load([]))
+        end
+        it 'loads a not an array' do
+          instance = Object.new
+          assert_equal(schema.new_jsi(instance), schema_instance_json_coder.load(instance))
+        end
+      end
+    end
+    describe 'dump' do
+      it 'dumps nil' do
+        assert_nil(schema_instance_json_coder.dump(nil))
+      end
+      it 'dumps a schema_instance_class' do
+        assert_equal({"foo" => "x", "bar" => "y"}, schema_instance_json_coder.dump(schema.new_jsi(foo: 'x', bar: 'y')))
+      end
+      it 'dumps something else' do
+        assert_raises(TypeError) do
+          schema_instance_json_coder.dump(Object.new)
+        end
+      end
+      it 'dumps some of the keys of a schema_instance_class after loading in a partial one' do
+        schema_instance_class = schema_instance_json_coder.load({'foo' => 'who'})
+        assert_equal({'foo' => 'who'}, schema_instance_json_coder.dump(schema_instance_class))
+        schema_instance_class.bar = 'whar'
+        assert_equal({'foo' => 'who', 'bar' => 'whar'}, schema_instance_json_coder.dump(schema_instance_class))
+      end
+      describe 'array' do
+        let(:options) { {array: true} }
+        it 'dumps an array of schema_instances' do
+          schema_instances = [schema.new_jsi(foo: 'x', bar: 'y'), schema.new_jsi(foo: 'z', bar: 'q')]
+          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], schema_instance_json_coder.dump(schema_instances))
+        end
+      end
+      describe 'array schema' do
+        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))
+        end
+      end
+    end
+  end
+end

data/test/jsi_json_arraynode_test.rb

@@ -3,23 +3,24 @@ require_relative 'test_helper'
 document_types = [
   {
     make_document: -> (d) { d },
-    document: ['a', ['b', 'q'], {'c' => {'d' => 'e'}}],
+    node_document: ['a', ['b', 'q'], {'c' => {'d' => 'e'}}],
     type_desc: 'Array',
   },
   {
     make_document: -> (d) { SortOfArray.new(d) },
-    document: SortOfArray.new(['a', SortOfArray.new(['b', 'q']), SortOfHash.new({'c' => SortOfHash.new({'d' => 'e'})})]),
+    node_document: SortOfArray.new(['a', SortOfArray.new(['b', 'q']), SortOfHash.new({'c' => SortOfHash.new({'d' => 'e'})})]),
     type_desc: 'sort of Array-like',
   },
 ]
 document_types.each do |document_type|
   describe "JSI::JSON::ArrayNode with #{document_type[:type_desc]}" do
-    # document of the node being tested
-    let(:document) { document_type[:document] }
+    # node_document of the node being tested
+    let(:node_document) { document_type[:node_document] }
     # by default the node is the whole document
     let(:path) { [] }
+    let(:node_ptr) { JSI::JSON::Pointer.new(path) }
     # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, path) }
+    let(:node) { JSI::JSON::Node.new_by_type(node_document, node_ptr) }
 
     describe '#[] bad index' do
       it 'improves TypeError for Array subsript' do
@@ -55,7 +56,7 @@ document_types.each do |document_type|
       end
     end
     describe '#as_json' do
-      let(:document) { document_type[:make_document].call(['a', 'b']) }
+      let(:node_document) { document_type[:make_document].call(['a', 'b']) }
       it '#as_json' do
         assert_equal(['a', 'b'], node.as_json)
         assert_equal(['a', 'b'], node.as_json(some_option: false))
@@ -107,35 +108,35 @@ document_types.each do |document_type|
       # for this reason, rassoc is NOT defined on Arraylike. it's here with as_json.
       #
       # I've never even seen anybody use rassoc. of all the methods to put into the standard library ...
-      it('#rassoc')               { assert_equal(['b', 'q'], node.as_json.rassoc('q')) }
+      it('#rassoc')              { assert_equal(['b', 'q'], node.as_json.rassoc('q')) }
       it('#repeated_combination') { assert_equal([[]], node.repeated_combination(0).to_a) }
       it('#repeated_permutation') { assert_equal([[]], node.repeated_permutation(0).to_a) }
-      it('#reverse')              { assert_equal([node[2], node[1], 'a'], node.reverse) }
-      it('#reverse_each')         { assert_equal([node[2], node[1], 'a'], node.reverse_each.to_a) }
-      it('#rindex')               { assert_equal(0, node.rindex('a')) }
-      it('#rotate')               { assert_equal([node[1], node[2], 'a'], node.rotate) }
-      it('#sample')               { assert_equal('a', JSI::JSON::Node.new_doc(['a']).sample) }
-      it('#shelljoin')            { assert_equal('a', JSI::JSON::Node.new_doc(['a']).shelljoin) } if [].respond_to?(:shelljoin)
-      it('#shuffle')              { assert_equal(3, node.shuffle.size) }
-      it('#slice')                { assert_equal(['a'], node.slice(0, 1)) }
-      it('#sort')                 { assert_equal(['a'], JSI::JSON::Node.new_doc(['a']).sort) }
-      it('#take')                 { assert_equal(['a'], node.take(1)) }
-      it('#take_while')           { assert_equal([], node.take_while { false }) }
-      it('#transpose')            { assert_equal([], JSI::JSON::Node.new_doc([]).transpose) }
-      it('#uniq')                 { assert_equal(node.to_a, node.uniq) }
-      it('#values_at')            { assert_equal(['a'], node.values_at(0)) }
-      it('#zip')                  { assert_equal([['a', 'a'], [node[1], node[1]], [node[2], node[2]]], node.zip(node)) }
+      it('#reverse')             { assert_equal([node[2], node[1], 'a'], node.reverse) }
+      it('#reverse_each')       { assert_equal([node[2], node[1], 'a'], node.reverse_each.to_a) }
+      it('#rindex')            { assert_equal(0, node.rindex('a')) }
+      it('#rotate')           { assert_equal([node[1], node[2], 'a'], node.rotate) }
+      it('#sample')          { assert_equal('a', JSI::JSON::Node.new_doc(['a']).sample) }
+      it('#shelljoin')      { assert_equal('a', JSI::JSON::Node.new_doc(['a']).shelljoin) } if [].respond_to?(:shelljoin)
+      it('#shuffle')       { assert_equal(3, node.shuffle.size) }
+      it('#slice')        { assert_equal(['a'], node.slice(0, 1)) }
+      it('#sort')        { assert_equal(['a'], JSI::JSON::Node.new_doc(['a']).sort) }
+      it('#take')       { assert_equal(['a'], node.take(1)) }
+      it('#take_while') { assert_equal([], node.take_while { false }) }
+      it('#transpose') { assert_equal([], JSI::JSON::Node.new_doc([]).transpose) }
+      it('#uniq')     { assert_equal(node.to_a, node.uniq) }
+      it('#values_at') { assert_equal(['a'], node.values_at(0)) }
+      it('#zip')      { assert_equal([['a', 'a'], [node[1], node[1]], [node[2], node[2]]], node.zip(node)) }
     end
     describe 'modified copy methods' do
       it('#reject')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.reject { |e| e != 'a' }) }
       it('#select')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.select { |e| e == 'a' }) }
-      it('#compact') { assert_equal(JSI::JSON::Node.new_doc(node.content.to_ary), node.compact) }
+      it('#compact') { assert_equal(JSI::JSON::Node.new_doc(node.node_content.to_ary), node.compact) }
       describe 'at a depth' do
-        let(:document) { document_type[:make_document].call([['b', 'q'], {'c' => ['d', 'e']}]) }
+        let(:node_document) { document_type[:make_document].call([['b', 'q'], {'c' => ['d', 'e']}]) }
         let(:path) { ['1', 'c'] }
         it('#select') do
           selected = node.select { |e| e == 'd' }
-          equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], ['1', 'c'])
+          equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], node_ptr)
           assert_equal(equivalent, selected)
         end
       end

data/test/jsi_json_hashnode_test.rb

@@ -3,23 +3,24 @@ require_relative 'test_helper'
 document_types = [
   {
     make_document: -> (d) { d },
-    document: {'a' => 'b', 'c' => {'d' => 'e'}},
+    node_document: {'a' => 'b', 'c' => {'d' => 'e'}},
     type_desc: 'Hash',
   },
   {
     make_document: -> (d) { SortOfHash.new(d) },
-    document: SortOfHash.new({'a' => 'b', 'c' => SortOfHash.new({'d' => 'e'})}),
+    node_document: SortOfHash.new({'a' => 'b', 'c' => SortOfHash.new({'d' => 'e'})}),
     type_desc: 'sort of Hash-like',
   },
 ]
 document_types.each do |document_type|
   describe "JSI::JSON::HashNode with #{document_type[:type_desc]}" do
-    # document of the node being tested
-    let(:document) { document_type[:document] }
+    # node_document of the node being tested
+    let(:node_document) { document_type[:node_document] }
     # by default the node is the whole document
     let(:path) { [] }
+    let(:node_ptr) { JSI::JSON::Pointer.new(path) }
     # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, path) }
+    let(:node) { JSI::JSON::Node.new_by_type(node_document, node_ptr) }
 
     describe '#each' do
       it 'iterates, one argument' do
@@ -54,21 +55,21 @@ document_types.each do |document_type|
       end
     end
     describe '#merge' do
-      let(:document) { document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}) }
+      let(:node_document) { document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}) }
       # testing the node at 'c' here, merging a hash at a path within a document.
       let(:path) { ['c'] }
       it 'merges' do
         merged = node.merge('x' => 'y')
-        # check the content at 'c' was merged with the remainder of the document intact (at 'a')
-        assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e', 'x' => 'y'}}, merged.document)
+        # check the node_content at 'c' was merged with the remainder of the document intact (at 'a')
+        assert_equal({'a' => {'b' => 0}, 'c' => {'d' => 'e', 'x' => 'y'}}, merged.node_document)
         # check the original node retains its original document
-        assert_equal(document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}), node.document)
+        assert_equal(document_type[:make_document].call({'a' => {'b' => 0}, 'c' => {'d' => 'e'}}), node.node_document)
         # check that unnecessary copies of unaffected parts of the document were not made
-        assert_equal(node.document.to_hash['a'].object_id, merged.document['a'].object_id)
+        assert_equal(node.node_document.to_hash['a'].object_id, merged.node_document['a'].object_id)
       end
     end
     describe '#as_json' do
-      let(:document) { document_type[:make_document].call({'a' => 'b'}) }
+      let(:node_document) { document_type[:make_document].call({'a' => 'b'}) }
       it '#as_json' do
         assert_equal({'a' => 'b'}, node.as_json)
         assert_equal({'a' => 'b'}, node.as_json(this_option: 'what?'))
@@ -80,46 +81,46 @@ document_types.each do |document_type|
       it('#empty?')   { assert_equal(false, node.empty?) }
       it('#has_key?') { assert_equal(true, node.has_key?('a')) }
       it('#include?') { assert_equal(false, node.include?('q')) }
-      it('#key?')     { assert_equal(true, node.key?('c')) }
-      it('#keys')     { assert_equal(['a', 'c'], node.keys) }
-      it('#length')   { assert_equal(2, node.length) }
-      it('#member?')  { assert_equal(false, node.member?(0)) }
-      it('#size')     { assert_equal(2, node.size) }
+      it('#key?')    { assert_equal(true, node.key?('c')) }
+      it('#keys')   { assert_equal(['a', 'c'], node.keys) }
+      it('#length') { assert_equal(2, node.length) }
+      it('#member?') { assert_equal(false, node.member?(0)) }
+      it('#size')   { assert_equal(2, node.size) }
     end
     describe 'key + value methods' do
-      it('#<')            { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
-      it('#<=')           { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
-      it('#>')            { assert_equal(true, node > {}) } if {}.respond_to?(:>)
-      it('#>=')           { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
-      it('#any?')         { assert_equal(false, node.any? { |k, v| v == 3 }) }
-      it('#assoc')        { assert_equal(['a', 'b'], node.assoc('a')) }
-      it('#dig')          { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
-      it('#each_pair')    { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
-      it('#each_value')   { assert_equal(['b', node['c']], node.each_value.to_a) }
-      it('#fetch')        { assert_equal('b', node.fetch('a')) }
+      it('#<')  { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
+      it('#<=')  { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
+      it('#>')    { assert_equal(true, node > {}) } if {}.respond_to?(:>)
+      it('#>=')    { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
+      it('#any?')   { assert_equal(false, node.any? { |k, v| v == 3 }) }
+      it('#assoc')   { assert_equal(['a', 'b'], node.assoc('a')) }
+      it('#dig')      { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
+      it('#each_pair') { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
+      it('#each_value') { assert_equal(['b', node['c']], node.each_value.to_a) }
+      it('#fetch')       { assert_equal('b', node.fetch('a')) }
       it('#fetch_values') { assert_equal(['b'], node.fetch_values('a')) } if {}.respond_to?(:fetch_values)
-      it('#has_value?')   { assert_equal(true, node.has_value?('b')) }
-      it('#invert')       { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
-      it('#key')          { assert_equal('a', node.key('b')) }
-      it('#rassoc')       { assert_equal(['a', 'b'], node.rassoc('b')) }
-      it('#to_h')         { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
-      it('#to_proc')      { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
+      it('#has_value?')  { assert_equal(true, node.has_value?('b')) }
+      it('#invert')     { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
+      it('#key')       { assert_equal('a', node.key('b')) }
+      it('#rassoc')   { assert_equal(['a', 'b'], node.rassoc('b')) }
+      it('#to_h')    { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
+      it('#to_proc') { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
       if {}.respond_to?(:transform_values)
         it('#transform_values') { assert_equal({'a' => nil, 'c' => nil}, node.transform_values { |_| nil }) }
       end
-      it('#value?')       { assert_equal(false, node.value?('0')) }
-      it('#values')       { assert_equal(['b', node['c']], node.values) }
-      it('#values_at')    { assert_equal(['b'], node.values_at('a')) }
+      it('#value?')  { assert_equal(false, node.value?('0')) }
+      it('#values')   { assert_equal(['b', node['c']], node.values) }
+      it('#values_at') { assert_equal(['b'], node.values_at('a')) }
     end
     describe 'modified copy methods' do
       # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
       # tests of all the modified copy methods here
-      it('#merge')            { assert_equal(JSI::JSON::Node.new_doc(node.content.to_hash), node.merge({})) }
-      it('#reject')           { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
-      it('#select')           { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
+      it('#merge') { assert_equal(JSI::JSON::Node.new_doc(node.node_content), node.merge({})) }
+      it('#reject') { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
+      it('#select') { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
       # Hash#compact only available as of ruby 2.5.0
       if {}.respond_to?(:compact)
-        it('#compact') { assert_equal(JSI::JSON::Node.new_doc({"a" => "b", "c" => node.content.to_hash["c"]}), node.compact) }
+        it('#compact') { assert_equal(JSI::JSON::Node.new_doc({"a" => "b", "c" => node.node_content.to_hash["c"]}), node.compact) }
       end
     end
     JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|

data/test/jsi_json_node_test.rb

@@ -2,61 +2,70 @@ require_relative 'test_helper'
 
 describe JSI::JSON::Node do
   let(:path) { [] }
-  let(:node) { JSI::JSON::Node.new(document, path) }
+  let(:node_ptr) { JSI::JSON::Pointer.new(path) }
+  let(:node) { JSI::JSON::Node.new(node_document, node_ptr) }
 
   describe 'initialization' do
     it 'initializes' do
-      node = JSI::JSON::Node.new({'a' => 'b'}, [])
-      assert_equal({'a' => 'b'}, node.document)
-      assert_equal([], node.path)
+      node = JSI::JSON::Node.new({'a' => 'b'}, node_ptr)
+      assert_equal({'a' => 'b'}, node.node_document)
+      assert_equal(JSI::JSON::Pointer.new([]), node.node_ptr)
+    end
+    it 'initializes, node_ptr is not node_ptr' do
+      err = assert_raises(TypeError) { JSI::JSON::Node.new({'a' => 'b'}, []) }
+      assert_equal('node_ptr must be a JSI::JSON::Pointer. got: [] (Array)', err.message)
+    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 # {\"a\"=>\"b\"}>", err.message)
     end
   end
   describe 'initialization by .new_by_type' do
     it 'initializes HashNode' do
       node = JSI::JSON::Node.new_doc({'a' => 'b'})
       assert_instance_of(JSI::JSON::HashNode, node)
-      assert_equal({'a' => 'b'}, node.document)
+      assert_equal({'a' => 'b'}, node.node_document)
     end
     it 'initializes ArrayNode' do
       node = JSI::JSON::Node.new_doc(['a', 'b'])
       assert_instance_of(JSI::JSON::ArrayNode, node)
-      assert_equal(['a', 'b'], node.document)
+      assert_equal(['a', 'b'], node.node_document)
     end
     it 'initializes Node' do
       object = Object.new
       node = JSI::JSON::Node.new_doc(object)
       assert_instance_of(JSI::JSON::Node, node)
-      assert_equal(object, node.document)
+      assert_equal(object, node.node_document)
     end
   end
-  describe '#pointer' do
-    it 'is a ::JSON::Schema::Pointer' do
-      assert_instance_of(::JSON::Schema::Pointer, JSI::JSON::Node.new({}, []).pointer)
+  describe '#node_ptr' do
+    it 'is a JSI::JSON::Pointer' do
+      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, node_ptr).node_ptr)
     end
   end
-  describe '#content' do
-    it 'returns the content at the root' do
-      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, []).content)
+  describe '#node_content' do
+    it 'returns the node_content at the root' do
+      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, node_ptr).node_content)
     end
-    it 'returns the content from the deep' do
-      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], [1, 'x', 0, 'a', 0]).content)
+    it 'returns the node_content from the deep' do
+      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], JSI::JSON::Pointer.new([1, 'x', 0, 'a', 0])).node_content)
     end
   end
   describe '#deref' do
-    let(:document) do
+    let(:node_document) do
       {
         'foo' => {'bar' => ['baz']},
         'a' => {'$ref' => '#/foo'},
       }
     end
     it 'follows a $ref' do
-      assert_equal({'bar' => ['baz']}, node['a'].deref.content)
+      assert_equal({'bar' => ['baz']}, node['a'].deref.node_content)
     end
     it 'returns the node when there is no $ref to follow' do
-      assert_equal({'bar' => ['baz']}, node['foo'].deref.content)
+      assert_equal({'bar' => ['baz']}, node['foo'].deref.node_content)
     end
     describe "dealing with google's invalid $refs" do
-      let(:document) do
+      let(:node_document) do
         {
           'schemas' => {'bar' => {'description' => ['baz']}},
           'a' => {'$ref' => 'bar', 'foo' => 'bar'},
@@ -64,163 +73,122 @@ describe JSI::JSON::Node do
       end
       it 'subscripts a node consisting of a $ref WITHOUT following' do
         subscripted = node['a']
-        assert_equal({'$ref' => 'bar', 'foo' => 'bar'}, subscripted.content)
-        assert_equal(['a'], subscripted.path)
+        assert_equal({'$ref' => 'bar', 'foo' => 'bar'}, subscripted.node_content)
+        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.node_ptr)
       end
       it 'looks for a node in #/schemas with the name of the $ref' do
-        assert_equal({'description' => ['baz']}, node['a'].deref.content)
-      end
-      it 'follows a $ref when subscripting past it' do
-        subscripted = node['a']['description']
-        assert_equal(['baz'], subscripted.content)
-        assert_equal(['schemas', 'bar', 'description'], subscripted.path)
-      end
-      it 'does not follow a $ref when subscripting a key that is present' do
-        subscripted = node['a']['foo']
-        assert_equal('bar', subscripted)
+        assert_equal({'description' => ['baz']}, node['a'].deref.node_content)
       end
     end
     describe "dealing with whatever this is" do
       # I think google uses this style in some cases maybe. I don't remember.
-      let(:document) do
+      let(:node_document) do
         {
           'schemas' => {'bar' => {'id' => 'BarID', 'description' => 'baz'}},
           'a' => {'$ref' => 'BarID'},
         }
       end
       it 'looks for a node in #/schemas with the name of the $ref' do
-        assert_equal({'id' => 'BarID', 'description' => 'baz'}, node['a'].deref.content)
+        assert_equal({'id' => 'BarID', 'description' => 'baz'}, node['a'].deref.node_content)
       end
     end
   end
   describe '#[]' do
     describe 'without dereferencing' do
-      let(:document) { [0, {'x' => [{'a' => ['b']}]}] }
+      let(:node_document) { [0, {'x' => [{'a' => ['b']}]}] }
       it 'subscripts arrays and hashes' do
         assert_equal('b', node[1]['x'][0]['a'][0])
       end
       it 'returns ArrayNode for an array' do
         subscripted = node[1]['x']
         assert_instance_of(JSI::JSON::ArrayNode, subscripted)
-        assert_equal([{'a' => ['b']}], subscripted.content)
-        assert_equal([1, 'x'], subscripted.path)
+        assert_equal([{'a' => ['b']}], subscripted.node_content)
+        assert_equal(JSI::JSON::Pointer.new([1, 'x']), subscripted.node_ptr)
       end
       it 'returns HashNode for a Hash' do
         subscripted = node[1]
         assert_instance_of(JSI::JSON::HashNode, subscripted)
-        assert_equal({'x' => [{'a' => ['b']}]}, subscripted.content)
-        assert_equal([1], subscripted.path)
+        assert_equal({'x' => [{'a' => ['b']}]}, subscripted.node_content)
+        assert_equal(JSI::JSON::Pointer.new([1]), subscripted.node_ptr)
+      end
+      describe 'node_content does not respond to []' do
+        let(:node_document) { Object.new }
+        it 'cannot subscript' do
+          err = assert_raises(NoMethodError) { node['x'] }
+          assert_equal("undefined method `[]`\nsubscripting with \"x\" (String) from Object. content is: #{node_document.pretty_inspect.chomp}", err.message)
+        end
       end
     end
     describe 'with dereferencing' do
-      let(:document) do
+      let(:node_document) do
         {
           'foo' => {'bar' => ['baz']},
           'a' => {'$ref' => '#/foo', 'description' => 'hi'}, # not sure a description is actually allowed here, whatever
         }
       end
-      it 'subscripts a node consisting of a $ref WITHOUT following' do
+      it 'subscripts a node consisting of a $ref without following' do
         subscripted = node['a']
-        assert_equal({'$ref' => '#/foo', 'description' => 'hi'}, subscripted.content)
-        assert_equal(['a'], subscripted.path)
-      end
-      it 'follows a $ref when subscripting past it' do
-        subscripted = node['a']['bar']
-        assert_equal(['baz'], subscripted.content)
-        assert_equal(['foo', 'bar'], subscripted.path)
-      end
-      it 'does not follow a $ref when subscripting a key that is present' do
-        subscripted = node['a']['description']
-        assert_equal('hi', subscripted)
+        assert_equal({'$ref' => '#/foo', 'description' => 'hi'}, subscripted.node_content)
+        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.node_ptr)
       end
     end
   end
   describe '#[]=' do
-    let(:document) { [0, {'x' => [{'a' => ['b']}]}] }
+    let(:node_document) { [0, {'x' => [{'a' => ['b']}]}] }
     it 'assigns' do
       node[0] = 'abcdefg'
-      assert_equal(['abcdefg', {'x' => [{'a' => ['b']}]}], document)
-      string_node = JSI::JSON::Node.new(document, [0])
+      assert_equal(['abcdefg', {'x' => [{'a' => ['b']}]}], node_document)
+      string_node = JSI::JSON::Node.new(node_document, JSI::JSON::Pointer.new([0]))
       string_node[0..2] = '0'
-      assert_equal(['0defg', {'x' => [{'a' => ['b']}]}], document)
+      assert_equal(['0defg', {'x' => [{'a' => ['b']}]}], node_document)
       node[0] = node[1]
-      assert_equal([{'x' => [{'a' => ['b']}]}, {'x' => [{'a' => ['b']}]}], document)
+      assert_equal([{'x' => [{'a' => ['b']}]}, {'x' => [{'a' => ['b']}]}], node_document)
     end
     it 'assigns, deeper' do
       node[1]['y'] = node[1]['x'][0]
-      assert_equal([0, {'x' => [{'a' => ['b']}], 'y' => {'a' => ['b']}}], document)
+      assert_equal([0, {'x' => [{'a' => ['b']}], 'y' => {'a' => ['b']}}], node_document)
     end
   end
-  describe '#document_node' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'has content that is the document' do
-      assert_equal({'a' => {'b' => 3}}, node['a'].document_node.content)
+  describe '#document_root_node' do
+    let(:node_document) { {'a' => {'b' => 3}} }
+    it 'has node_content that is the node_document' do
+      assert_equal({'a' => {'b' => 3}}, node['a'].document_root_node.node_content)
     end
   end
   describe '#parent_node' do
-    let(:document) { {'a' => {'b' => []}} }
+    let(:node_document) { {'a' => {'b' => []}} }
     it 'finds a parent' do
       sub = node['a']['b']
-      assert_equal(['a', 'b'], sub.path)
+      assert_equal(JSI::JSON::Pointer.new(['a', 'b']), sub.node_ptr)
       parent = sub.parent_node
-      assert_equal(['a'], parent.path)
-      assert_equal({'b' => []}, parent.content)
+      assert_equal(JSI::JSON::Pointer.new(['a']), parent.node_ptr)
+      assert_equal({'b' => []}, parent.node_content)
       assert_equal(node['a'], parent)
       root_from_sub = sub.parent_node.parent_node
-      assert_equal([], root_from_sub.path)
-      assert_equal({'a' => {'b' => []}}, root_from_sub.content)
+      assert_equal(JSI::JSON::Pointer.new([]), root_from_sub.node_ptr)
+      assert_equal({'a' => {'b' => []}}, root_from_sub.node_content)
       assert_equal(node, root_from_sub)
-      err = assert_raises(::JSON::Schema::Pointer::ReferenceError) do
+      err = assert_raises(JSI::JSON::Pointer::ReferenceError) do
         root_from_sub.parent_node
       end
-      assert_match(/\Acannot access parent of root node: #\{<JSI::JSON::HashNode/, err.message)
-    end
-  end
-  describe '#pointer_path' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'is empty' do
-      assert_equal('', node.pointer_path)
-    end
-    it 'is not empty' do
-      assert_equal('/a', node['a'].pointer_path)
-    end
-    describe 'containing an empty string and some slashes and tildes that need escaping' do
-      let(:document) { {'' => {'a/b~c!d#e[f]' => []}} }
-      it 'matches' do
-        assert_equal('//a~1b~0c!d#e[f]', node['']['a/b~c!d#e[f]'].pointer_path)
-      end
-    end
-  end
-  describe '#fragment' do
-    let(:document) { {'a' => {'b' => 3}} }
-    it 'is empty' do
-      assert_equal('#', node.fragment)
-    end
-    it 'is not empty' do
-      assert_equal('#/a', node['a'].fragment)
-    end
-    describe 'containing an empty string and some slashes and tildes that need escaping' do
-      let(:document) { {'' => {'a/b~c!d#e[f]' => []}} }
-      it 'matches' do
-        assert_equal('#//a~1b~0c!d#e%5Bf%5D', node['']['a/b~c!d#e[f]'].fragment)
-      end
+      assert_equal('cannot access parent of root pointer: JSI::JSON::Pointer[]', err.message)
     end
   end
   describe '#modified_copy' do
-    let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
+    let(:node_document) { [['b', 'q'], {'c' => ['d', 'e']}] }
     let(:path) { ['1', 'c'] }
     it 'returns a different object' do
       # simplest thing
       modified_dup = node.modified_copy(&:dup)
       # it is equal - being a dup
-      assert_equal(modified_dup, node)
+      assert_equal(node, modified_dup)
       # but different object
       refute_equal(node.object_id, modified_dup.object_id)
       # the parents, obviously, are different
-      refute_equal(node.parent_node.content.object_id, modified_dup.parent_node.content.object_id)
-      refute_equal(node.parent_node.parent_node.content.object_id, modified_dup.parent_node.parent_node.content.object_id)
-      # but any untouched part(s) - in this case the ['b', 'q'] at document[0] - are untouched
-      assert_equal(node.document_node[0].content.object_id, modified_dup.document_node[0].content.object_id)
+      refute_equal(node.parent_node.node_content.object_id, modified_dup.parent_node.node_content.object_id)
+      refute_equal(node.parent_node.parent_node.node_content.object_id, modified_dup.parent_node.parent_node.node_content.object_id)
+      # but any untouched part(s) - in this case the ['b', 'q'] at node_document[0] - are untouched
+      assert_equal(node.document_root_node[0].node_content.object_id, modified_dup.document_root_node[0].node_content.object_id)
     end
     it 'returns the same object' do
       unmodified_dup = node.modified_copy { |o| o }
@@ -228,59 +196,60 @@ describe JSI::JSON::Node do
       # same object, since the block just returned it
       refute_equal(node.object_id, unmodified_dup.object_id)
       # the parents are unchanged since the object is the same
-      assert_equal(node.parent_node.content.object_id, unmodified_dup.parent_node.content.object_id)
-      assert_equal(node.parent_node.parent_node.content.object_id, unmodified_dup.parent_node.parent_node.content.object_id)
-      # same as the other: any untouched part(s) - in this case the ['b', 'q'] at document[0] - are untouched
-      assert_equal(node.document_node[0].content.object_id, unmodified_dup.document_node[0].content.object_id)
+      assert_equal(node.parent_node.node_content.object_id, unmodified_dup.parent_node.node_content.object_id)
+      assert_equal(node.parent_node.parent_node.node_content.object_id, unmodified_dup.parent_node.parent_node.node_content.object_id)
+      # same as the other: any untouched part(s) - in this case the ['b', 'q'] at node_document[0] - are untouched
+      assert_equal(node.document_root_node[0].node_content.object_id, unmodified_dup.document_root_node[0].node_content.object_id)
     end
     it 'raises subscripting string from array' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, ['x']).modified_copy(&:dup) }
+      err = assert_raises(TypeError) { JSI::JSON::Node.new(node_document, JSI::JSON::Pointer.new(['x'])).modified_copy(&:dup) }
       assert_match(%r(\Abad subscript "x" with remaining subpath: \[\] for array: \[.*\]\z)m, err.message)
     end
     it 'raises subscripting from invalid subpath' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, [0, 0, 'what']).modified_copy(&:dup) }
+      err = assert_raises(TypeError) { JSI::JSON::Node.new(node_document, JSI::JSON::Pointer.new([0, 0, 'what'])).modified_copy(&:dup) }
       assert_match(%r(bad subscript: "what" with remaining subpath: \[\] for content: "b"\z)m, err.message)
     end
   end
   describe '#inspect' do
-    let(:document) { {'a' => {'c' => ['d', 'e']}} }
+    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(:document) { {'a' => {'c' => ['d', 'e']}} }
+    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 '#fingerprint' do
+  describe '#jsi_fingerprint' do
+    let(:node_ptr) { JSI::JSON::Pointer.new([]) }
     it 'hashes consistently' do
-      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new([0], [])])
+      assert_equal('x', {JSI::JSON::Node.new([0], node_ptr) => 'x'}[JSI::JSON::Node.new([0], node_ptr)])
     end
     it 'hashes consistently regardless of the Node being decorated as a subclass' do
-      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], [])])
-      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new_doc([0])])
+      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], node_ptr)])
+      assert_equal('x', {JSI::JSON::Node.new([0], node_ptr) => 'x'}[JSI::JSON::Node.new_doc([0])])
     end
     it '==' do
-      assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_doc([0]))
+      assert_equal(JSI::JSON::Node.new([0], node_ptr), JSI::JSON::Node.new([0], node_ptr))
+      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], node_ptr))
+      assert_equal(JSI::JSON::Node.new([0], node_ptr), JSI::JSON::Node.new_doc([0]))
       assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc([0]))
     end
     it '!=' do
-      refute_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_doc({}))
+      refute_equal(JSI::JSON::Node.new([0], node_ptr), JSI::JSON::Node.new({}, node_ptr))
+      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, node_ptr))
+      refute_equal(JSI::JSON::Node.new([0], node_ptr), JSI::JSON::Node.new_doc({}))
       refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc({}))
       refute_equal({}, JSI::JSON::Node.new_doc({}))
       refute_equal(JSI::JSON::Node.new_doc({}), {})
     end
   end
   describe '#as_json' do
-    let(:document) { {'a' => 'b'} }
+    let(:node_document) { {'a' => 'b'} }
     it '#as_json' do
       assert_equal({'a' => 'b'}, node.as_json)
     end