jsi 0.1.0 → 0.2.0

data/test/jsi_json_hashnode_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 '#each' do
       it 'iterates, one argument' do
@@ -80,43 +81,43 @@ document_types.each do |document_type|
       it('#empty?')   { assert_equal(false, node.empty?) }
       it('#has_key?') { assert_equal(true, node.has_key?('a')) }
       it('#include?') { assert_equal(false, node.include?('q')) }
-      it('#key?')     { assert_equal(true, node.key?('c')) }
-      it('#keys')     { assert_equal(['a', 'c'], node.keys) }
-      it('#length')   { assert_equal(2, node.length) }
-      it('#member?')  { assert_equal(false, node.member?(0)) }
-      it('#size')     { assert_equal(2, node.size) }
+      it('#key?')    { assert_equal(true, node.key?('c')) }
+      it('#keys')   { assert_equal(['a', 'c'], node.keys) }
+      it('#length') { assert_equal(2, node.length) }
+      it('#member?') { assert_equal(false, node.member?(0)) }
+      it('#size')   { assert_equal(2, node.size) }
     end
     describe 'key + value methods' do
-      it('#<')            { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
-      it('#<=')           { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
-      it('#>')            { assert_equal(true, node > {}) } if {}.respond_to?(:>)
-      it('#>=')           { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
-      it('#any?')         { assert_equal(false, node.any? { |k, v| v == 3 }) }
-      it('#assoc')        { assert_equal(['a', 'b'], node.assoc('a')) }
-      it('#dig')          { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
-      it('#each_pair')    { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
-      it('#each_value')   { assert_equal(['b', node['c']], node.each_value.to_a) }
-      it('#fetch')        { assert_equal('b', node.fetch('a')) }
+      it('#<')  { assert_equal(true, node < {'a' => 'b', 'c' => node['c'], 'x' => 'y'}) } if {}.respond_to?(:<)
+      it('#<=')  { assert_equal(true, node <= node) } if {}.respond_to?(:<=)
+      it('#>')    { assert_equal(true, node > {}) } if {}.respond_to?(:>)
+      it('#>=')    { assert_equal(false, node >= {'foo' => 'bar'}) } if {}.respond_to?(:>=)
+      it('#any?')   { assert_equal(false, node.any? { |k, v| v == 3 }) }
+      it('#assoc')   { assert_equal(['a', 'b'], node.assoc('a')) }
+      it('#dig')      { assert_equal('e', node.dig('c', 'd')) } if {}.respond_to?(:dig)
+      it('#each_pair') { assert_equal([['a', 'b'], ['c', node['c']]], node.each_pair.to_a) }
+      it('#each_value') { assert_equal(['b', node['c']], node.each_value.to_a) }
+      it('#fetch')       { assert_equal('b', node.fetch('a')) }
       it('#fetch_values') { assert_equal(['b'], node.fetch_values('a')) } if {}.respond_to?(:fetch_values)
-      it('#has_value?')   { assert_equal(true, node.has_value?('b')) }
-      it('#invert')       { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
-      it('#key')          { assert_equal('a', node.key('b')) }
-      it('#rassoc')       { assert_equal(['a', 'b'], node.rassoc('b')) }
-      it('#to_h')         { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
-      it('#to_proc')      { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
+      it('#has_value?')  { assert_equal(true, node.has_value?('b')) }
+      it('#invert')     { assert_equal({'b' => 'a', node['c'] => 'c'}, node.invert) }
+      it('#key')       { assert_equal('a', node.key('b')) }
+      it('#rassoc')   { assert_equal(['a', 'b'], node.rassoc('b')) }
+      it('#to_h')    { assert_equal({'a' => 'b', 'c' => node['c']}, node.to_h) }
+      it('#to_proc') { assert_equal('b', node.to_proc.call('a')) } if {}.respond_to?(:to_proc)
       if {}.respond_to?(:transform_values)
         it('#transform_values') { assert_equal({'a' => nil, 'c' => nil}, node.transform_values { |_| nil }) }
       end
-      it('#value?')       { assert_equal(false, node.value?('0')) }
-      it('#values')       { assert_equal(['b', node['c']], node.values) }
-      it('#values_at')    { assert_equal(['b'], node.values_at('a')) }
+      it('#value?')  { assert_equal(false, node.value?('0')) }
+      it('#values')   { assert_equal(['b', node['c']], node.values) }
+      it('#values_at') { assert_equal(['b'], node.values_at('a')) }
     end
     describe 'modified copy methods' do
       # I'm going to rely on the #merge test above to test the modified copy functionality and just do basic
       # tests of all the modified copy methods here
-      it('#merge')            { assert_equal(JSI::JSON::Node.new_doc(node.content.to_hash), node.merge({})) }
-      it('#reject')           { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
-      it('#select')           { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
+      it('#merge') { assert_equal(JSI::JSON::Node.new_doc(node.content), node.merge({})) }
+      it('#reject') { assert_equal(JSI::JSON::Node.new_doc({}), node.reject { true }) }
+      it('#select') { assert_equal(JSI::JSON::Node.new_doc({}), node.select { false }) }
       # Hash#compact only available as of ruby 2.5.0
       if {}.respond_to?(:compact)
         it('#compact') { assert_equal(JSI::JSON::Node.new_doc({"a" => "b", "c" => node.content.to_hash["c"]}), node.compact) }

data/test/jsi_json_node_test.rb

@@ -2,13 +2,22 @@ require_relative 'test_helper'
 
 describe JSI::JSON::Node do
   let(:path) { [] }
-  let(:node) { JSI::JSON::Node.new(document, path) }
+  let(:pointer) { JSI::JSON::Pointer.new(path) }
+  let(:node) { JSI::JSON::Node.new(document, pointer) }
 
   describe 'initialization' do
     it 'initializes' do
-      node = JSI::JSON::Node.new({'a' => 'b'}, [])
+      node = JSI::JSON::Node.new({'a' => 'b'}, pointer)
       assert_equal({'a' => 'b'}, node.document)
-      assert_equal([], node.path)
+      assert_equal(JSI::JSON::Pointer.new([]), node.pointer)
+    end
+    it 'initializes, pointer is not pointer' do
+      err = assert_raises(TypeError) { JSI::JSON::Node.new({'a' => 'b'}, []) }
+      assert_equal('pointer must be a JSI::JSON::Pointer. got: [] (Array)', err.message)
+    end
+    it 'initializes, document is another Node' do
+      err = assert_raises(TypeError) { JSI::JSON::Node.new(JSI::JSON::Node.new({'a' => 'b'}, pointer), pointer) }
+      assert_equal("document of a Node should not be another JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" {\"a\"=>\"b\"}>", err.message)
     end
   end
   describe 'initialization by .new_by_type' do
@@ -31,15 +40,20 @@ describe JSI::JSON::Node do
   end
   describe '#pointer' do
     it 'is a JSI::JSON::Pointer' do
-      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, []).pointer)
+      assert_instance_of(JSI::JSON::Pointer, JSI::JSON::Node.new({}, pointer).pointer)
+    end
+  end
+  describe '#path' do
+    it 'is an array of reference tokens' do
+      assert_equal(['a'], JSI::JSON::Node.new({}, JSI::JSON::Pointer.new(['a'])).path)
     end
   end
   describe '#content' do
     it 'returns the content at the root' do
-      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, []).content)
+      assert_equal({'a' => 'b'}, JSI::JSON::Node.new({'a' => 'b'}, pointer).content)
     end
     it 'returns the content from the deep' do
-      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], [1, 'x', 0, 'a', 0]).content)
+      assert_equal('b', JSI::JSON::Node.new([0, {'x' => [{'a' => ['b']}]}], JSI::JSON::Pointer.new([1, 'x', 0, 'a', 0])).content)
     end
   end
   describe '#deref' do
@@ -65,7 +79,7 @@ describe JSI::JSON::Node do
       it 'subscripts a node consisting of a $ref WITHOUT following' do
         subscripted = node['a']
         assert_equal({'$ref' => 'bar', 'foo' => 'bar'}, subscripted.content)
-        assert_equal(['a'], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
       end
       it 'looks for a node in #/schemas with the name of the $ref' do
         assert_equal({'description' => ['baz']}, node['a'].deref.content)
@@ -73,7 +87,7 @@ describe JSI::JSON::Node do
       it 'follows a $ref when subscripting past it' do
         subscripted = node['a']['description']
         assert_equal(['baz'], subscripted.content)
-        assert_equal(['schemas', 'bar', 'description'], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new(['schemas', 'bar', 'description']), subscripted.pointer)
       end
       it 'does not follow a $ref when subscripting a key that is present' do
         subscripted = node['a']['foo']
@@ -103,13 +117,20 @@ describe JSI::JSON::Node do
         subscripted = node[1]['x']
         assert_instance_of(JSI::JSON::ArrayNode, subscripted)
         assert_equal([{'a' => ['b']}], subscripted.content)
-        assert_equal([1, 'x'], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new([1, 'x']), subscripted.pointer)
       end
       it 'returns HashNode for a Hash' do
         subscripted = node[1]
         assert_instance_of(JSI::JSON::HashNode, subscripted)
         assert_equal({'x' => [{'a' => ['b']}]}, subscripted.content)
-        assert_equal([1], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new([1]), subscripted.pointer)
+      end
+      describe 'content does not respond to []' do
+        let(:document) { Object.new }
+        it 'cannot subscript' do
+          err = assert_raises(NoMethodError) { node['x'] }
+          assert_equal("undefined method `[]`\nsubscripting with \"x\" (String) from Object. content is: #{document.pretty_inspect.chomp}", err.message)
+        end
       end
     end
     describe 'with dereferencing' do
@@ -122,12 +143,12 @@ describe JSI::JSON::Node do
       it 'subscripts a node consisting of a $ref WITHOUT following' do
         subscripted = node['a']
         assert_equal({'$ref' => '#/foo', 'description' => 'hi'}, subscripted.content)
-        assert_equal(['a'], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new(['a']), subscripted.pointer)
       end
       it 'follows a $ref when subscripting past it' do
         subscripted = node['a']['bar']
         assert_equal(['baz'], subscripted.content)
-        assert_equal(['foo', 'bar'], subscripted.path)
+        assert_equal(JSI::JSON::Pointer.new(['foo', 'bar']), subscripted.pointer)
       end
       it 'does not follow a $ref when subscripting a key that is present' do
         subscripted = node['a']['description']
@@ -140,7 +161,7 @@ describe JSI::JSON::Node do
     it 'assigns' do
       node[0] = 'abcdefg'
       assert_equal(['abcdefg', {'x' => [{'a' => ['b']}]}], document)
-      string_node = JSI::JSON::Node.new(document, [0])
+      string_node = JSI::JSON::Node.new(document, JSI::JSON::Pointer.new([0]))
       string_node[0..2] = '0'
       assert_equal(['0defg', {'x' => [{'a' => ['b']}]}], document)
       node[0] = node[1]
@@ -161,19 +182,19 @@ describe JSI::JSON::Node do
     let(:document) { {'a' => {'b' => []}} }
     it 'finds a parent' do
       sub = node['a']['b']
-      assert_equal(['a', 'b'], sub.path)
+      assert_equal(JSI::JSON::Pointer.new(['a', 'b']), sub.pointer)
       parent = sub.parent_node
-      assert_equal(['a'], parent.path)
+      assert_equal(JSI::JSON::Pointer.new(['a']), parent.pointer)
       assert_equal({'b' => []}, parent.content)
       assert_equal(node['a'], parent)
       root_from_sub = sub.parent_node.parent_node
-      assert_equal([], root_from_sub.path)
+      assert_equal(JSI::JSON::Pointer.new([]), root_from_sub.pointer)
       assert_equal({'a' => {'b' => []}}, root_from_sub.content)
       assert_equal(node, root_from_sub)
       err = assert_raises(JSI::JSON::Pointer::ReferenceError) do
         root_from_sub.parent_node
       end
-      assert_match(/\Acannot access parent of root node: #\{<JSI::JSON::HashNode/, err.message)
+      assert_match(/\Acannot access parent of root pointer: #<JSI::JSON::Pointer/, err.message)
     end
   end
   describe '#pointer_path' do
@@ -234,11 +255,11 @@ describe JSI::JSON::Node do
       assert_equal(node.document_node[0].content.object_id, unmodified_dup.document_node[0].content.object_id)
     end
     it 'raises subscripting string from array' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, ['x']).modified_copy(&:dup) }
+      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, JSI::JSON::Pointer.new(['x'])).modified_copy(&:dup) }
       assert_match(%r(\Abad subscript "x" with remaining subpath: \[\] for array: \[.*\]\z)m, err.message)
     end
     it 'raises subscripting from invalid subpath' do
-      err = assert_raises(TypeError) { JSI::JSON::Node.new(document, [0, 0, 'what']).modified_copy(&:dup) }
+      err = assert_raises(TypeError) { JSI::JSON::Node.new(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
@@ -257,23 +278,24 @@ describe JSI::JSON::Node do
     end
   end
   describe '#fingerprint' do
+    let(:pointer) { JSI::JSON::Pointer.new([]) }
     it 'hashes consistently' do
-      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new([0], [])])
+      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => 'x'}[JSI::JSON::Node.new([0], pointer)])
     end
     it 'hashes consistently regardless of the Node being decorated as a subclass' do
-      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], [])])
-      assert_equal('x', {JSI::JSON::Node.new([0], []) => 'x'}[JSI::JSON::Node.new_doc([0])])
+      assert_equal('x', {JSI::JSON::Node.new_doc([0]) => 'x'}[JSI::JSON::Node.new([0], pointer)])
+      assert_equal('x', {JSI::JSON::Node.new([0], pointer) => 'x'}[JSI::JSON::Node.new_doc([0])])
     end
     it '==' do
-      assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], []))
-      assert_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_doc([0]))
+      assert_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new([0], pointer))
+      assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new([0], pointer))
+      assert_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new_doc([0]))
       assert_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc([0]))
     end
     it '!=' do
-      refute_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, []))
-      refute_equal(JSI::JSON::Node.new([0], []), JSI::JSON::Node.new_doc({}))
+      refute_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new({}, pointer))
+      refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new({}, pointer))
+      refute_equal(JSI::JSON::Node.new([0], pointer), JSI::JSON::Node.new_doc({}))
       refute_equal(JSI::JSON::Node.new_doc([0]), JSI::JSON::Node.new_doc({}))
       refute_equal({}, JSI::JSON::Node.new_doc({}))
       refute_equal(JSI::JSON::Node.new_doc({}), {})

data/test/jsi_json_pointer_test.rb

@@ -35,13 +35,13 @@ describe JSI::JSON::Pointer do
         "/m~0n" ,     8,
       ]
       evaluations.each_slice(2) do |pointer, value|
-        assert_equal(value, JSI::JSON::Pointer.new(:pointer, pointer).evaluate(document))
+        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.new(:pointer, "this does not begin with slash").evaluate(document)
+        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
@@ -80,19 +80,27 @@ describe JSI::JSON::Pointer do
         '#/m~0n',       8,
       ]
       evaluations.each_slice(2) do |fragment, value|
-        assert_equal(value, JSI::JSON::Pointer.new(:fragment, fragment).evaluate(document))
+        assert_equal(value, JSI::JSON::Pointer.from_fragment(fragment).evaluate(document))
       end
     end
 
     it 'raises for invalid syntax' do
       err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.new(:fragment, "this does not begin with #").evaluate(document)
+        JSI::JSON::Pointer.from_fragment("this does not begin with #").evaluate(document)
       end
       assert_equal("Invalid fragment syntax in \"this does not begin with #\": fragment must begin with #", err.message)
       err = assert_raises(JSI::JSON::Pointer::PointerSyntaxError) do
-        JSI::JSON::Pointer.new(:fragment, "#this does not begin with slash").evaluate(document)
+        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/schema_test.rb

@@ -17,7 +17,7 @@ describe JSI::Schema do
     it 'initializes from a JSI' do
       schema_jsi = SomeMetaschema.new('type' => 'object')
       schema = JSI::Schema.new(schema_jsi)
-      assert_equal(schema_jsi.instance, schema.schema_node)
+      assert_equal(schema_jsi, schema.schema_node)
       assert_equal(schema_jsi, schema.schema_object)
     end
     it 'cannot instantiate from some unknown object' do
@@ -167,27 +167,27 @@ describe JSI::Schema do
     let(:schema) { JSI::Schema.new({id: 'https://schemas.jsi.unth.net/test/validation', type: 'object'}) }
     describe 'without errors' do
       let(:instance) { {'foo' => 'bar'} }
-      it '#fully_validate' do
-        assert_equal([], schema.fully_validate(instance))
+      it '#fully_validate_instance' do
+        assert_equal([], schema.fully_validate_instance(instance))
       end
-      it '#validate' do
-        assert_equal(true, schema.validate(instance))
+      it '#validate_instance' do
+        assert_equal(true, schema.validate_instance(instance))
       end
-      it '#validate!' do
-        assert_equal(true, schema.validate!(instance))
+      it '#validate_instance!' do
+        assert_equal(true, schema.validate_instance!(instance))
       end
     end
     describe 'with errors' do
       let(:instance) { ['no'] }
-      it '#fully_validate' do
-        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate(instance))
+      it '#fully_validate_instance' do
+        assert_equal(["The property '#/' of type array did not match the following type: object in schema https://schemas.jsi.unth.net/test/validation"], schema.fully_validate_instance(instance))
       end
-      it '#validate' do
-        assert_equal(false, schema.validate(instance))
+      it '#validate_instance' do
+        assert_equal(false, schema.validate_instance(instance))
       end
-      it '#validate!' do
+      it '#validate_instance!' do
         err = assert_raises(JSON::Schema::ValidationError) do
-          schema.validate!(instance)
+          schema.validate_instance!(instance)
         end
         assert_equal("The property '#/' of type array did not match the following type: object", err.message)
       end

data/test/spreedly_openapi_test.rb

@@ -0,0 +1,8 @@
+require_relative 'test_helper'
+
+require 'spreedly_openapi'
+describe 'spreedly openapi' do
+  it 'instantiates the spreedly openapi doc' do
+    SpreedlyOpenAPI::Document.inspect
+  end
+end

data/test/test_helper.rb

@@ -2,8 +2,10 @@ require 'coveralls'
 if Coveralls.will_run?
   Coveralls.wear!
 end
-
 require 'simplecov'
+
+require 'byebug'
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'jsi'
 
@@ -16,8 +18,6 @@ require 'minitest/reporters'
 
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
-require 'byebug'
-
 class JSISpec < Minitest::Spec
   if ENV['JSI_TEST_ALPHA']
     # :nocov:

data/test/util_test.rb

@@ -6,23 +6,23 @@ describe JSI::Util do
       assert_equal({'a' => 'b', 'c' => 'd', nil => 3}, JSI.stringify_symbol_keys({a: 'b', 'c' => 'd', nil => 3}))
     end
     it 'stringifies HashNode keys' do
-      actual = JSI.stringify_symbol_keys(JSI::JSON::HashNode.new({a: 'b', 'c' => 'd', nil => 3}, []))
-      expected = JSI::JSON::HashNode.new({'a' => 'b', 'c' => 'd', nil => 3}, [])
+      actual = JSI.stringify_symbol_keys(JSI::JSON::Node.new_doc({a: 'b', 'c' => 'd', nil => 3}))
+      expected = JSI::JSON::Node.new_doc({'a' => 'b', 'c' => 'd', nil => 3})
       assert_equal(expected, actual)
     end
     it 'stringifies JSI hash keys' do
       klass = JSI.class_for_schema(type: 'object')
-      expected = JSI.stringify_symbol_keys(klass.new(JSI::JSON::HashNode.new({a: 'b', 'c' => 'd', nil => 3}, [])))
-      actual = klass.new(JSI::JSON::HashNode.new({'a' => 'b', 'c' => 'd', nil => 3}, []))
+      expected = JSI.stringify_symbol_keys(klass.new(JSI::JSON::Node.new_doc({a: 'b', 'c' => 'd', nil => 3})))
+      actual = klass.new(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => 'd', nil => 3}))
       assert_equal(expected, actual)
     end
     describe 'non-hash-like argument' do
       it 'errors' do
         err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(nil) }
         assert_equal("expected argument to be a hash; got NilClass: nil", err.message)
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::JSON::Node.new(3, [])) }
+        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI::JSON::Node.new_doc(3)) }
         assert_equal("expected argument to be a hash; got JSI::JSON::Node: #<JSI::JSON::Node fragment=\"#\" 3>", err.message)
-        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI.class_for_schema({}).new(JSI::JSON::Node.new(3, []))) }
+        err = assert_raises(ArgumentError) { JSI.stringify_symbol_keys(JSI.class_for_schema({}).new(JSI::JSON::Node.new_doc(3))) }
         assert_match(%r(\Aexpected argument to be a hash; got JSI::SchemaClasses\["[^"]+#"\]: #<JSI::SchemaClasses\["[^"]+#"\]\n  #<JSI::JSON::Node fragment="#" 3>\n>\z)m, err.message)
       end
     end
@@ -48,14 +48,14 @@ describe JSI::Util do
       assert_equal(expected, actual)
     end
     it 'deep stringifies HashNode keys' do
-      actual = JSI.deep_stringify_symbol_keys(JSI::JSON::HashNode.new({a: 'b', 'c' => {d: 0}, nil => 3}, []))
-      expected = JSI::JSON::HashNode.new({'a' => 'b', 'c' => {'d' => 0}, nil => 3}, [])
+      actual = JSI.deep_stringify_symbol_keys(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3}))
+      expected = JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3})
       assert_equal(expected, actual)
     end
     it 'deep stringifies JSI instance' do
       klass = JSI.class_for_schema(type: 'object')
-      actual = JSI.deep_stringify_symbol_keys(klass.new(JSI::JSON::HashNode.new({a: 'b', 'c' => {d: 0}, nil => 3}, [])))
-      expected = klass.new(JSI::JSON::HashNode.new({'a' => 'b', 'c' => {'d' => 0}, nil => 3}, []))
+      actual = JSI.deep_stringify_symbol_keys(klass.new(JSI::JSON::Node.new_doc({a: 'b', 'c' => {d: 0}, nil => 3})))
+      expected = klass.new(JSI::JSON::Node.new_doc({'a' => 'b', 'c' => {'d' => 0}, nil => 3}))
       assert_equal(expected, actual)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ethan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-19 00:00:00.000000000 Z
+date: 2019-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -83,7 +83,7 @@ dependencies:
 description: JSI represents json-schemas as ruby classes and json-schema instances
   as instances of those classes
 email:
-- ethan@unth
+- ethan@unth.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -103,7 +103,10 @@ files:
 - lib/jsi/json.rb
 - lib/jsi/json/node.rb
 - lib/jsi/json/pointer.rb
+- lib/jsi/pathed_node.rb
 - lib/jsi/schema.rb
+- lib/jsi/schema_classes.rb
+- lib/jsi/simple_wrap.rb
 - lib/jsi/typelike_modules.rb
 - lib/jsi/util.rb
 - lib/jsi/version.rb
@@ -118,6 +121,7 @@ files:
 - test/jsi_test.rb
 - test/jsi_typelike_as_json_test.rb
 - test/schema_test.rb
+- test/spreedly_openapi_test.rb
 - test/test_helper.rb
 - test/util_test.rb
 homepage: https://github.com/notEthan/jsi
@@ -156,5 +160,6 @@ test_files:
 - test/jsi_test.rb
 - test/jsi_typelike_as_json_test.rb
 - test/schema_test.rb
+- test/spreedly_openapi_test.rb
 - test/test_helper.rb
 - test/util_test.rb