jsi 0.2.1 → 0.3.0

data/lib/jsi/version.rb

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

data/lib/schemas/json-schema.org/draft-04/schema.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JSI
+  schema_id = 'http://json-schema.org/draft-04/schema'
+  schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
+  JSONSchemaOrgDraft04 = MetaschemaNode.new(schema_content).jsi_schema_module
+end

data/lib/schemas/json-schema.org/draft-06/schema.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JSI
+  schema_id = 'http://json-schema.org/draft/schema' # I don't know why this is not http://json-schema.org/draft-06/schema
+  schema_content = ::JSON.parse(File.read(::JSON::Validator.validators[schema_id].metaschema))
+  JSONSchemaOrgDraft06 = MetaschemaNode.new(schema_content).jsi_schema_module
+end

data/test/base_array_test.rb

@@ -1,25 +1,32 @@
 require_relative 'test_helper'
 
+base = {
+  'description' => 'named array schema',
+  'type' => 'array',
+  'items' => [
+    {'type' => 'string'},
+    {'type' => 'object'},
+    {'type' => 'array', 'items' => {}},
+  ],
+}
+NamedArrayInstance = JSI.class_for_schema(base)
+NamedIdArrayInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base))
+
 describe JSI::BaseArray do
-  let(:document) do
-    ['foo', {'lamp' => [3]}, ['q', 'r']]
-  end
-  let(:path) { [] }
-  let(:pointer) { JSI::JSON::Pointer.new(path) }
-  let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
+  let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
   let(:schema_content) do
     {
+      'description' => 'hash schema',
       'type' => 'array',
       'items' => [
         {'type' => 'string'},
-        {'type' => 'object', 'items' => {}},
-        {'type' => 'array'},
+        {'type' => 'object'},
+        {'type' => 'array', 'items' => {}},
       ],
     }
   end
   let(:schema) { JSI::Schema.new(schema_content) }
-  let(:class_for_schema) { JSI.class_for_schema(schema) }
-  let(:subject) { class_for_schema.new(instance) }
+  let(:subject) { schema.new_jsi(instance) }
 
   describe '#[] with a default that is a basic type' do
     let(:schema_content) do
@@ -29,21 +36,21 @@ describe JSI::BaseArray do
       }
     end
     describe 'default value' do
-      let(:document) { [1] }
+      let(:instance) { [1] }
       it 'returns the default value' do
         assert_equal('foo', subject[2])
       end
     end
     describe 'nondefault value (basic type)' do
-      let(:document) { ['who'] }
+      let(:instance) { ['who'] }
       it 'returns the nondefault value' do
         assert_equal('who', subject[0])
       end
     end
     describe 'nondefault value (nonbasic type)' do
-      let(:document) { [[2]] }
+      let(:instance) { [[2]] }
       it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), subject[0])
+        assert_is_a(schema.items.jsi_schema_module, subject[0])
         assert_equal([2], subject[0].as_json)
       end
     end
@@ -56,22 +63,22 @@ describe JSI::BaseArray do
       }
     end
     describe 'default value' do
-      let(:document) { [{'bar' => 3}] }
+      let(:instance) { [{'bar' => 3}] }
       it 'returns the default value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
+        assert_is_a(schema.items.jsi_schema_module, subject[1])
         assert_equal({'foo' => 2}, subject[1].as_json)
       end
     end
     describe 'nondefault value (basic type)' do
-      let(:document) { [true, 'who'] }
+      let(:instance) { [true, 'who'] }
       it 'returns the nondefault value' do
         assert_equal('who', subject[1])
       end
     end
     describe 'nondefault value (nonbasic type)' do
-      let(:document) { [true, [2]] }
+      let(:instance) { [true, [2]] }
       it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
+        assert_is_a(schema.items.jsi_schema_module, subject[1])
         assert_equal([2], subject[1].as_json)
       end
     end
@@ -83,63 +90,173 @@ describe JSI::BaseArray do
       subject[2] = {'y' => 'z'}
 
       assert_equal({'y' => 'z'}, subject[2].as_json)
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), orig_2)
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['items'][2]), subject[2])
+      assert_is_a(schema.items[2].jsi_schema_module, orig_2)
+      assert_is_a(schema.items[2].jsi_schema_module, subject[2])
     end
     it 'modifies the instance, visible to other references to the same instance' do
-      orig_instance = subject.instance
+      orig_instance = subject.jsi_instance
 
       subject[2] = {'y' => 'z'}
 
-      assert_equal(orig_instance, subject.instance)
-      assert_equal({'y' => 'z'}, orig_instance[2].as_json)
-      assert_equal({'y' => 'z'}, subject.instance[2].as_json)
-      assert_equal(orig_instance.class, subject.instance.class)
+      assert_equal(orig_instance, subject.jsi_instance)
+      assert_equal({'y' => 'z'}, orig_instance[2])
+      assert_equal({'y' => 'z'}, subject.jsi_instance[2])
+      assert_equal(orig_instance.class, subject.jsi_instance.class)
     end
     describe 'when the instance is not arraylike' do
       let(:instance) { nil }
       it 'errors' do
         err = assert_raises(NoMethodError) { subject[2] = 0 }
-        assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::X.*>\z), err.message)
+        assert_equal("cannot assign subcript (using token: 2) to instance: nil", err.message)
+      end
+    end
+    describe '#inspect' do
+      it 'inspects' do
+        assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print' do
+      it 'pretty_prints' do
+        assert_equal("#[<JSI> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect SortOfArray' do
+      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<JSI SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print SortOfArray' do
+      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
+      it 'pretty_prints' do
+        assert_equal("#[<JSI SortOfArray>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named' do
+      let(:subject) { NamedArrayInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("#[<NamedArrayInstance> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print named' do
+      let(:subject) { NamedArrayInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("#[<NamedArrayInstance>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named SortOfArray' do
+      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<NamedArrayInstance SortOfArray> \"foo\", \#{<JSI> \"lamp\" => [3]}, #[<JSI> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print named SortOfArray' do
+      let(:subject) { NamedArrayInstance.new(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<NamedArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI> \"lamp\" => [3]},\n  #[<JSI> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named with id' do
+      let(:subject) { NamedIdArrayInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("#[<NamedIdArrayInstance> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print named with id' do
+      let(:subject) { NamedIdArrayInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("#[<NamedIdArrayInstance>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named with id SortOfArray' do
+      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<NamedIdArrayInstance SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print named with id SortOfArray' do
+      let(:subject) { NamedIdArrayInstance.new(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<NamedIdArrayInstance SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/test/base/named_array_schema#/items/2)>\n    \"q\",\n    \"r\"\n  ],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect with id' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:subject) { schema.new_jsi(instance) }
+      it 'inspects' do
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print with id' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:subject) { schema.new_jsi(instance) }
+      it 'inspects' do
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#)>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n  #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect with id SortOfArray' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"], {\"four\"=>4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print with id SortOfArray' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'items' => [{}, {}, {}]} }
+      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
+      it 'inspects' do
+        assert_equal("#[<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/test/withid#/items/1)> \"lamp\" => [3]},\n  #[<JSI (https://schemas.jsi.unth.net/test/withid#/items/2)> \"q\", \"r\"],\n  {\"four\"=>4}\n]\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect Node' do
+      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
+      it 'inspects' do
+        assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\"> \"foo\", \#{<JSI JSI::JSON::HashNode fragment=\"#/1\"> \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]}, #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"], \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}]", subject.inspect)
+      end
+    end
+    describe '#pretty_print Node' do
+      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
+      it 'pretty_prints' do
+        assert_equal("#[<JSI JSI::JSON::ArrayNode fragment=\"#\">\n  \"foo\",\n  \#{<JSI JSI::JSON::HashNode fragment=\"#/1\">\n    \"lamp\" => #[<JSI::JSON::ArrayNode fragment=\"#/1/lamp\"> 3]\n  },\n  #[<JSI JSI::JSON::ArrayNode fragment=\"#/2\"> \"q\", \"r\"],\n  \#{<JSI::JSON::HashNode fragment=\"#/3\"> \"four\" => 4}\n]\n", subject.pretty_inspect)
       end
     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], subject.each_index.to_a) }
+    it('#each_index') { assert_equal([0, 1, 2, 3], 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('#length')   { assert_equal(4, subject.length) }
+    it('#size')    { assert_equal(4, subject.size) }
   end
   describe 'index + element methods' do
-    it('#|')  { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
+    it('#|')  { assert_equal(['foo', subject[1], subject[2], subject[3], 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([subject[1], subject[2], subject[3]], 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('#abbrev')    { assert_equal({'a' => 'a'}, schema.new_jsi(['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('#combination')  { assert_equal([['foo'], [subject[1]], [subject[2]], [subject[3]]], 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('#drop')      { assert_equal([subject[2], subject[3]], subject.drop(2)) }
+    it('#drop_while') { assert_equal([subject[1], subject[2], subject[3]], 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('#join')     { assert_equal('a b', schema.new_jsi(['a', 'b']).join(' ')) }
+    it('#last')      { assert_equal(subject[3], subject.last) }
+    it('#pack')       { assert_equal(' ', schema.new_jsi([32]).pack('c')) }
+    it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]], [subject[3]]], 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
@@ -147,25 +264,25 @@ describe JSI::BaseArray do
     # 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 and #content must be called.
-    it('#rassoc')              { assert_equal(['q', 'r'], subject.instance.content.rassoc('r')) }
+    # for this reason, rassoc is NOT defined on Arraylike and we call #jsi_instance to use it.
+    it('#rassoc')              { assert_equal(['q', 'r'], subject.jsi_instance.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('#reverse')             { assert_equal([subject[3], subject[2], subject[1], 'foo'], subject.reverse) }
+    it('#reverse_each')       { assert_equal([subject[3], 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('#rotate')           { assert_equal([subject[1], subject[2], subject[3], 'foo'], subject.rotate) }
+    it('#sample')          { assert_equal('a', schema.new_jsi(['a']).sample) }
+    it('#shelljoin')      { assert_equal('a', schema.new_jsi(['a']).shelljoin) } if [].respond_to?(:shelljoin)
+    it('#shuffle')       { assert_equal(4, subject.shuffle.size) }
     it('#slice')        { assert_equal(['foo'], subject.slice(0, 1)) }
-    it('#sort')        { assert_equal(['a'], class_for_schema.new(['a']).sort) }
+    it('#sort')        { assert_equal(['a'], schema.new_jsi(['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('#transpose') { assert_equal([], schema.new_jsi([]).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('#zip')      { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]], [subject[3], subject[3]]], 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'])]) }
@@ -174,30 +291,27 @@ describe JSI::BaseArray do
       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('#[]')     { assert_equal(SortOfArray.new(['q', 'r']), subject[2].jsi_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'], pointer)), subject.reject { |e| e != 'foo' }) }
+    it('#reject') { assert_equal(schema.new_jsi(['foo']), 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'], pointer)), subject.select { |e| e == 'foo' }) }
+    it('#select') { assert_equal(schema.new_jsi(['foo']), subject.select { |e| e == 'foo' }) }
     it('#select block var') do
       subj_a = subject.to_a
       subject.select { |e| assert_equal(e, subj_a.shift) }
     end
     it('#compact') { assert_equal(subject, subject.compact) }
     describe 'at a depth' do
-      let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
-      let(:path) { ['1', 'c'] }
       it('#select') do
-        selected = subject.select { |e| e == 'd' }
-        equivalent_node = JSI::JSON::ArrayNode.new([['b', 'q'], {'c' => ['d']}], pointer)
-        equivalent = class_for_schema.new(equivalent_node)
-        assert_equal(equivalent, selected)
+        expected = schema.new_jsi(['foo', {'lamp' => [3]}, ['r'], {'four' => 4}])[2]
+        actual = subject[2].select { |e| e == 'r' }
+        assert_equal(expected, actual)
       end
     end
   end

data/test/base_hash_test.rb

@@ -1,14 +1,21 @@
 require_relative 'test_helper'
 
+base = {
+  'description' => 'named hash schema',
+  'type' => 'object',
+  'properties' => {
+    'foo' => {'type' => 'object'},
+    'bar' => {},
+  },
+}
+NamedHashInstance = JSI.class_for_schema(base)
+NamedIdHashInstance = JSI.class_for_schema({'$id' => 'https://schemas.jsi.unth.net/test/base/named_hash_schema'}.merge(base))
+
 describe JSI::BaseHash do
-  let(:document) do
-    {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}
-  end
-  let(:path) { [] }
-  let(:pointer) { JSI::JSON::Pointer.new(path) }
-  let(:instance) { JSI::JSON::Node.new_by_type(document, pointer) }
+  let(:instance) { {'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]} }
   let(:schema_content) do
     {
+      'description' => 'hash schema',
       'type' => 'object',
       'properties' => {
         'foo' => {'type' => 'object'},
@@ -17,10 +24,9 @@ describe JSI::BaseHash do
     }
   end
   let(:schema) { JSI::Schema.new(schema_content) }
-  let(:class_for_schema) { JSI.class_for_schema(schema) }
-  let(:subject) { class_for_schema.new(instance) }
+  let(:subject) { schema.new_jsi(instance) }
 
-  describe '#[] with a default that is a basic type' do
+  describe '#[] with a schema default that is a basic type' do
     let(:schema_content) do
       {
         'type' => 'object',
@@ -30,26 +36,26 @@ describe JSI::BaseHash do
       }
     end
     describe 'default value' do
-      let(:document) { {'bar' => 3} }
+      let(:instance) { {'bar' => 3} }
       it 'returns the default value' do
         assert_equal('foo', subject.foo)
       end
     end
     describe 'nondefault value (basic type)' do
-      let(:document) { {'foo' => 'who'} }
+      let(:instance) { {'foo' => 'who'} }
       it 'returns the nondefault value' do
         assert_equal('who', subject.foo)
       end
     end
     describe 'nondefault value (nonbasic type)' do
-      let(:document) { {'foo' => [2]} }
+      let(:instance) { {'foo' => [2]} }
       it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
         assert_equal([2], subject.foo.as_json)
       end
     end
   end
-  describe '#[] with a default that is a nonbasic type' do
+  describe '#[] with a schema default that is a nonbasic type' do
     let(:schema_content) do
       {
         'type' => 'object',
@@ -59,26 +65,43 @@ describe JSI::BaseHash do
       }
     end
     describe 'default value' do
-      let(:document) { {'bar' => 3} }
+      let(:instance) { {'bar' => 3} }
       it 'returns the default value' do
-        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
         assert_equal({'foo' => 2}, subject.foo.as_json)
       end
     end
     describe 'nondefault value (basic type)' do
-      let(:document) { {'foo' => 'who'} }
+      let(:instance) { {'foo' => 'who'} }
       it 'returns the nondefault value' do
         assert_equal('who', subject.foo)
       end
     end
     describe 'nondefault value (nonbasic type)' do
-      let(:document) { {'foo' => [2]} }
+      let(:instance) { {'foo' => [2]} }
       it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['properties']['foo']), subject.foo)
+        assert_is_a(schema.properties['foo'].jsi_schema_module, subject.foo)
         assert_equal([2], subject.foo.as_json)
       end
     end
   end
+  describe '#[] with a hash default that is a nonbasic type' do
+    let(:schema_content) do
+      {
+        'type' => 'object',
+        'properties' => {
+          'foo' => {},
+        },
+      }
+    end
+    describe 'default value' do
+      let(:instance) { Hash.new({'foo' => 2}).merge({'bar' => 3}) }
+      it 'returns the default value' do
+        assert_is_a(Hash, subject.foo)
+        assert_equal({'foo' => 2}, subject.foo)
+      end
+    end
+  end
   describe 'hashlike []=' do
     it 'sets a property' do
       orig_foo = subject['foo']
@@ -86,8 +109,8 @@ describe JSI::BaseHash do
       subject['foo'] = {'y' => 'z'}
 
       assert_equal({'y' => 'z'}, subject['foo'].as_json)
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), orig_foo)
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
+      assert_is_a(schema.properties['foo'].jsi_schema_module, orig_foo)
+      assert_is_a(schema.properties['foo'].jsi_schema_module, subject['foo'])
     end
     it 'sets a property to a schema instance with a different schema' do
       assert(subject['foo'])
@@ -97,11 +120,11 @@ describe JSI::BaseHash do
       # the content of the subscripts' instances is the same but the subscripts' classes are different
       assert_equal([9], subject['foo'].as_json)
       assert_equal([9], subject['bar'].as_json)
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
-      assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['bar']), subject['bar'])
+      assert_is_a(schema.properties['foo'].jsi_schema_module, subject['foo'])
+      assert_is_a(schema.properties['bar'].jsi_schema_module, subject['bar'])
     end
     it 'sets a property to a schema instance with the same schema' do
-      other_subject = class_for_schema.new(JSI::JSON::Node.new_doc({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}))
+      other_subject = schema.new_jsi({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => [true]})
       # Given
       assert_equal(other_subject, subject)
 
@@ -115,20 +138,130 @@ describe JSI::BaseHash do
       refute_equal(other_subject['foo'].object_id, subject['foo'].object_id)
     end
     it 'modifies the instance, visible to other references to the same instance' do
-      orig_instance = subject.instance
+      orig_instance = subject.jsi_instance
 
       subject['foo'] = {'y' => 'z'}
 
-      assert_equal(orig_instance, subject.instance)
-      assert_equal({'y' => 'z'}, orig_instance['foo'].as_json)
-      assert_equal({'y' => 'z'}, subject.instance['foo'].as_json)
-      assert_equal(orig_instance.class, subject.instance.class)
+      assert_equal(orig_instance, subject.jsi_instance)
+      assert_equal({'y' => 'z'}, orig_instance['foo'])
+      assert_equal({'y' => 'z'}, subject.jsi_instance['foo'])
+      assert_equal(orig_instance.class, subject.jsi_instance.class)
     end
     describe 'when the instance is not hashlike' do
       let(:instance) { nil }
       it 'errors' do
         err = assert_raises(NoMethodError) { subject['foo'] = 0 }
-        assert_match(%r(\Aundefined method `\[\]=' for #<JSI::SchemaClasses::.*>\z), err.message)
+        assert_equal('cannot assign subcript (using token: "foo") to instance: nil', err.message)
+      end
+    end
+    describe '#inspect' do
+      it 'inspects' do
+        assert_equal("\#{<JSI> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print' do
+      it 'pretty_prints' do
+        assert_equal("\#{<JSI> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect SortOfHash' do
+      let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<JSI SortOfHash> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print SortOfHash' do
+      let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
+      it 'pretty_prints' do
+        assert_equal("\#{<JSI SortOfHash>\n  \"foo\" => \#{<JSI> \"x\" => \"y\"},\n  \"bar\" => #[<JSI> 9],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named' do
+      let(:subject) { NamedHashInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("\#{<NamedHashInstance> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print named' do
+      let(:subject) { NamedHashInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("\#{<NamedHashInstance>\n  \"foo\" => \#{<JSI> \"x\" => \"y\"},\n  \"bar\" => #[<JSI> 9],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named SortOfHash' do
+      let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<NamedHashInstance SortOfHash> \"foo\" => \#{<JSI> \"x\" => \"y\"}, \"bar\" => #[<JSI> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print named SortOfHash' do
+      let(:subject) { NamedHashInstance.new(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<NamedHashInstance SortOfHash>\n  \"foo\" => \#{<JSI> \"x\" => \"y\"},\n  \"bar\" => #[<JSI> 9],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named with id' do
+      let(:subject) { NamedIdHashInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("\#{<NamedIdHashInstance> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print named with id' do
+      let(:subject) { NamedIdHashInstance.new(instance) }
+      it 'inspects' do
+        assert_equal("\#{<NamedIdHashInstance>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect named SortOfHash with id' do
+      let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<NamedIdHashInstance SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print named with id SortOfHash' do
+      let(:subject) { NamedIdHashInstance.new(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<NamedIdHashInstance SortOfHash>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/base/named_hash_schema#/properties/bar)>\n    9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect with id' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:subject) { schema.new_jsi(instance) }
+      it 'inspects' do
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print with id' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:subject) { schema.new_jsi(instance) }
+      it 'inspects' do
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#)>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect with id SortOfHash' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash> \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)> \"x\" => \"y\"}, \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9], \"baz\" => [true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print with id SortOfHash' do
+      let(:schema_content) { {'$id' => 'https://schemas.jsi.unth.net/test/withid', 'properties' => {'foo' => {}, 'bar' => {}}} }
+      let(:subject) { schema.new_jsi(SortOfHash.new(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<JSI (https://schemas.jsi.unth.net/test/withid#) SortOfHash>\n  \"foo\" => \#{<JSI (https://schemas.jsi.unth.net/test/withid#/properties/foo)>\n    \"x\" => \"y\"\n  },\n  \"bar\" => #[<JSI (https://schemas.jsi.unth.net/test/withid#/properties/bar)> 9\n  ],\n  \"baz\" => [true]\n}\n", subject.pretty_inspect)
+      end
+    end
+    describe '#inspect Node' do
+      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
+      it 'inspects' do
+        assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\"> \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"}, \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9], \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]}", subject.inspect)
+      end
+    end
+    describe '#pretty_print Node' do
+      let(:subject) { schema.new_jsi(JSI::JSON::Node.new_doc(instance)) }
+      it 'pretty_prints' do
+        assert_equal("\#{<JSI JSI::JSON::HashNode fragment=\"#\">\n  \"foo\" => \#{<JSI JSI::JSON::HashNode fragment=\"#/foo\"> \"x\" => \"y\"},\n  \"bar\" => #[<JSI JSI::JSON::ArrayNode fragment=\"#/bar\"> 9],\n  \"baz\" => #[<JSI::JSON::ArrayNode fragment=\"#/baz\"> true]\n}\n", subject.pretty_inspect)
       end
     end
   end
@@ -145,36 +278,36 @@ describe JSI::BaseHash do
     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 < {'foo' => subject['foo'], 'bar' => subject['bar'], 'baz' => subject['baz'], '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('#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)
     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('#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('#[]')       { assert_equal(SortOfHash.new({'a' => 'b'}), subject['foo'].jsi_instance) }
       it('#as_json') { assert_equal({'foo' => {'a' => 'b'}}, subject.as_json) }
     end
   end
@@ -182,8 +315,8 @@ describe JSI::BaseHash 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({}, pointer)), subject.reject { true }) }
-    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, pointer)), subject.select { false }) }
+    it('#reject') { assert_equal(schema.new_jsi({}), subject.reject { true }) }
+    it('#select') { assert_equal(schema.new_jsi({}), subject.select { false }) }
     describe '#select' do
       it 'yields properly too' do
         subject.select do |k, v|