jsi 0.2.1 → 0.3.0

data/test/jsi_coder_test.rb

@@ -1,28 +1,28 @@
 require_relative 'test_helper'
 
 describe JSI::JSICoder do
-  let(:schema) do
+  let(:schema_object) do
     {properties: {foo: {}, bar: {}}}
   end
-  let(:schema_instance_class) { JSI.class_for_schema(schema) }
+  let(:schema) { JSI::Schema.new(schema_object) }
   let(:options) { {} }
-  let(:schema_instance_json_coder) { JSI::JSICoder.new(schema_instance_class, 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_instance_class.new('foo' => 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
+        assert_equal(schema.new_jsi('foo' => 'bar'), schema_instance_json_coder.load({"foo" => "bar"}))
       end
       it 'loads something else' do
-        assert_equal(schema_instance_class.new([[]]), schema_instance_json_coder.load([[]]))
+        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_instance_class.new('foo' => 'bar'), schema_instance_class.new('foo' => 'baz')], schema_instance_json_coder.load(data))
+          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([]))
@@ -34,17 +34,17 @@ describe JSI::JSICoder do
         end
       end
       describe 'array schema' do
-        let(:schema) { {items: {properties: {foo: {}, bar: {}}}} }
+        let(:schema_object) { {items: {properties: {foo: {}, bar: {}}}} }
         it 'loads an array of hashes' do
           data = [{"foo" => "bar"}, {"foo" => "baz"}]
-          assert_equal(schema_instance_class.new([{'foo' => 'bar'}, {'foo' => 'baz'}]), schema_instance_json_coder.load(data))
+          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_instance_class.new([]), schema_instance_json_coder.load([]))
+          assert_equal(schema.new_jsi([]), schema_instance_json_coder.load([]))
         end
         it 'loads a not an array' do
           instance = Object.new
-          assert_equal(schema_instance_class.new(instance), schema_instance_json_coder.load(instance))
+          assert_equal(schema.new_jsi(instance), schema_instance_json_coder.load(instance))
         end
       end
     end
@@ -53,7 +53,7 @@ describe JSI::JSICoder 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_instance_class.new(foo: 'x', bar: 'y')))
+        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
@@ -69,14 +69,14 @@ describe JSI::JSICoder do
       describe 'array' do
         let(:options) { {array: true} }
         it 'dumps an array of schema_instances' do
-          schema_instances = [schema_instance_class.new(foo: 'x', bar: 'y'), schema_instance_class.new(foo: 'z', bar: 'q')]
+          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) { {items: {properties: {foo: {}, bar: {}}}} }
+        let(:schema_object) { {items: {properties: {foo: {}, bar: {}}}} }
         it 'dumps a schema_instance array' do
-          schema_instances = schema_instance_class.new([{foo: 'x', bar: 'y'}, {foo: 'z', bar: 'q'}])
+          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

data/test/jsi_json_arraynode_test.rb

@@ -3,24 +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(:pointer) { JSI::JSON::Pointer.new(path) }
+    let(:node_ptr) { JSI::JSON::Pointer.new(path) }
     # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, pointer) }
+    let(:node) { JSI::JSON::Node.new_by_type(node_document, node_ptr) }
 
     describe '#[] bad index' do
       it 'improves TypeError for Array subsript' do
@@ -56,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))
@@ -130,13 +130,13 @@ document_types.each do |document_type|
     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']}], pointer)
+          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,24 +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(:pointer) { JSI::JSON::Pointer.new(path) }
+    let(:node_ptr) { JSI::JSON::Pointer.new(path) }
     # the node being tested
-    let(:node) { JSI::JSON::Node.new_by_type(document, pointer) }
+    let(:node) { JSI::JSON::Node.new_by_type(node_document, node_ptr) }
 
     describe '#each' do
       it 'iterates, one argument' do
@@ -55,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?'))
@@ -115,12 +115,12 @@ document_types.each do |document_type|
     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), node.merge({})) }
+      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,75 +2,70 @@ require_relative 'test_helper'
 
 describe JSI::JSON::Node do
   let(:path) { [] }
-  let(:pointer) { JSI::JSON::Pointer.new(path) }
-  let(:node) { JSI::JSON::Node.new(document, pointer) }
+  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'}, pointer)
-      assert_equal({'a' => 'b'}, node.document)
-      assert_equal(JSI::JSON::Pointer.new([]), node.pointer)
+      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, pointer is not pointer' do
+    it 'initializes, node_ptr is not node_ptr' do
       err = assert_raises(TypeError) { JSI::JSON::Node.new({'a' => 'b'}, []) }
-      assert_equal('pointer must be a JSI::JSON::Pointer. got: [] (Array)', err.message)
+      assert_equal('node_ptr must be a JSI::JSON::Pointer. got: [] (Array)', err.message)
     end
-    it 'initializes, document is another Node' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(JSI::JSON::Node.new({'a' => 'b'}, pointer), pointer) }
-      assert_equal("document of a Node should not be another JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" {\"a\"=>\"b\"}>", err.message)
+    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)
     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
+  describe '#node_ptr' do
     it 'is a JSI::JSON::Pointer' do
-      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, pointer).pointer)
+      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, node_ptr).node_ptr)
     end
   end
-  describe '#path' do
-    it 'is an array of reference tokens' do
-      assert_equal(['a'], JSI::JSON::Node.new({}, JSI::JSON::Pointer.new(['a'])).path)
+  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
-  end
-  describe '#content' do
-    it 'returns the content at the root' do
-      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, pointer).content)
-    end
-    it 'returns the 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])).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'},
@@ -78,118 +73,100 @@ 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(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
+        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(JSI::JSON::Pointer.new(['schemas', 'bar', 'description']), subscripted.pointer)
-      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(JSI::JSON::Pointer.new([1, 'x']), subscripted.pointer)
+        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(JSI::JSON::Pointer.new([1]), subscripted.pointer)
+        assert_equal({'x' => [{'a' => ['b']}]}, subscripted.node_content)
+        assert_equal(JSI::JSON::Pointer.new([1]), subscripted.node_ptr)
       end
-      describe 'content does not respond to []' do
-        let(:document) { Object.new }
+      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: #{document.pretty_inspect.chomp}", err.message)
+          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(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
-      end
-      it 'follows a $ref when subscripting past it' do
-        subscripted = node['a']['bar']
-        assert_equal(['baz'], subscripted.content)
-        assert_equal(JSI::JSON::Pointer.new(['foo', 'bar']), subscripted.pointer)
-      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, JSI::JSON::Pointer.new([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(JSI::JSON::Pointer.new(['a', 'b']), sub.pointer)
+      assert_equal(JSI::JSON::Pointer.new(['a', 'b']), sub.node_ptr)
       parent = sub.parent_node
-      assert_equal(JSI::JSON::Pointer.new(['a']), parent.pointer)
-      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(JSI::JSON::Pointer.new([]), root_from_sub.pointer)
-      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(JSI::JSON::Pointer::ReferenceError) do
         root_from_sub.parent_node
@@ -197,51 +174,21 @@ describe JSI::JSON::Node do
       assert_match(/\Acannot access parent of root pointer: #<JSI::JSON::Pointer/, 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
-    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 }
@@ -249,60 +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, JSI::JSON::Pointer.new(['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, JSI::JSON::Pointer.new([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)
     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)
     end
   end
-  describe '#fingerprint' do
-    let(:pointer) { JSI::JSON::Pointer.new([]) }
+  describe '#jsi_fingerprint' do
+    let(:node_ptr) { JSI::JSON::Pointer.new([]) }
     it 'hashes consistently' do
-      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => 'x'}[JSI::JSON::Node.new([0], pointer)])
+      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], pointer)])
-      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => '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], pointer), JSI::JSON::Node.new([0], pointer))
-      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], pointer))
-      assert_equal(JSI::JSON::Node.new([0], pointer), 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], pointer), JSI::JSON::Node.new({}, pointer))
-      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, pointer))
-      refute_equal(JSI::JSON::Node.new([0], pointer), 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