jsi 0.0.1 → 0.0.2

data/lib/jsi/typelike_modules.rb

@@ -1,24 +1,50 @@
 module JSI
+  # a module relating to objects that act like Hash or Array instances
   module Typelike
-    def self.modified_copy(other, &block)
-      if other.respond_to?(:modified_copy)
-        other.modified_copy(&block)
+    # yields the content of the given param `object`. for objects which have a
+    # #modified_copy method of their own (JSI::Base, JSI::JSON::Node) that
+    # method is invoked with the given block. otherwise the given object itself
+    # is yielded.
+    #
+    # the given block must result in a modified copy of its block parameter
+    # (not destructively modifying the yielded content).
+    #
+    # @yield [Object] the content of the given object. the block should result
+    #   in a (nondestructively) modified copy of this.
+    # @return [object.class] modified copy of the given object
+    def self.modified_copy(object, &block)
+      if object.respond_to?(:modified_copy)
+        object.modified_copy(&block)
       else
-        return yield(other)
+        return yield(object)
       end
     end
 
-    # I could require 'json/add/core' and use #as_json but I like this better.
+    # recursive method to express the given argument object in json-compatible
+    # types of Hash, Array, and basic types of String/boolean/numeric/nil. this
+    # will raise TypeError if an object is given that is not a type that seems
+    # to be expressable as json.
+    #
+    # similar effect could be achieved by requiring 'json/add/core' and using
+    # #as_json, but I don't much care for how it represents classes that are
+    # not naturally expressable in JSON, and prefer not to load its
+    # monkey-patching.
+    #
+    # @param object [Object] the object to be converted to jsonifiability
+    # @return [Array, Hash, String, Boolean, NilClass, Numeric] jsonifiable
+    #   expression of param object
+    # @raise [TypeError] when the object (or an object nested with a hash or
+    #   array of object) cannot be expressed as json
     def self.as_json(object, *opt)
       if object.respond_to?(:to_hash)
-        object.map do |k, v|
+        (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
           unless k.is_a?(Symbol) || k.respond_to?(:to_str)
             raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
           end
           {k.to_s => as_json(v, *opt)}
         end.inject({}, &:update)
       elsif object.respond_to?(:to_ary)
-        object.map { |e| as_json(e, *opt) }
+        (object.respond_to?(:map) ? object : object.to_ary).map { |e| as_json(e, *opt) }
       elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
         object
       elsif object.is_a?(Symbol)
@@ -32,6 +58,11 @@ module JSI
       end
     end
   end
+
+  # a module of methods for objects which behave like Hash but are not Hash.
+  #
+  # this module is intended to be internal to JSI. no guarantees or API promises
+  # are made for non-JSI classes including this module.
   module Hashlike
     # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
@@ -52,33 +83,40 @@ module JSI
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
         JSI::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a, &b)
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+          responsive_object.public_send(method_name, *a, &b)
         end
       end
     end
     safe_kv_block_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
         JSI::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a) do |k, _v|
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+          responsive_object.public_send(method_name, *a) do |k, _v|
             b.call(k, self[k])
           end
         end
       end
     end
 
+    # @return [String] basically the same #inspect as Hash, but has the
+    #   class name and, if responsive, self's #object_group_text
     def inspect
       object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#{<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
+      "\#{<#{self.class}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
     end
 
+    # @return [String] see #inspect
     def to_s
       inspect
     end
 
+    # pretty-prints a representation this node to the given printer
+    # @return [void]
     def pretty_print(q)
       q.instance_exec(self) do |obj|
         object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#{<#{obj.class.to_s}#{object_group_text}>"
+        text "\#{<#{obj.class}#{object_group_text}>"
         group_sub {
           nest(2) {
             breakable(obj.any? { true } ? ' ' : '')
@@ -96,6 +134,11 @@ module JSI
       end
     end
   end
+
+  # a module of methods for objects which behave like Array but are not Array.
+  #
+  # this module is intended to be internal to JSI. no guarantees or API promises
+  # are made for non-JSI classes including this module.
   module Arraylike
     # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
@@ -120,7 +163,8 @@ module JSI
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
         JSI::Typelike.modified_copy(self) do |object_to_modify|
-          object_to_modify.public_send(method_name, *a, &b)
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+          responsive_object.public_send(method_name, *a, &b)
         end
       end
     end
@@ -128,26 +172,32 @@ module JSI
       define_method(method_name) do |*a, &b|
         JSI::Typelike.modified_copy(self) do |object_to_modify|
           i = 0
-          object_to_modify.public_send(method_name, *a) do |_e|
+          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+          responsive_object.public_send(method_name, *a) do |_e|
             b.call(self[i]).tap { i += 1 }
           end
         end
       end
     end
 
+    # @return [String] basically the same #inspect as Array, but has the
+    #   class name and, if responsive, self's #object_group_text
     def inspect
       object_group_text = respond_to?(:object_group_text) ? ' ' + self.object_group_text : ''
-      "\#[<#{self.class.to_s}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
+      "\#[<#{self.class}#{object_group_text}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
     end
 
+    # @return [String] see #inspect
     def to_s
       inspect
     end
 
+    # pretty-prints a representation this node to the given printer
+    # @return [void]
     def pretty_print(q)
       q.instance_exec(self) do |obj|
         object_group_text = obj.respond_to?(:object_group_text) ? ' ' + obj.object_group_text : ''
-        text "\#[<#{obj.class.to_s}#{object_group_text}>"
+        text "\#[<#{obj.class}#{object_group_text}>"
         group_sub {
           nest(2) {
             breakable(obj.any? { true } ? ' ' : '')

data/lib/jsi/util.rb

@@ -1,5 +1,19 @@
 module JSI
   module Util
+    # 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
+    # ActiveSupport::HashWithIndifferentAccess#update)
+    #
+    # at the moment it is undefined whether the returned hash is the same
+    # instance as the `hash` param. if `hash` is already a hash  which contains
+    # no symbol keys, this method MAY return that same instance. use #dup on
+    # the return if you need to ensure it is not the same instance as the
+    # argument instance.
+    #
+    # @param hash [#to_hash] the hash from which to convert symbol keys to strings
+    # @return [same class as the param `hash`, or Hash if the former cannot be done] a
+    #    hash(-like) instance containing no symbol keys
     def stringify_symbol_keys(hash)
       unless hash.respond_to?(:to_hash)
         raise(ArgumentError, "expected argument to be a hash; got #{hash.class.inspect}: #{hash.pretty_inspect.chomp}")
@@ -23,7 +37,7 @@ module JSI
         JSI::Typelike.modified_copy(object) do |hash|
           changed = false
           out = {}
-          hash.each do |k, v|
+          (hash.respond_to?(:each) ? hash : hash.to_hash).each do |k, v|
             if k.is_a?(Symbol)
               changed = true
               k = k.to_s
@@ -39,7 +53,7 @@ module JSI
       elsif object.respond_to?(:to_ary)
         JSI::Typelike.modified_copy(object) do |ary|
           changed = false
-          out = ary.map do |e|
+          out = (ary.respond_to?(:each) ? ary : ary.to_ary).map do |e|
             out_e = deep_stringify_symbol_keys(e)
             changed = true if out_e.object_id != e.object_id
             out_e
@@ -50,6 +64,20 @@ module JSI
         object
       end
     end
+
+    # this is the Y-combinator, which allows anonymous recursive functions. for a simple example,
+    # to define a recursive function to return the length of an array:
+    #
+    #    length = ycomb do |len|
+    #      proc{|list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
+    #    end
+    #
+    # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
+    # and chapter 9 of the little schemer, available as the sample chapter at http://www.ccs.neu.edu/home/matthias/BTLS/
+    def ycomb
+      proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
+    end
+    module_function :ycomb
   end
   extend Util
 
@@ -86,18 +114,4 @@ module JSI
     end
   end
   extend Memoize
-
-  # this is the Y-combinator, which allows anonymous recursive functions. for a simple example, 
-  # to define a recursive function to return the length of an array:
-  #
-  #  length = ycomb do |len|
-  #    proc{|list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
-  #  end
-  #
-  # see https://secure.wikimedia.org/wikipedia/en/wiki/Fixed_point_combinator#Y_combinator
-  # and chapter 9 of the little schemer, available as the sample chapter at http://www.ccs.neu.edu/home/matthias/BTLS/
-  def ycomb
-    proc { |f| f.call(f) }.call(proc { |f| yield proc{|*x| f.call(f).call(*x) } })
-  end
-  module_function :ycomb
 end

data/lib/jsi/version.rb

@@ -1,3 +1,3 @@
 module JSI
-  VERSION = "0.0.1"
+  VERSION = "0.0.2".freeze
 end

data/test/base_array_test.rb

@@ -112,12 +112,12 @@ describe JSI::BaseArray do
     it('#zip')                  { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
   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'], [])), 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'], [])), subject.select { |e| e == 'foo' }) }
     it('#select block var') do
       subj_a = subject.to_a
       subject.select { |e| assert_equal(e, subj_a.shift) }

data/test/base_hash_test.rb

@@ -30,7 +30,7 @@ describe JSI::BaseHash do
       assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['foo']), subject['foo'])
     end
     it 'sets a property to a schema instance with a different schema' do
-      orig_foo = subject['foo']
+      assert(subject['foo'])
 
       subject['foo'] = subject['bar']
 
@@ -41,7 +41,7 @@ describe JSI::BaseHash do
       assert_instance_of(JSI.class_for_schema(schema.schema_node['properties']['bar']), 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_by_type({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}, []))
+      other_subject = class_for_schema.new(JSI::JSON::Node.new_doc({'foo' => {'x' => 'y'}, 'bar' => [9], 'baz' => true}))
       # Given
       assert_equal(other_subject, subject)
 
@@ -103,7 +103,7 @@ describe JSI::BaseHash do
     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}) }
+      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) }
@@ -112,9 +112,9 @@ describe JSI::BaseHash do
   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({}, [])), subject.reject { true }) }
+    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::HashNode.new({}, [])), subject.select { false }) }
     describe '#select' do
       it 'yields properly too' do
         subject.select do |k, v|
@@ -124,7 +124,7 @@ describe JSI::BaseHash do
     end
     # Hash#compact only available as of ruby 2.5.0
     if {}.respond_to?(:compact)
-      it('#compact')        { assert_equal(subject, subject.compact) }
+      it('#compact') { assert_equal(subject, subject.compact) }
     end
   end
   JSI::Hashlike::DESTRUCTIVE_METHODS.each do |destructive_method_name|

data/test/base_test.rb

@@ -51,12 +51,12 @@ describe JSI::Base do
   end
   describe 'module for schema .inspect' do
     it '.inspect' do
-      assert_match(%r(\A#<Module for Schema: .+#>\z), JSI.module_for_schema(schema).inspect)
+      assert_match(%r(\A#<Module for Schema: .+#>\z), JSI::SchemaClasses.module_for_schema(schema).inspect)
     end
   end
   describe 'module for schema .schema' do
     it '.schema' do
-      assert_equal(schema, JSI.module_for_schema(schema).schema)
+      assert_equal(schema, JSI::SchemaClasses.module_for_schema(schema).schema)
     end
   end
   describe 'SchemaClasses[]' do
@@ -81,20 +81,20 @@ describe JSI::Base do
       assert_equal(JSI.class_for_schema(schema), JSI.class_for_schema(JSI.class_for_schema({}).new(schema.schema_node)))
     end
   end
-  describe '.module_for_schema' do
+  describe 'JSI::SchemaClasses.module_for_schema' do
     it 'returns a module from a schema' do
-      module_for_schema = JSI.module_for_schema(schema)
+      module_for_schema = JSI::SchemaClasses.module_for_schema(schema)
       # same module every time
-      assert_equal(JSI.module_for_schema(schema), module_for_schema)
+      assert_equal(JSI::SchemaClasses.module_for_schema(schema), module_for_schema)
     end
     it 'returns a module from a hash' do
-      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(schema.schema_node.content))
+      assert_equal(JSI::SchemaClasses.module_for_schema(schema), JSI::SchemaClasses.module_for_schema(schema.schema_node.content))
     end
     it 'returns a module from a schema node' do
-      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(schema.schema_node))
+      assert_equal(JSI::SchemaClasses.module_for_schema(schema), JSI::SchemaClasses.module_for_schema(schema.schema_node))
     end
     it 'returns a module from a Base' do
-      assert_equal(JSI.module_for_schema(schema), JSI.module_for_schema(JSI.class_for_schema({}).new(schema.schema_node)))
+      assert_equal(JSI::SchemaClasses.module_for_schema(schema), JSI::SchemaClasses.module_for_schema(JSI.class_for_schema({}).new(schema.schema_node)))
     end
   end
   describe 'initialization' do
@@ -107,7 +107,7 @@ describe JSI::Base do
     describe 'nil' do
       let(:instance) { nil }
       it 'initializes with nil instance' do
-        assert_equal(JSI::JSON::Node.new_by_type(nil, []), subject.instance)
+        assert_equal(JSI::JSON::Node.new_doc(nil), subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -115,7 +115,7 @@ describe JSI::Base do
     describe 'arbitrary instance' do
       let(:instance) { Object.new }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_by_type(instance, []), subject.instance)
+        assert_equal(JSI::JSON::Node.new_doc(instance), subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -124,7 +124,7 @@ describe JSI::Base do
       let(:instance) { {'foo' => 'bar'} }
       let(:schema_content) { {'type' => 'object'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_by_type({'foo' => 'bar'}, []), subject.instance)
+        assert_equal(JSI::JSON::Node.new_doc({'foo' => 'bar'}), subject.instance)
         assert(!subject.respond_to?(:to_ary))
         assert(subject.respond_to?(:to_hash))
       end
@@ -142,7 +142,7 @@ describe JSI::Base do
       let(:instance) { ['foo'] }
       let(:schema_content) { {'type' => 'array'} }
       it 'initializes' do
-        assert_equal(JSI::JSON::Node.new_by_type(['foo'], []), subject.instance)
+        assert_equal(JSI::JSON::Node.new_doc(['foo']), subject.instance)
         assert(subject.respond_to?(:to_ary))
         assert(!subject.respond_to?(:to_hash))
       end
@@ -168,8 +168,8 @@ describe JSI::Base do
     end
   end
   describe '#parents, #parent' do
-    let(:schema_content) { {properties: {foo: {properties: {bar: {properties: {baz: {}}}}}}} }
-    let(:document) { {foo: {bar: {baz: {}}}} }
+    let(:schema_content) { {'properties' => {'foo' => {'properties' => {'bar' => {'properties' => {'baz' => {}}}}}}} }
+    let(:document) { {'foo' => {'bar' => {'baz' => {}}}} }
     describe 'no parents' do
       it 'has none' do
         assert_equal([], subject.parents)
@@ -317,7 +317,7 @@ describe JSI::Base do
         end
         it 'does not define readers' do
           assert_equal('bar', subject.foo)
-          assert_equal(JSI.module_for_schema(subject.schema), subject.method(:foo).owner)
+          assert_equal(JSI::SchemaClasses.module_for_schema(subject.schema), subject.method(:foo).owner)
 
           assert_equal(JSI::Base, subject.method(:initialize).owner)
           assert_equal('hi', subject['initialize'])
@@ -377,10 +377,10 @@ describe JSI::Base do
   end
   describe '#as_json' do
     it '#as_json' do
-      assert_equal({'a' => 'b'}, JSI.class_for_schema({}).new(JSI::JSON::Node.new_by_type({'a' => 'b'}, [])).as_json)
-      assert_equal({'a' => 'b'}, JSI.class_for_schema({'type' => 'object'}).new(JSI::JSON::Node.new_by_type({'a' => 'b'}, [])).as_json)
-      assert_equal(['a', 'b'], JSI.class_for_schema({'type' => 'array'}).new(JSI::JSON::Node.new_by_type(['a', 'b'], [])).as_json)
-      assert_equal(['a'], JSI::class_for_schema({}).new(['a']).as_json(some_option: true))
+      assert_equal({'a' => 'b'}, JSI.class_for_schema({}).new(JSI::JSON::Node.new_doc({'a' => 'b'})).as_json)
+      assert_equal({'a' => 'b'}, JSI.class_for_schema({'type' => 'object'}).new(JSI::JSON::Node.new_doc({'a' => 'b'})).as_json)
+      assert_equal(['a', 'b'], JSI.class_for_schema({'type' => 'array'}).new(JSI::JSON::Node.new_doc(['a', 'b'])).as_json)
+      assert_equal(['a'], JSI.class_for_schema({}).new(['a']).as_json(some_option: true))
     end
   end
   describe 'overwrite schema instance with instance=' do

data/test/jsi_json_arraynode_test.rb

@@ -1,133 +1,149 @@
 require_relative 'test_helper'
 
-describe JSI::JSON::ArrayNode do
-  # document of the node being tested
-  let(:document) { ['a', ['b', 'q'], {'c' => {'d' => 'e'}}] }
-  # by default the node is the whole document
-  let(:path) { [] }
-  # the node being tested
-  let(:node) { JSI::JSON::Node.new_by_type(document, path) }
+document_types = [
+  {
+    make_document: -> (d) { d },
+    document: ['a', ['b', 'q'], {'c' => {'d' => 'e'}}],
+    type_desc: 'Array',
+  },
+  {
+    make_document: -> (d) { SortOfArray.new(d) },
+    document: SortOfArray.new(['a', SortOfArray.new(['b', 'q']), SortOfHash.new({'c' => SortOfHash.new({'d' => 'e'})})]),
+    type_desc: 'sort of Array-like',
+  },
+]
+document_types.each do |document_type|
+  describe "JSI::JSON::ArrayNode with #{document_type[:type_desc]}" do
+    # document of the node being tested
+    let(:document) { document_type[:document] }
+    # by default the node is the whole document
+    let(:path) { [] }
+    # the node being tested
+    let(:node) { JSI::JSON::Node.new_by_type(document, path) }
 
-  describe '#[] bad index' do
-    it 'improves TypeError for Array subsript' do
-      err = assert_raises(TypeError) do
-        node[:x]
+    describe '#[] bad index' do
+      it 'improves TypeError for Array subsript' do
+        err = assert_raises(TypeError) do
+          node[:x]
+        end
+        assert_match(/^subscripting with :x \(Symbol\) from Array. content is: \[.*\]\z/m, err.message)
       end
-      assert_match(/^subscripting with :x \(Symbol\) from Array. self is: #\[<JSI::JSON::ArrayNode fragment="#">/, err.message)
     end
-  end
-  describe '#each' do
-    it 'iterates, one argument' do
-      out = []
-      node.each do |arg|
-        out << arg
+    describe '#each' do
+      it 'iterates, one argument' do
+        out = []
+        node.each do |arg|
+          out << arg
+        end
+        assert_instance_of(JSI::JSON::ArrayNode, node[1])
+        assert_instance_of(JSI::JSON::HashNode, node[2])
+        assert_equal(['a', node[1], node[2]], out)
+      end
+      it 'returns self' do
+        assert_equal(node.each { }.object_id, node.object_id)
+      end
+      it 'returns an enumerator when called with no block' do
+        enum = node.each
+        assert_instance_of(Enumerator, enum)
+        assert_equal(['a', node[1], node[2]], enum.to_a)
       end
-      assert_instance_of(JSI::JSON::ArrayNode, node[1])
-      assert_instance_of(JSI::JSON::HashNode, node[2])
-      assert_equal(['a', node[1], node[2]], out)
     end
-    it 'returns self' do
-      assert_equal(node.each { }.object_id, node.object_id)
+    describe '#to_ary' do
+      it 'returns a Array with Nodes in' do
+        assert_instance_of(Array, node.to_ary)
+        assert_equal(['a', node[1], node[2]], node.to_ary)
+      end
     end
-    it 'returns an enumerator when called with no block' do
-      enum = node.each
-      assert_instance_of(Enumerator, enum)
-      assert_equal(['a', node[1], node[2]], enum.to_a)
+    describe '#as_json' do
+      let(:document) { document_type[:make_document].call(['a', 'b']) }
+      it '#as_json' do
+        assert_equal(['a', 'b'], node.as_json)
+        assert_equal(['a', 'b'], node.as_json(some_option: false))
+      end
     end
-  end
-  describe '#to_ary' do
-    it 'returns a Array with Nodes in' do
-      assert_instance_of(Array, node.to_ary)
-      assert_equal(['a', node[1], node[2]], node.to_ary)
+    # these methods just delegate to Array so not going to test excessively
+    describe 'index only methods' do
+      it('#each_index') { assert_equal([0, 1, 2], node.each_index.to_a) }
+      it('#empty?')     { assert_equal(false, node.empty?) }
+      it('#length')     { assert_equal(3, node.length) }
+      it('#size')       { assert_equal(3, node.size) }
     end
-  end
-  describe '#as_json' do
-    let(:document) { ['a', 'b'] }
-    it '#as_json' do
-      assert_equal(['a', 'b'], node.as_json)
-      assert_equal(['a', 'b'], node.as_json(some_option: false))
+    describe 'index + element methods' do
+      it('#|')                    { assert_equal(['a', node[1], node[2], 0], node | [0]) }
+      it('#&')                    { assert_equal(['a'], node & ['a']) }
+      it('#*')                    { assert_equal(node.to_a, node * 1) }
+      it('#+')                    { assert_equal(node.to_a, node + []) }
+      it('#-')                    { assert_equal([node[1], node[2]], node - ['a']) }
+      it('#<=>')                  { assert_equal(1, node <=> []) }
+      it('#<=>')                  { assert_equal(-1, [] <=> node) }
+      require 'abbrev'
+      it('#abbrev')               { assert_equal({'a' => 'a'}, JSI::JSON::Node.new_doc(['a']).abbrev) }
+      it('#assoc')                { assert_equal(['b', 'q'], node.assoc('b')) }
+      it('#at')                   { assert_equal('a', node.at(0)) }
+      it('#bsearch')              { assert_equal(nil, node.bsearch { false }) }
+      it('#bsearch_index')        { assert_equal(nil, node.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
+      it('#combination')          { assert_equal([['a'], [node[1]], [node[2]]], node.combination(1).to_a) }
+      it('#count')                { assert_equal(1, node.count('a')) }
+      it('#cycle')                { assert_equal(node.to_a, node.cycle(1).to_a) }
+      it('#dig')                  { assert_equal('e', node.dig(2, 'c', 'd')) } if [].respond_to?(:dig)
+      it('#drop')                 { assert_equal([node[2]], node.drop(2)) }
+      it('#drop_while')           { assert_equal([node[1], node[2]], node.drop_while { |e| e == 'a' }) }
+      it('#fetch')                { assert_equal('a', node.fetch(0)) }
+      it('#find_index')           { assert_equal(0, node.find_index { true }) }
+      it('#first')                { assert_equal('a', node.first) }
+      it('#include?')             { assert_equal(true, node.include?('a')) }
+      it('#index')                { assert_equal(0, node.index('a')) }
+      it('#join')                 { assert_equal('a b', JSI::JSON::Node.new_doc(['a', 'b']).join(' ')) }
+      it('#last')                 { assert_equal(node[2], node.last) }
+      it('#pack')                 { assert_equal(' ', JSI::JSON::Node.new_doc([32]).pack('c')) }
+      it('#permutation')          { assert_equal([['a'], [node[1]], [node[2]]], node.permutation(1).to_a) }
+      it('#product')              { assert_equal([], node.product([])) }
+      # due to differences in implementation between #assoc and #rassoc, the reason for which
+      # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
+      # type checking than assoc for the array(like) array elements.
+      # compare:
+      # assoc:  https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
+      # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
+      # for this reason, rassoc is NOT defined on Arraylike. it's here with as_json.
+      #
+      # I've never even seen anybody use rassoc. of all the methods to put into the standard library ...
+      it('#rassoc')               { assert_equal(['b', 'q'], node.as_json.rassoc('q')) }
+      it('#repeated_combination') { assert_equal([[]], node.repeated_combination(0).to_a) }
+      it('#repeated_permutation') { assert_equal([[]], node.repeated_permutation(0).to_a) }
+      it('#reverse')              { assert_equal([node[2], node[1], 'a'], node.reverse) }
+      it('#reverse_each')         { assert_equal([node[2], node[1], 'a'], node.reverse_each.to_a) }
+      it('#rindex')               { assert_equal(0, node.rindex('a')) }
+      it('#rotate')               { assert_equal([node[1], node[2], 'a'], node.rotate) }
+      it('#sample')               { assert_equal('a', JSI::JSON::Node.new_doc(['a']).sample) }
+      it('#shelljoin')            { assert_equal('a', JSI::JSON::Node.new_doc(['a']).shelljoin) } if [].respond_to?(:shelljoin)
+      it('#shuffle')              { assert_equal(3, node.shuffle.size) }
+      it('#slice')                { assert_equal(['a'], node.slice(0, 1)) }
+      it('#sort')                 { assert_equal(['a'], JSI::JSON::Node.new_doc(['a']).sort) }
+      it('#take')                 { assert_equal(['a'], node.take(1)) }
+      it('#take_while')           { assert_equal([], node.take_while { false }) }
+      it('#transpose')            { assert_equal([], JSI::JSON::Node.new_doc([]).transpose) }
+      it('#uniq')                 { assert_equal(node.to_a, node.uniq) }
+      it('#values_at')            { assert_equal(['a'], node.values_at(0)) }
+      it('#zip')                  { assert_equal([['a', 'a'], [node[1], node[1]], [node[2], node[2]]], node.zip(node)) }
     end
-  end
-  # these methods just delegate to Array so not going to test excessively
-  describe 'index only methods' do
-    it('#each_index') { assert_equal([0, 1, 2], node.each_index.to_a) }
-    it('#empty?')     { assert_equal(false, node.empty?) }
-    it('#length')     { assert_equal(3, node.length) }
-    it('#size')       { assert_equal(3, node.size) }
-  end
-  describe 'index + element methods' do
-    it('#|')                    { assert_equal(['a', node[1], node[2], 0], node | [0]) }
-    it('#&')                    { assert_equal(['a'], node & ['a']) }
-    it('#*')                    { assert_equal(node.to_a, node * 1) }
-    it('#+')                    { assert_equal(node.to_a, node + []) }
-    it('#-')                    { assert_equal([node[1], node[2]], node - ['a']) }
-    it('#<=>')                  { assert_equal(1, node <=> []) }
-    it('#<=>')                  { assert_equal(-1, [] <=> node) }
-    require 'abbrev'
-    it('#abbrev')               { assert_equal({'a' => 'a'}, JSI::JSON::Node.new_by_type(['a'], []).abbrev) }
-    it('#assoc')                { assert_equal(['b', 'q'], node.assoc('b')) }
-    it('#at')                   { assert_equal('a', node.at(0)) }
-    it('#bsearch')              { assert_equal(nil, node.bsearch { false }) }
-    it('#bsearch_index')        { assert_equal(nil, node.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
-    it('#combination')          { assert_equal([['a'], [node[1]], [node[2]]], node.combination(1).to_a) }
-    it('#count')                { assert_equal(1, node.count('a')) }
-    it('#cycle')                { assert_equal(node.to_a, node.cycle(1).to_a) }
-    it('#dig')                  { assert_equal('e', node.dig(2, 'c', 'd')) } if [].respond_to?(:dig)
-    it('#drop')                 { assert_equal([node[2]], node.drop(2)) }
-    it('#drop_while')           { assert_equal([node[1], node[2]], node.drop_while { |e| e == 'a' }) }
-    it('#fetch')                { assert_equal('a', node.fetch(0)) }
-    it('#find_index')           { assert_equal(0, node.find_index { true }) }
-    it('#first')                { assert_equal('a', node.first) }
-    it('#include?')             { assert_equal(true, node.include?('a')) }
-    it('#index')                { assert_equal(0, node.index('a')) }
-    it('#join')                 { assert_equal('a b', JSI::JSON::Node.new_by_type(['a', 'b'], []).join(' ')) }
-    it('#last')                 { assert_equal(node[2], node.last) }
-    it('#pack')                 { assert_equal(' ', JSI::JSON::Node.new_by_type([32], []).pack('c')) }
-    it('#permutation')          { assert_equal([['a'], [node[1]], [node[2]]], node.permutation(1).to_a) }
-    it('#product')              { assert_equal([], node.product([])) }
-    # due to differences in implementation between #assoc and #rassoc, the reason for which
-    # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
-    # type checking than assoc for the array(like) array elements.
-    # compare:
-    # assoc:  https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3780-L3813
-    # rassoc: https://github.com/ruby/ruby/blob/v2_5_0/array.c#L3815-L3847
-    # for this reason, rassoc is NOT defined on Arraylike and #content must be called.
-    it('#rassoc')               { assert_equal(['b', 'q'], node.content.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_by_type(['a'], []).sample) }
-    it('#shelljoin')            { assert_equal('a', JSI::JSON::Node.new_by_type(['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_by_type(['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_by_type([], []).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_by_type(['a'], []), node.reject { |e| e != 'a' }) }
-    it('#select')  { assert_equal(JSI::JSON::Node.new_by_type(['a'], []), node.select { |e| e == 'a' }) }
-    it('#compact') { assert_equal(node, node.compact) }
-    describe 'at a depth' do
-      let(:document) { [['b', 'q'], {'c' => ['d', 'e']}] }
-      let(:path) { ['1', 'c'] }
-      it('#select') do
-        selected = node.select { |e| e == 'd' }
-        equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], ['1', 'c'])
-        assert_equal(equivalent, selected)
+    describe 'modified copy methods' do
+      it('#reject')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.reject { |e| e != 'a' }) }
+      it('#select')  { assert_equal(JSI::JSON::Node.new_doc(['a']), node.select { |e| e == 'a' }) }
+      it('#compact') { assert_equal(JSI::JSON::Node.new_doc(node.content.to_ary), node.compact) }
+      describe 'at a depth' do
+        let(:document) { document_type[:make_document].call([['b', 'q'], {'c' => ['d', 'e']}]) }
+        let(:path) { ['1', 'c'] }
+        it('#select') do
+          selected = node.select { |e| e == 'd' }
+          equivalent = JSI::JSON::Node.new_by_type([['b', 'q'], {'c' => ['d']}], ['1', 'c'])
+          assert_equal(equivalent, selected)
+        end
       end
     end
-  end
-  JSI::Arraylike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-    it("does not respond to destructive method #{destructive_method_name}") do
-      assert(!node.respond_to?(destructive_method_name))
+    JSI::Arraylike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
+      it("does not respond to destructive method #{destructive_method_name}") do
+        assert(!node.respond_to?(destructive_method_name))
+      end
     end
   end
 end