jsi 0.4.0 → 0.7.0

data/test/jsi_json_arraynode_test.rb

@@ -1,150 +0,0 @@
-require_relative 'test_helper'
-
-document_types = [
-  {
-    make_document: -> (d) { d },
-    node_document: ['a', ['b', 'q'], {'c' => {'d' => 'e'}}],
-    type_desc: 'Array',
-  },
-  {
-    make_document: -> (d) { SortOfArray.new(d) },
-    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
-    # 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(node_document, node_ptr) }
-
-    describe '#[] bad index' do
-      it 'improves TypeError for Array subsript' do
-        err = assert_raises(TypeError) do
-          node[:x]
-        end
-        assert_match(/^subscripting with :x \(Symbol\) from Array. content is: \[.*\]\z/m, err.message)
-      end
-    end
-    describe '#each' do
-      it 'iterates, one argument' do
-        out = []
-        node.each do |arg|
-          out << arg
-        end
-        assert_instance_of(JSI::JSON::ArrayNode, node[1])
-        assert_instance_of(JSI::JSON::HashNode, node[2])
-        assert_equal(['a', node[1], node[2]], out)
-      end
-      it 'returns self' do
-        assert_equal(node.each { }.object_id, node.object_id)
-      end
-      it 'returns an enumerator when called with no block' do
-        enum = node.each
-        assert_instance_of(Enumerator, enum)
-        assert_equal(['a', node[1], node[2]], enum.to_a)
-      end
-    end
-    describe '#to_ary' do
-      it 'returns a Array with Nodes in' do
-        assert_instance_of(Array, node.to_ary)
-        assert_equal(['a', node[1], node[2]], node.to_ary)
-      end
-    end
-    describe '#as_json' do
-      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))
-      end
-    end
-    # these methods just delegate to Array so not going to test excessively
-    describe 'index only methods' do
-      it('#each_index') { assert_equal([0, 1, 2], node.each_index.to_a) }
-      it('#empty?')     { assert_equal(false, node.empty?) }
-      it('#length')     { assert_equal(3, node.length) }
-      it('#size')       { assert_equal(3, node.size) }
-    end
-    describe 'index + element methods' do
-      it('#|')                    { assert_equal(['a', node[1], node[2], 0], node | [0]) }
-      it('#&')                    { assert_equal(['a'], node & ['a']) }
-      it('#*')                    { assert_equal(node.to_a, node * 1) }
-      it('#+')                    { assert_equal(node.to_a, node + []) }
-      it('#-')                    { assert_equal([node[1], node[2]], node - ['a']) }
-      it('#<=>')                  { assert_equal(1, node <=> []) }
-      it('#<=>')                  { assert_equal(-1, [] <=> node) }
-      require 'abbrev'
-      it('#abbrev')               { assert_equal({'a' => 'a'}, JSI::JSON::Node.new_doc(['a']).abbrev) }
-      it('#assoc')                { assert_equal(['b', 'q'], node.assoc('b')) }
-      it('#at')                   { assert_equal('a', node.at(0)) }
-      it('#bsearch')              { assert_equal(nil, node.bsearch { false }) }
-      it('#bsearch_index')        { assert_equal(nil, node.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
-      it('#combination')          { assert_equal([['a'], [node[1]], [node[2]]], node.combination(1).to_a) }
-      it('#count')                { assert_equal(1, node.count('a')) }
-      it('#cycle')                { assert_equal(node.to_a, node.cycle(1).to_a) }
-      it('#dig')                  { assert_equal('e', node.dig(2, 'c', 'd')) } if [].respond_to?(:dig)
-      it('#drop')                 { assert_equal([node[2]], node.drop(2)) }
-      it('#drop_while')           { assert_equal([node[1], node[2]], node.drop_while { |e| e == 'a' }) }
-      it('#fetch')                { assert_equal('a', node.fetch(0)) }
-      it('#find_index')           { assert_equal(0, node.find_index { true }) }
-      it('#first')                { assert_equal('a', node.first) }
-      it('#include?')             { assert_equal(true, node.include?('a')) }
-      it('#index')                { assert_equal(0, node.index('a')) }
-      it('#join')                 { assert_equal('a b', JSI::JSON::Node.new_doc(['a', 'b']).join(' ')) }
-      it('#last')                 { assert_equal(node[2], node.last) }
-      it('#pack')                 { assert_equal(' ', JSI::JSON::Node.new_doc([32]).pack('c')) }
-      it('#permutation')          { assert_equal([['a'], [node[1]], [node[2]]], node.permutation(1).to_a) }
-      it('#product')              { assert_equal([], node.product([])) }
-      # due to differences in implementation between #assoc and #rassoc, the reason for which
-      # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
-      # type checking than assoc for the array(like) array elements.
-      # compare:
-      # assoc:  https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
-      # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
-      # 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('#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)) }
-    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.node_content.to_ary), node.compact) }
-      describe 'at a depth' do
-        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']}], node_ptr)
-          assert_equal(equivalent, selected)
-        end
-      end
-    end
-    JSI::Arraylike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-      it("does not respond to destructive method #{destructive_method_name}") do
-        assert(!node.respond_to?(destructive_method_name))
-      end
-    end
-  end
-end

data/test/jsi_json_hashnode_test.rb

@@ -1,132 +0,0 @@
-require_relative 'test_helper'
-
-document_types = [
-  {
-    make_document: -> (d) { d },
-    node_document: {'a' => 'b', 'c' => {'d' => 'e'}},
-    type_desc: 'Hash',
-  },
-  {
-    make_document: -> (d) { SortOfHash.new(d) },
-    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
-    # 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(node_document, node_ptr) }
-
-    describe '#each' do
-      it 'iterates, one argument' do
-        out = []
-        node.each do |arg|
-          out << arg
-        end
-        assert_instance_of(JSI::JSON::HashNode, node['c'])
-        assert_equal([['a', 'b'], ['c', node['c']]], out)
-      end
-      it 'iterates, two arguments' do
-        out = []
-        node.each do |k, v|
-          out << [k, v]
-        end
-        assert_instance_of(JSI::JSON::HashNode, node['c'])
-        assert_equal([['a', 'b'], ['c', node['c']]], out)
-      end
-      it 'returns self' do
-        assert_equal(node.each { }.object_id, node.object_id)
-      end
-      it 'returns an enumerator when called with no block' do
-        enum = node.each
-        assert_instance_of(Enumerator, enum)
-        assert_equal([['a', 'b'], ['c', node['c']]], enum.to_a)
-      end
-    end
-    describe '#to_hash' do
-      it 'returns a Hash with Nodes in' do
-        assert_instance_of(Hash, node.to_hash)
-        assert_equal({'a' => 'b', 'c' => node['c']}, node.to_hash)
-      end
-    end
-    describe '#merge' do
-      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 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.node_document)
-        # check that unnecessary copies of unaffected parts of the document were not made
-        assert_equal(node.node_document.to_hash['a'].object_id, merged.node_document['a'].object_id)
-      end
-    end
-    describe '#as_json' do
-      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?'))
-      end
-    end
-    # these methods just delegate to Hash so not going to test excessively
-    describe 'key only methods' do
-      it('#each_key') { assert_equal(['a', 'c'], node.each_key.to_a) }
-      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) }
-    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('#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)
-      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')) }
-    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.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.node_content.to_hash["c"]}), node.compact) }
-      end
-    end
-    JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-      it("does not respond to destructive method #{destructive_method_name}") do
-        assert(!node.respond_to?(destructive_method_name))
-      end
-    end
-  end
-end

data/test/jsi_json_node_test.rb

@@ -1,257 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::JSON::Node do
-  let(: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'}, 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.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.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.node_document)
-    end
-  end
-  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 '#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 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(:node_document) do
-      {
-        'foo' => {'bar' => ['baz']},
-        'a' => {'$ref' => '#/foo'},
-      }
-    end
-    it 'follows a $ref' do
-      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.node_content)
-    end
-    describe "dealing with google's invalid $refs" do
-      let(:node_document) do
-        {
-          'schemas' => {'bar' => {'description' => ['baz']}},
-          'a' => {'$ref' => 'bar', 'foo' => 'bar'},
-        }
-      end
-      it 'subscripts a node consisting of a $ref WITHOUT following' do
-        subscripted = node['a']
-        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.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(: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.node_content)
-      end
-    end
-  end
-  describe '#[]' do
-    describe 'without dereferencing' do
-      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.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.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(: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
-        subscripted = node['a']
-        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(:node_document) { [0, {'x' => [{'a' => ['b']}]}] }
-    it 'assigns' do
-      node[0] = 'abcdefg'
-      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']}]}], node_document)
-      node[0] = node[1]
-      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']}}], node_document)
-    end
-  end
-  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(:node_document) { {'a' => {'b' => []}} }
-    it 'finds a parent' do
-      sub = node['a']['b']
-      assert_equal(JSI::JSON::Pointer.new(['a', 'b']), sub.node_ptr)
-      parent = sub.parent_node
-      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.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
-      end
-      assert_equal('cannot access parent of root pointer: JSI::JSON::Pointer[]', err.message)
-    end
-  end
-  describe '#modified_copy' do
-    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(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.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 }
-      assert_equal(unmodified_dup, node)
-      # 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.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(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(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(:node_document) { {'a' => {'c' => ['d', 'e']}} }
-    let(:path) { ['a'] }
-    it 'inspects' do
-      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 #/a {"c"=>["d", "e"]}>), node.pretty_inspect.chomp)
-    end
-  end
-  describe '#jsi_fingerprint' do
-    let(:node_ptr) { JSI::JSON::Pointer.new([]) }
-    it 'hashes consistently' do
-      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], 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], 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], 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(:node_document) { {'a' => 'b'} }
-    it '#as_json' do
-      assert_equal({'a' => 'b'}, node.as_json)
-    end
-  end
-end

data/test/jsi_json_pointer_test.rb

@@ -1,102 +0,0 @@
-require_relative 'test_helper'
-
-describe JSI::JSON::Pointer do
-  # For example, given the document
-  let(:document) do
-    {
-       "foo" => ["bar", "baz"],
-       "" => 0,
-       "a/b" => 1,
-       "c%d" => 2,
-       "e^f" => 3,
-       "g|h" => 4,
-       "i\\j" => 5,
-       "k\"l" => 6,
-       " " => 7,
-       "m~n" => 8,
-    }
-  end
-
-  describe 'initialize from pointer' do
-    it 'parses' do
-      # The following strings evaluate to the accompanying values:
-      evaluations = [
-        ""      ,     document,
-        "/foo"  ,     ["bar", "baz"],
-        "/foo/0",     "bar",
-        "/"     ,     0,
-        "/a~1b" ,     1,
-        "/c%d"  ,     2,
-        "/e^f"  ,     3,
-        "/g|h"  ,     4,
-        "/i\\j" ,     5,
-        "/k\"l" ,     6,
-        "/ "    ,     7,
-        "/m~0n" ,     8,
-      ]
-      evaluations.each_slice(2) do |pointer, value|
-        assert_equal(value, JSI::JSON::Pointer.from_pointer(pointer).evaluate(document))
-      end
-    end
-
-    it 'raises for invalid syntax' do
-      err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.from_pointer("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
-  end
-  describe 'initialize from fragment' do
-    # For example, given the document
-    let(:document) do
-      {
-         "foo" => ["bar", "baz"],
-         "" => 0,
-         "a/b" => 1,
-         "c%d" => 2,
-         "e^f" => 3,
-         "g|h" => 4,
-         "i\\j" => 5,
-         "k\"l" => 6,
-         " " => 7,
-         "m~n" => 8,
-      }
-    end
-
-    it 'parses' do
-      # the following URI fragment identifiers evaluate to the accompanying values:
-      evaluations = [
-        '#',            document,
-        '#/foo',        ["bar", "baz"],
-        '#/foo/0',      "bar",
-        '#/',           0,
-        '#/a~1b',       1,
-        '#/c%25d',      2,
-        '#/e%5Ef',      3,
-        '#/g%7Ch',      4,
-        '#/i%5Cj',      5,
-        '#/k%22l',      6,
-        '#/%20',        7,
-        '#/m~0n',       8,
-      ]
-      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 slash").evaluate(document)
-      end
-      assert_equal("Invalid pointer syntax in \"this does not begin with slash\": pointer must begin with /", err.message)
-    end
-  end
-  describe 'initialize' do
-    describe 'invalid reference_tokens' do
-      it 'raises' do
-        err = assert_raises(TypeError) { JSI::JSON::Pointer.new({}) }
-        assert_equal("reference_tokens must be an array. got: {}", err.message)
-      end
-    end
-  end
-end

data/test/jsi_test.rb

@@ -1,11 +0,0 @@
-require_relative 'test_helper'
-
-class JSITest < Minitest::Test
-  def test_that_it_has_a_version_number
-    refute_nil ::JSI::VERSION
-  end
-
-  def test_it_does_something_useful
-    assert true
-  end
-end