jsi 0.1.0 → 0.2.0

data/lib/jsi/util.rb

@@ -1,5 +1,8 @@
 module JSI
   module Util
+    # a proc which does nothing
+    NOOP = -> (*_) { }
+
     # returns a version of the given hash, in which any symbol keys are
     # converted to strings. behavior on collisions is undefined (but in the
     # future could take a block like

data/lib/jsi/version.rb

@@ -1,3 +1,3 @@
 module JSI
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/test/base_array_test.rb

@@ -5,7 +5,8 @@ describe JSI::BaseArray do
     ['foo', {'lamp' => [3]}, ['q', 'r']]
   end
   let(:path) { [] }
-  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:pointer) { JSI::JSON::Pointer.new(path) }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
   let(:schema_content) do
     {
       'type' => 'array',
@@ -106,40 +107,40 @@ describe JSI::BaseArray do
   # 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], subject.each_index.to_a) }
-    it('#empty?')     { assert_equal(false, subject.empty?) }
-    it('#length')     { assert_equal(3, subject.length) }
-    it('#size')       { assert_equal(3, subject.size) }
+    it('#empty?')    { assert_equal(false, subject.empty?) }
+    it('#length')   { assert_equal(3, subject.length) }
+    it('#size')    { assert_equal(3, subject.size) }
   end
   describe 'index + element methods' do
-    it('#|')                    { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
-    it('#&')                    { assert_equal(['foo'], subject & ['foo']) }
-    it('#*')                    { assert_equal(subject.to_a, subject * 1) }
-    it('#+')                    { assert_equal(subject.to_a, subject + []) }
-    it('#-')                    { assert_equal([subject[1], subject[2]], subject - ['foo']) }
-    it('#<=>')                  { assert_equal(1, subject <=> []) }
-    it('#<=>')                  { assert_equal(-1, [] <=> subject) }
+    it('#|')  { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
+    it('#&')   { assert_equal(['foo'], subject & ['foo']) }
+    it('#*')    { assert_equal(subject.to_a, subject * 1) }
+    it('#+')     { assert_equal(subject.to_a, subject + []) }
+    it('#-')      { assert_equal([subject[1], subject[2]], subject - ['foo']) }
+    it('#<=>')     { assert_equal(1, subject <=> []) }
+    it('#<=>')      { assert_equal(-1, [] <=> subject) }
     require 'abbrev'
-    it('#abbrev')               { assert_equal({'a' => 'a'}, class_for_schema.new(['a']).abbrev) }
-    it('#assoc')                { assert_equal(['q', 'r'], subject.instance.assoc('q')) }
-    it('#at')                   { assert_equal('foo', subject.at(0)) }
-    it('#bsearch')              { assert_equal(nil, subject.bsearch { false }) }
-    it('#bsearch_index')        { assert_equal(nil, subject.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
-    it('#combination')          { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.combination(1).to_a) }
-    it('#count')                { assert_equal(1, subject.count('foo')) }
-    it('#cycle')                { assert_equal(subject.to_a, subject.cycle(1).to_a) }
-    it('#dig')                  { assert_equal(3, subject.dig(1, 'lamp', 0)) } if [].respond_to?(:dig)
-    it('#drop')                 { assert_equal([subject[2]], subject.drop(2)) }
-    it('#drop_while')           { assert_equal([subject[1], subject[2]], subject.drop_while { |e| e == 'foo' }) }
-    it('#fetch')                { assert_equal('foo', subject.fetch(0)) }
-    it('#find_index')           { assert_equal(0, subject.find_index { true }) }
-    it('#first')                { assert_equal('foo', subject.first) }
-    it('#include?')             { assert_equal(true, subject.include?('foo')) }
-    it('#index')                { assert_equal(0, subject.index('foo')) }
-    it('#join')                 { assert_equal('a b', class_for_schema.new(['a', 'b']).join(' ')) }
-    it('#last')                 { assert_equal(subject[2], subject.last) }
-    it('#pack')                 { assert_equal(' ', class_for_schema.new([32]).pack('c')) }
-    it('#permutation')          { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.permutation(1).to_a) }
-    it('#product')              { assert_equal([], subject.product([])) }
+    it('#abbrev')    { assert_equal({'a' => 'a'}, class_for_schema.new(['a']).abbrev) }
+    it('#assoc')      { assert_equal(['q', 'r'], subject.assoc('q')) }
+    it('#at')          { assert_equal('foo', subject.at(0)) }
+    it('#bsearch')      { assert_equal(nil, subject.bsearch { false }) }
+    it('#bsearch_index') { assert_equal(nil, subject.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
+    it('#combination')  { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.combination(1).to_a) }
+    it('#count')       { assert_equal(1, subject.count('foo')) }
+    it('#cycle')      { assert_equal(subject.to_a, subject.cycle(1).to_a) }
+    it('#dig')       { assert_equal(3, subject.dig(1, 'lamp', 0)) } if [].respond_to?(:dig)
+    it('#drop')      { assert_equal([subject[2]], subject.drop(2)) }
+    it('#drop_while') { assert_equal([subject[1], subject[2]], subject.drop_while { |e| e == 'foo' }) }
+    it('#fetch')     { assert_equal('foo', subject.fetch(0)) }
+    it('#find_index') { assert_equal(0, subject.find_index { true }) }
+    it('#first')     { assert_equal('foo', subject.first) }
+    it('#include?') { assert_equal(true, subject.include?('foo')) }
+    it('#index')   { assert_equal(0, subject.index('foo')) }
+    it('#join')     { assert_equal('a b', class_for_schema.new(['a', 'b']).join(' ')) }
+    it('#last')      { assert_equal(subject[2], subject.last) }
+    it('#pack')       { assert_equal(' ', class_for_schema.new([32]).pack('c')) }
+    it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.permutation(1).to_a) }
+    it('#product')    { assert_equal([], subject.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.
@@ -147,32 +148,43 @@ describe JSI::BaseArray do
     # 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 and #content must be called.
-    it('#rassoc')               { assert_equal(['q', 'r'], subject.instance.content.rassoc('r')) }
+    it('#rassoc')              { assert_equal(['q', 'r'], subject.instance.content.rassoc('r')) }
     it('#repeated_combination') { assert_equal([[]], subject.repeated_combination(0).to_a) }
     it('#repeated_permutation') { assert_equal([[]], subject.repeated_permutation(0).to_a) }
-    it('#reverse')              { assert_equal([subject[2], subject[1], 'foo'], subject.reverse) }
-    it('#reverse_each')         { assert_equal([subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
-    it('#rindex')               { assert_equal(0, subject.rindex('foo')) }
-    it('#rotate')               { assert_equal([subject[1], subject[2], 'foo'], subject.rotate) }
-    it('#sample')               { assert_equal('a', class_for_schema.new(['a']).sample) }
-    it('#shelljoin')            { assert_equal('a', class_for_schema.new(['a']).shelljoin) } if [].respond_to?(:shelljoin)
-    it('#shuffle')              { assert_equal(3, subject.shuffle.size) }
-    it('#slice')                { assert_equal(['foo'], subject.slice(0, 1)) }
-    it('#sort')                 { assert_equal(['a'], class_for_schema.new(['a']).sort) }
-    it('#take')                 { assert_equal(['foo'], subject.take(1)) }
-    it('#take_while')           { assert_equal([], subject.take_while { false }) }
-    it('#transpose')            { assert_equal([], class_for_schema.new([]).transpose) }
-    it('#uniq')                 { assert_equal(subject.to_a, subject.uniq) }
-    it('#values_at')            { assert_equal(['foo'], subject.values_at(0)) }
-    it('#zip')                  { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
+    it('#reverse')             { assert_equal([subject[2], subject[1], 'foo'], subject.reverse) }
+    it('#reverse_each')       { assert_equal([subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
+    it('#rindex')            { assert_equal(0, subject.rindex('foo')) }
+    it('#rotate')           { assert_equal([subject[1], subject[2], 'foo'], subject.rotate) }
+    it('#sample')          { assert_equal('a', class_for_schema.new(['a']).sample) }
+    it('#shelljoin')      { assert_equal('a', class_for_schema.new(['a']).shelljoin) } if [].respond_to?(:shelljoin)
+    it('#shuffle')       { assert_equal(3, subject.shuffle.size) }
+    it('#slice')        { assert_equal(['foo'], subject.slice(0, 1)) }
+    it('#sort')        { assert_equal(['a'], class_for_schema.new(['a']).sort) }
+    it('#take')       { assert_equal(['foo'], subject.take(1)) }
+    it('#take_while') { assert_equal([], subject.take_while { false }) }
+    it('#transpose') { assert_equal([], class_for_schema.new([]).transpose) }
+    it('#uniq')     { assert_equal(subject.to_a, subject.uniq) }
+    it('#values_at') { assert_equal(['foo'], subject.values_at(0)) }
+    it('#zip')      { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
+  end
+  describe 'with an instance that has to_ary but not other ary instance methods' do
+    let(:instance) { SortOfArray.new(['foo', {'lamp' => SortOfArray.new([3])}, SortOfArray.new(['q', 'r'])]) }
+    describe 'delegating instance methods to #to_ary' do
+      it('#each_index') { assert_equal([0, 1, 2], subject.each_index.to_a) }
+      it('#size')      { assert_equal(3, subject.size) }
+      it('#count')    { assert_equal(1, subject.count('foo')) }
+      it('#slice')   { assert_equal(['foo'], subject.slice(0, 1)) }
+      it('#[]')     { assert_equal(SortOfArray.new(['q', 'r']), subject[2].instance) }
+      it('#as_json') { assert_equal(['foo', {'lamp' => [3]}, ['q', 'r']], subject.as_json) }
+    end
   end
   describe 'modified copy methods' do
-    it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], [])), subject.reject { |e| e != 'foo' }) }
+    it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.reject { |e| e != 'foo' }) }
     it('#reject block var') do
       subj_a = subject.to_a
       subject.reject { |e| assert_equal(e, subj_a.shift) }
     end
-    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], [])), subject.select { |e| e == 'foo' }) }
+    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.select { |e| e == 'foo' }) }
     it('#select block var') do
       subj_a = subject.to_a
       subject.select { |e| assert_equal(e, subj_a.shift) }
@@ -183,7 +195,7 @@ describe JSI::BaseArray do
       let(:path) { ['1', 'c'] }
       it('#select') do
         selected = subject.select { |e| e == 'd' }
-        equivalent_node = JSI::JSON::ArrayNode.new([['b', 'q'], {'c' => ['d']}], path)
+        equivalent_node = JSI::JSON::ArrayNode.new([['b', 'q'], {'c' => ['d']}], pointer)
         equivalent = class_for_schema.new(equivalent_node)
         assert_equal(equivalent, selected)
       end

data/test/base_hash_test.rb

@@ -5,7 +5,8 @@ describe JSI::BaseHash do
     {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}
   end
   let(:path) { [] }
-  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:pointer) { JSI::JSON::Pointer.new(path) }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
   let(:schema_content) do
     {
       'type' => 'object',
@@ -137,43 +138,52 @@ describe JSI::BaseHash do
     it('#empty?')   { assert_equal(false, subject.empty?) }
     it('#has_key?') { assert_equal(true, subject.has_key?('bar')) }
     it('#include?') { assert_equal(false, subject.include?('q')) }
-    it('#key?')     { assert_equal(true, subject.key?('baz')) }
-    it('#keys')     { assert_equal(['foo', 'bar', 'baz'], subject.keys) }
-    it('#length')   { assert_equal(3, subject.length) }
-    it('#member?')  { assert_equal(false, subject.member?(0)) }
-    it('#size')     { assert_equal(3, subject.size) }
+    it('#key?')    { assert_equal(true, subject.key?('baz')) }
+    it('#keys')   { assert_equal(['foo', 'bar', 'baz'], subject.keys) }
+    it('#length') { assert_equal(3, subject.length) }
+    it('#member?') { assert_equal(false, subject.member?(0)) }
+    it('#size')   { assert_equal(3, subject.size) }
   end
   describe 'key + value methods' do
-    it('#<')            { assert_equal(true, subject < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true, 'x' => 'y'}) } if {}.respond_to?(:<)
-    it('#<=')           { assert_equal(true, subject <= subject) } if {}.respond_to?(:<=)
-    it('#>')            { assert_equal(true, subject > {}) } if {}.respond_to?(:>)
-    it('#>=')           { assert_equal(false, subject >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
-    it('#any?')         { assert_equal(false, subject.any? { |k, v| v == 3 }) }
-    it('#assoc')        { assert_equal(['foo', subject['foo']], subject.assoc('foo')) }
-    it('#dig')          { assert_equal(9, subject.dig('bar', 0)) } if {}.respond_to?(:dig)
-    it('#each_pair')    { assert_equal([['foo', subject['foo']], ['bar', subject['bar']], ['baz', true]], subject.each_pair.to_a) }
-    it('#each_value')   { assert_equal([subject['foo'], subject['bar'], true], subject.each_value.to_a) }
-    it('#fetch')        { assert_equal(true, subject.fetch('baz')) }
+    it('#<')  { assert_equal(true, subject < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true, 'x' => 'y'}) } if {}.respond_to?(:<)
+    it('#<=')  { assert_equal(true, subject <= subject) } if {}.respond_to?(:<=)
+    it('#>')    { assert_equal(true, subject > {}) } if {}.respond_to?(:>)
+    it('#>=')    { assert_equal(false, subject >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
+    it('#any?')   { assert_equal(false, subject.any? { |k, v| v == 3 }) }
+    it('#assoc')   { assert_equal(['foo', subject['foo']], subject.assoc('foo')) }
+    it('#dig')      { assert_equal(9, subject.dig('bar', 0)) } if {}.respond_to?(:dig)
+    it('#each_pair') { assert_equal([['foo', subject['foo']], ['bar', subject['bar']], ['baz', true]], subject.each_pair.to_a) }
+    it('#each_value') { assert_equal([subject['foo'], subject['bar'], true], subject.each_value.to_a) }
+    it('#fetch')       { assert_equal(true, subject.fetch('baz')) }
     it('#fetch_values') { assert_equal([true], subject.fetch_values('baz')) } if {}.respond_to?(:fetch_values)
-    it('#has_value?')   { assert_equal(true, subject.has_value?(true)) }
-    it('#invert')       { assert_equal({subject['foo'] => 'foo', subject['bar'] => 'bar', true => 'baz'}, subject.invert) }
-    it('#key')          { assert_equal('baz', subject.key(true)) }
-    it('#rassoc')       { assert_equal(['baz', true], subject.rassoc(true)) }
-    it('#to_h')         { assert_equal({'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true}, subject.to_h) }
-    it('#to_proc')      { assert_equal(true, subject.to_proc.call('baz')) } if {}.respond_to?(:to_proc)
+    it('#has_value?')  { assert_equal(true, subject.has_value?(true)) }
+    it('#invert')     { assert_equal({subject['foo'] => 'foo', subject['bar'] => 'bar', true => 'baz'}, subject.invert) }
+    it('#key')       { assert_equal('baz', subject.key(true)) }
+    it('#rassoc')   { assert_equal(['baz', true], subject.rassoc(true)) }
+    it('#to_h')    { assert_equal({'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => true}, subject.to_h) }
+    it('#to_proc') { assert_equal(true, subject.to_proc.call('baz')) } if {}.respond_to?(:to_proc)
     if {}.respond_to?(:transform_values)
       it('#transform_values') { assert_equal({'foo' => nil, 'bar' => nil, 'baz' => nil}, subject.transform_values { |_| nil }) }
     end
-    it('#value?')       { assert_equal(false, subject.value?('0')) }
-    it('#values')       { assert_equal([subject['foo'], subject['bar'], true], subject.values) }
-    it('#values_at')    { assert_equal([true], subject.values_at('baz')) }
+    it('#value?')  { assert_equal(false, subject.value?('0')) }
+    it('#values')   { assert_equal([subject['foo'], subject['bar'], true], subject.values) }
+    it('#values_at') { assert_equal([true], subject.values_at('baz')) }
+  end
+  describe 'with an instance that has to_hash but not other hash instance methods' do
+    let(:instance) { SortOfHash.new({'foo' => SortOfHash.new({'a' => 'b'})}) }
+    describe 'delegating instance methods to #to_hash' do
+      it('#each_key') { assert_equal(['foo'], subject.each_key.to_a) }
+      it('#each_pair') { assert_equal([['foo', subject['foo']]], subject.each_pair.to_a) }
+      it('#[]')       { assert_equal(SortOfHash.new({'a' => 'b'}), subject['foo'].instance) }
+      it('#as_json') { assert_equal({'foo' => {'a' => 'b'}}, subject.as_json) }
+    end
   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(subject, subject.merge({})) }
-    it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, [])), subject.reject { true }) }
-    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, [])), subject.select { false }) }
+    it('#merge') { assert_equal(subject, subject.merge({})) }
+    it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, pointer)), subject.reject { true }) }
+    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, pointer)), subject.select { false }) }
     describe '#select' do
       it 'yields properly too' do
         subject.select do |k, v|

data/test/base_test.rb

@@ -5,7 +5,8 @@ NamedSchemaInstance = JSI.class_for_schema({id: 'https://schemas.jsi.unth.net/te
 describe JSI::Base do
   let(:document) { {} }
   let(:path) { [] }
-  let(:instance) { JSI::JSON::Node.new_by_type(document, path) }
+  let(:pointer) { JSI::JSON::Pointer.new(path) }
+  let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
   let(:schema_content) { {} }
   let(:schema) { JSI::Schema.new(schema_content) }
   let(:subject) { JSI.class_for_schema(schema).new(instance) }
@@ -107,7 +108,7 @@ describe JSI::Base do
     describe 'nil' do
       let(:instance) { nil }
       it 'initializes with nil instance' do
-        assert_equal(JSI::JSON::Node.new_doc(nil), subject.instance)
+        assert_equal(nil, subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -115,7 +116,7 @@ describe JSI::Base do
     describe 'arbitrary instance' do
       let(:instance) { Object.new }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_doc(instance), subject.instance)
+        assert_equal(instance, subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -124,7 +125,7 @@ describe JSI::Base do
       let(:instance) { {'foo' => 'bar'} }
       let(:schema_content) { {'type' => 'object'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_doc({'foo' => 'bar'}), subject.instance)
+        assert_equal({'foo' => 'bar'}, subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(subject.respond_to?(:to_hash))
       end
@@ -133,7 +134,7 @@ describe JSI::Base do
       let(:document) { {'foo' => 'bar'} }
       let(:schema_content) { {'type' => 'object'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::HashNode.new({'foo' => 'bar'}, []), subject.instance)
+        assert_equal(JSI::JSON::HashNode.new({'foo' => 'bar'}, JSI::JSON::Pointer.new([])), subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(subject.respond_to?(:to_hash))
       end
@@ -142,7 +143,7 @@ describe JSI::Base do
       let(:instance) { ['foo'] }
       let(:schema_content) { {'type' => 'array'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_doc(['foo']), subject.instance)
+        assert_equal(['foo'], subject.instance)
         assert(subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -151,41 +152,52 @@ describe JSI::Base do
       let(:document) { ['foo'] }
       let(:schema_content) { {'type' => 'array'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::ArrayNode.new(['foo'], []), subject.instance)
+        assert_equal(JSI::JSON::ArrayNode.new(['foo'], JSI::JSON::Pointer.new([])), subject.instance)
         assert(subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
     end
-    describe 'another Base' do
+    describe 'another JSI::Base invalid' do
       let(:schema_content) { {'type' => 'object'} }
       let(:instance) { JSI.class_for_schema(schema).new({'foo' => 'bar'}) }
-      it 'initializes with a warning' do
-        assert_output(nil, /assigning instance to a Base instance is incorrect. received: #\{<JSI::SchemaClasses\["[^"]+#"\][^>]*>[^}]+}/) do
-          subject
-        end
-        assert_equal(JSI::JSON::HashNode.new({'foo' => 'bar'}, []), subject.instance)
+      it 'initializes with an error' do
+        err = assert_raises(TypeError) { subject }
+        assert_match(%r(\Aassigning another JSI::Base instance to JSI::SchemaClasses\[\".*#\"\] instance is incorrect. received: #\{<JSI::SchemaClasses\[.*\] Hash>\s*"foo" => "bar"\s*\}\z)m, err.message)
+      end
+    end
+    describe 'Schema invalid' do
+      let(:instance) { JSI::Schema.new({}) }
+      it 'initializes with an error' do
+        err = assert_raises(TypeError) { subject }
+        assert_match(%r(\Aassigning a schema to JSI::SchemaClasses\[\".*#\"\] instance is incorrect. received: #<JSI::Schema schema_id=.*>\z)m, err.message)
       end
     end
   end
-  describe '#parents, #parent' do
+  describe '#parent_jsis, #parent_jsi' do
     let(:schema_content) { {'properties' => {'foo' => {'properties' => {'bar' => {'properties' => {'baz' => {}}}}}}} }
     let(:document) { {'foo' => {'bar' => {'baz' => {}}}} }
-    describe 'no parents' do
+    describe 'no parent_jsis' do
       it 'has none' do
         assert_equal([], subject.parents)
+        assert_equal([], subject.parent_jsis.to_a)
         assert_equal(nil, subject.parent)
+        assert_equal(nil, subject.parent_jsi)
       end
     end
-    describe 'one parent' do
+    describe 'one parent_jsi' do
       it 'has one' do
         assert_equal([subject], subject.foo.parents)
+        assert_equal([subject], subject.foo.parent_jsis.to_a)
         assert_equal(subject, subject.foo.parent)
+        assert_equal(subject, subject.foo.parent_jsi)
       end
     end
-    describe 'more parents' do
+    describe 'more parent_jsis' do
       it 'has more' do
         assert_equal([subject.foo.bar, subject.foo, subject], subject.foo.bar.baz.parents)
+        assert_equal([subject.foo.bar, subject.foo, subject], subject.foo.bar.baz.parent_jsis.to_a)
         assert_equal(subject.foo.bar, subject.foo.bar.baz.parent)
+        assert_equal(subject.foo.bar, subject.foo.bar.baz.parent_jsi)
       end
     end
   end
@@ -197,6 +209,19 @@ describe JSI::Base do
     end
   end
   describe '#modified_copy' do
+    describe 'with an instance that does not have #modified_copy' do
+      let(:instance) { Object.new }
+      it 'yields the instance to modify' do
+        new_instance = Object.new
+        modified = subject.modified_copy do |o|
+          assert_equal(instance, o)
+          new_instance
+        end
+        assert_equal(new_instance, modified.instance)
+        assert_equal(instance, subject.instance)
+        refute_equal(instance, modified)
+      end
+    end
     describe 'with an instance that does have #modified_copy' do
       it 'yields the instance to modify' do
         modified = subject.modified_copy do |o|
@@ -282,7 +307,7 @@ describe JSI::Base do
         let(:instance) { nil }
         it 'errors' do
           err = assert_raises(NoMethodError) { subject.foo }
-          assert_match(%r(\Ainstance does not respond to \[\]; cannot call reader `foo' for: #<JSI::SchemaClasses\["[^"]+#"\].*nil.*>\z)m, err.message)
+          assert_match(%r(\Aschema instance of class .* does not respond to \[\]; cannot call reader 'foo'. instance is )m, err.message)
         end
       end
       describe 'properties with the same names as instance methods' do
@@ -317,7 +342,7 @@ describe JSI::Base do
         end
         it 'does not define readers' do
           assert_equal('bar', subject.foo)
-          assert_equal(JSI::SchemaClasses.module_for_schema(subject.schema), subject.method(:foo).owner)
+          assert_equal(JSI::SchemaClasses.module_for_schema(subject.schema, conflicting_modules: [JSI::Base, JSI::BaseArray, JSI::BaseHash]), subject.method(:foo).owner)
 
           assert_equal(JSI::Base, subject.method(:initialize).owner)
           assert_equal('hi', subject['initialize'])
@@ -356,7 +381,7 @@ describe JSI::Base do
         let(:instance) { nil }
         it 'errors' do
           err = assert_raises(NoMethodError) { subject.foo = 0 }
-          assert_match(%r(\Ainstance does not respond to \[\]=; cannot call writer `foo=' for: #<JSI::SchemaClasses\["[^"]+#"\].*nil.*>\z)m, err.message)
+          assert_match(%r(\Aschema instance of class .* does not respond to \[\]=; cannot call writer 'foo='. instance is )m, err.message)
         end
       end
     end
@@ -383,13 +408,15 @@ describe JSI::Base do
       assert_equal(['a'], JSI.class_for_schema({}).new(['a']).as_json(some_option: true))
     end
   end
-  describe 'overwrite schema instance with instance=' do
-    # this error message indicates an internal bug (hence Bug class), so there isn't an intended way to
-    # trigger it using JSI::Base properly. we use it improperly just to test that code path. this
-    # is definitely not defined behavior.
-    it 'errors' do
-      err = assert_raises(JSI::Bug) { subject.send(:instance=, {'foo' => 'bar'}) }
-      assert_match(%r(\Aoverwriting instance is not supported\z), err.message)
+  describe 'equality between different classes of JSI::Base subclasses' do
+    let(:subject_subclass) { Class.new(JSI.class_for_schema(schema)).new(instance) }
+
+    it 'considers a Base subclass (class_for_schema) and subsubclass to be equal with the same instance' do
+      assert_equal(subject.hash, subject_subclass.hash)
+      assert(subject == subject_subclass)
+      assert(subject_subclass == subject)
+      assert(subject.eql?(subject_subclass))
+      assert(subject_subclass.eql?(subject))
     end
   end
 end

data/test/jsi_json_arraynode_test.rb

@@ -18,8 +18,9 @@ document_types.each do |document_type|
     let(:document) { document_type[:document] }
     # by default the node is the whole document
     let(:path) { [] }
+    let(:pointer) { 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(document, pointer) }
 
     describe '#[] bad index' do
       it 'improves TypeError for Array subsript' do
@@ -107,24 +108,24 @@ 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' }) }
@@ -135,7 +136,7 @@ document_types.each do |document_type|
         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']}], pointer)
           assert_equal(equivalent, selected)
         end
       end