jsi 0.4.0 → 0.7.0

data/lib/jsi/typelike_modules.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  # a module relating to objects that act like Hash or Array instances
-  module Typelike
-    # 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(object)
-      end
-    end
-
-    # 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.is_a?(JSI::PathedNode)
-        as_json(object.node_content, *opt)
-      elsif object.respond_to?(:to_hash)
-        (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.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)
-        object.to_s
-      elsif object.is_a?(Set)
-        as_json(object.to_a, *opt)
-      elsif object.respond_to?(:as_json)
-        as_json(object.as_json(*opt), *opt)
-      else
-        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
-      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.
-
-    # methods which do not need to access the value.
-    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size)
-    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at)
-    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
-    # these return a modified copy
-    safe_modified_copy_methods = %w(compact)
-    # select and reject will return a modified copy but need the yielded block variable value from #[]
-    safe_kv_block_modified_copy_methods = %w(select reject)
-    SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
-    safe_to_hash_methods = SAFE_METHODS - safe_modified_copy_methods - safe_kv_block_modified_copy_methods
-    safe_to_hash_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
-    end
-    safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        modified_copy do |object_to_modify|
-          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|
-        modified_copy do |object_to_modify|
-          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
-
-    # the same as Hash#update
-    # @param other [#to_hash] the other hash to update this hash from
-    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
-    #   is determined by calling the block with the key, its value in hsh and its value in other_hash.
-    # @return self, updated with other
-    # @raise [TypeError] when `other` does not respond to #to_hash
-    def update(other, &block)
-      unless other.respond_to?(:to_hash)
-        raise(TypeError, "cannot update with argument that does not respond to #to_hash: #{other.pretty_inspect.chomp}")
-      end
-      self_respondingto_key = self.respond_to?(:key?) ? self : to_hash
-      other.to_hash.each_pair do |key, value|
-        if block_given? && self_respondingto_key.key?(key)
-          value = yield(key, self[key], value)
-        end
-        self[key] = value
-      end
-      self
-    end
-
-    alias_method :merge!, :update
-
-    # the same as Hash#merge
-    # @param other [#to_hash] the other hash to merge into this
-    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
-    #   is determined by calling the block with the key, its value in hsh and its value in other_hash.
-    # @return duplicate of this hash with the other hash merged in
-    # @raise [TypeError] when `other` does not respond to #to_hash
-    def merge(other, &block)
-      dup.update(other, &block)
-    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_str = (respond_to?(:object_group_text) ? self.object_group_text : [self.class]).join(' ')
-      "\#{<#{object_group_str}>#{empty? ? '' : ' '}#{self.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}}"
-    end
-
-    alias_method :to_s, :inspect
-
-    # pretty-prints a representation this node to the given printer
-    # @return [void]
-    def pretty_print(q)
-      object_group_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
-      q.text "\#{<#{object_group_str}>"
-      q.group_sub {
-        q.nest(2) {
-          q.breakable(any? { true } ? ' ' : '')
-          q.seplist(self, nil, :each_pair) { |k, v|
-            q.group {
-              q.pp k
-              q.text ' => '
-              q.pp v
-            }
-          }
-        }
-      }
-      q.breakable ''
-      q.text '}'
-    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.
-
-    # methods which do not need to access the element.
-    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size)
-    # there are some ambiguous ones that are omitted, like #sort, #map / #collect.
-    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev assoc at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip)
-    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift)
-
-    # methods (well, method) that returns a modified copy and doesn't need any handling of block variable(s)
-    safe_modified_copy_methods = %w(compact)
-
-    # methods that return a modified copy and do need handling of block variables
-    safe_el_block_methods = %w(reject select)
-
-    SAFE_METHODS = SAFE_INDEX_ONLY_METHODS | SAFE_INDEX_ELEMENT_METHODS
-    safe_to_ary_methods = SAFE_METHODS - safe_modified_copy_methods - safe_el_block_methods
-    safe_to_ary_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
-    end
-    safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        modified_copy do |object_to_modify|
-          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
-    safe_el_block_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        modified_copy do |object_to_modify|
-          i = 0
-          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_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
-      "\#[<#{object_group_str}>#{empty? ? '' : ' '}#{self.map { |e| e.inspect }.join(', ')}]"
-    end
-
-    alias_method :to_s, :inspect
-
-    # pretty-prints a representation this node to the given printer
-    # @return [void]
-    def pretty_print(q)
-      object_group_str = (respond_to?(:object_group_text) ? object_group_text : [self.class]).join(' ')
-      q.text "\#[<#{object_group_str}>"
-      q.group_sub {
-        q.nest(2) {
-          q.breakable(any? { true } ? ' ' : '')
-          q.seplist(self, nil, :each) { |e|
-            q.pp e
-          }
-        }
-      }
-      q.breakable ''
-      q.text ']'
-    end
-  end
-end

data/test/base_array_test.rb

@@ -1,323 +0,0 @@
-require_relative 'test_helper'
-
-base = {
-  'description' => 'named array schema',
-  'type' => 'array',
-  'items' => [
-    {'type' => 'string'},
-    {'type' => 'object'},
-    {'type' => 'array', 'items' => {}},
-  ],
-}
-NamedArrayInstance = JSI::Schema.new(base).jsi_schema_class
-NamedIdArrayInstance = JSI::Schema.new({'$id' => 'https://schemas.jsi.unth.net/test/base/named_array_schema'}.merge(base)).jsi_schema_class
-
-describe 'JSI::Base array' do
-  let(:instance) { ['foo', {'lamp' => [3]}, ['q', 'r'], {'four' => 4}] }
-  let(:schema_content) do
-    {
-      'description' => 'hash schema',
-      'type' => 'array',
-      'items' => [
-        {'type' => 'string'},
-        {'type' => 'object'},
-        {'type' => 'array', 'items' => {}},
-      ],
-    }
-  end
-  let(:schema) { JSI::Schema.new(schema_content) }
-  let(:subject) { schema.new_jsi(instance) }
-
-  describe '#[] with a default that is a basic type' do
-    let(:schema_content) do
-      {
-        'type' => 'array',
-        'items' => {'default' => 'foo'},
-      }
-    end
-    describe 'default value' do
-      let(:instance) { [1] }
-      it 'returns the default value' do
-        assert_equal('foo', subject[2])
-      end
-    end
-    describe 'nondefault value (basic type)' do
-      let(:instance) { ['who'] }
-      it 'returns the nondefault value' do
-        assert_equal('who', subject[0])
-      end
-    end
-    describe 'nondefault value (nonbasic type)' do
-      let(:instance) { [[2]] }
-      it 'returns the nondefault value' do
-        assert_is_a(schema.items.jsi_schema_module, subject[0])
-        assert_equal([2], subject[0].as_json)
-      end
-    end
-  end
-  describe '#[] with a default that is a nonbasic type' do
-    let(:schema_content) do
-      {
-        'type' => 'array',
-        'items' => {'default' => {'foo' => 2}},
-      }
-    end
-    describe 'default value' do
-      let(:instance) { [{'bar' => 3}] }
-      it 'returns the default value' do
-        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(:instance) { [true, 'who'] }
-      it 'returns the nondefault value' do
-        assert_equal('who', subject[1])
-      end
-    end
-    describe 'nondefault value (nonbasic type)' do
-      let(:instance) { [true, [2]] }
-      it 'returns the nondefault value' do
-        assert_is_a(schema.items.jsi_schema_module, subject[1])
-        assert_equal([2], subject[1].as_json)
-      end
-    end
-  end
-  describe 'arraylike []=' do
-    it 'sets an index' do
-      orig_2 = subject[2]
-
-      subject[2] = {'y' => 'z'}
-
-      assert_equal({'y' => 'z'}, subject[2].as_json)
-      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.jsi_instance
-
-      subject[2] = {'y' => 'z'}
-
-      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_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/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(instance) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_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/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(instance) }
-      it 'pretty prints' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#)>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\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/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray> \"foo\", \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)> \"lamp\" => [3]}, #[<JSI (https://schemas.jsi.unth.net/base_array_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/base_array_test/withid', 'items' => [{}, {}, {}]} }
-      let(:subject) { schema.new_jsi(SortOfArray.new(instance)) }
-      it 'inspects' do
-        assert_equal("#[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#) SortOfArray>\n  \"foo\",\n  \#{<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/1)>\n    \"lamp\" => [3]\n  },\n  #[<JSI (https://schemas.jsi.unth.net/base_array_test/withid#/items/2)>\n    \"q\",\n    \"r\"\n  ],\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 #> \"foo\", \#{<JSI JSI::JSON::HashNode #/1> \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]}, #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"], \#{<JSI::JSON::HashNode #/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 #>\n  \"foo\",\n  \#{<JSI JSI::JSON::HashNode #/1>\n    \"lamp\" => #[<JSI::JSON::ArrayNode #/1/lamp> 3]\n  },\n  #[<JSI JSI::JSON::ArrayNode #/2> \"q\", \"r\"],\n  \#{<JSI::JSON::HashNode #/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, 3], subject.each_index.to_a) }
-    it('#empty?')    { assert_equal(false, subject.empty?) }
-    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], 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[3]], subject - ['foo']) }
-    it('#<=>')     { assert_equal(1, subject <=> []) }
-    it('#<=>')      { assert_equal(-1, [] <=> subject) }
-    require '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[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[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', 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
-    # 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 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[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], 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'], 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([], 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[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'])]) }
-    describe 'delegating instance methods to #to_ary' do
-      it('#each_index') { assert_equal([0, 1, 2], subject.each_index.to_a) }
-      it('#size')      { assert_equal(3, subject.size) }
-      it('#count')    { assert_equal(1, subject.count('foo')) }
-      it('#slice')   { assert_equal(['foo'], subject.slice(0, 1)) }
-      it('#[]')     { assert_equal(SortOfArray.new(['q', 'r']), subject[2].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(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(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
-      it('#select') do
-        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
-  JSI::Arraylike::DESTRUCTIVE_METHODS.each do |destructive_method_name|
-    it("does not respond to destructive method #{destructive_method_name}") do
-      assert(!subject.respond_to?(destructive_method_name))
-    end
-  end
-end