jsi 0.2.0 → 0.6.0

data/lib/jsi/json/pointer.rb

@@ -1,330 +0,0 @@
-require 'addressable/uri'
-
-module JSI
-  module JSON
-    # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
-    class Pointer
-      class Error < StandardError
-      end
-      class PointerSyntaxError < Error
-      end
-      class ReferenceError < Error
-      end
-
-      # instantiates a Pointer from any given reference tokens.
-      #
-      #     >> JSI::JSON::Pointer[]
-      #     => #<JSI::JSON::Pointer reference_tokens: []>
-      #     >> JSI::JSON::Pointer['a', 'b']
-      #     => #<JSI::JSON::Pointer reference_tokens: ["a", "b"]>
-      #     >> JSI::JSON::Pointer['a']['b']
-      #     => #<JSI::JSON::Pointer reference_tokens: ["a", "b"]>
-      #
-      # note in the last example that you can conveniently chain the class .[] method
-      # with the instance #[] method.
-      #
-      # @param *reference_tokens any number of reference tokens
-      # @return [JSI::JSON::Pointer]
-      def self.[](*reference_tokens)
-        new(reference_tokens)
-      end
-
-      # parse a URI-escaped fragment and instantiate as a JSI::JSON::Pointer
-      #
-      #     ptr = JSI::JSON::Pointer.from_fragment('#/foo/bar')
-      #     => #<JSI::JSON::Pointer fragment: #/foo/bar>
-      #     ptr.reference_tokens
-      #     => ["foo", "bar"]
-      #
-      # with URI escaping:
-      #
-      #     ptr = JSI::JSON::Pointer.from_fragment('#/foo%20bar')
-      #     => #<JSI::JSON::Pointer fragment: #/foo%20bar>
-      #     ptr.reference_tokens
-      #     => ["foo bar"]
-      #
-      # @param fragment [String] a fragment containing a pointer (starting with #)
-      # @return [JSI::JSON::Pointer]
-      def self.from_fragment(fragment)
-        fragment = Addressable::URI.unescape(fragment)
-        match = fragment.match(/\A#/)
-        if match
-          from_pointer(match.post_match, type: 'fragment')
-        else
-          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
-        end
-      end
-
-      # parse a pointer string and instantiate as a JSI::JSON::Pointer
-      #
-      #     ptr1 = JSI::JSON::Pointer.from_pointer('/foo')
-      #     => #<JSI::JSON::Pointer pointer: /foo>
-      #     ptr1.reference_tokens
-      #     => ["foo"]
-      #
-      #     ptr2 = JSI::JSON::Pointer.from_pointer('/foo~0bar/baz~1qux')
-      #     => #<JSI::JSON::Pointer pointer: /foo~0bar/baz~1qux>
-      #     ptr2.reference_tokens
-      #     => ["foo~bar", "baz/qux"]
-      #
-      # @param pointer_string [String] a pointer string
-      # @param type (for internal use) indicates the original representation of the pointer
-      # @return [JSI::JSON::Pointer]
-      def self.from_pointer(pointer_string, type: 'pointer')
-        tokens = pointer_string.split('/', -1).map! do |piece|
-          piece.gsub('~1', '/').gsub('~0', '~')
-        end
-        if tokens[0] == ''
-          new(tokens[1..-1], type: type)
-        elsif tokens.empty?
-          new(tokens, type: type)
-        else
-          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
-        end
-      end
-
-      # initializes a JSI::JSON::Pointer from the given reference_tokens.
-      #
-      # @param reference_tokens [Array<Object>]
-      # @param type [String, Symbol] one of 'pointer' or 'fragment'
-      def initialize(reference_tokens, type: nil)
-        unless reference_tokens.respond_to?(:to_ary)
-          raise(TypeError, "reference_tokens must be an array. got: #{reference_tokens.inspect}")
-        end
-        @reference_tokens = reference_tokens.to_ary.map(&:freeze).freeze
-        @type = type.is_a?(Symbol) ? type.to_s : type
-      end
-
-      attr_reader :reference_tokens
-
-      # takes a root json document and evaluates this pointer through the document, returning the value
-      # pointed to by this pointer.
-      #
-      # @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
-      # @return [Object] the content of the document pointed to by this pointer
-      # @raise [JSI::JSON::Pointer::ReferenceError] the document does not contain the path this pointer references
-      def evaluate(document)
-        res = reference_tokens.inject(document) do |value, token|
-          if value.respond_to?(:to_ary)
-            if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
-              token = token.to_i
-            end
-            unless token.is_a?(Integer)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
-            end
-            unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_ary)[token]
-          elsif value.respond_to?(:to_hash)
-            unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
-              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
-            end
-            (value.respond_to?(:[]) ? value : value.to_hash)[token]
-          else
-            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
-          end
-        end
-        res
-      end
-
-      # @return [String] the pointer string representation of this Pointer
-      def pointer
-        reference_tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
-      end
-
-      # @return [String] the fragment string representation of this Pointer
-      def fragment
-        '#' + Addressable::URI.escape(pointer)
-      end
-
-      # @return [Boolean] whether this pointer points to the root (has an empty array of reference_tokens)
-      def root?
-        reference_tokens.empty?
-      end
-
-      # @return [JSI::JSON::Pointer] pointer to the parent of where this pointer points
-      # @raise [JSI::JSON::Pointer::ReferenceError] if this pointer has no parent (points to the root)
-      def parent
-        if root?
-          raise(ReferenceError, "cannot access parent of root pointer: #{pretty_inspect.chomp}")
-        else
-          Pointer.new(reference_tokens[0...-1], type: @type)
-        end
-      end
-
-      # @return [Boolean] does this pointer contain the other_ptr - that is, is this pointer an
-      #   ancestor of other_ptr, a child pointer. contains? is inclusive; a pointer does contain itself.
-      def contains?(other_ptr)
-        self.reference_tokens == other_ptr.reference_tokens[0...self.reference_tokens.size]
-      end
-
-      # @return [JSI::JSON::Pointer] returns this pointer relative to the given ancestor_ptr
-      # @raise [JSI::JSON::Pointer::ReferenceError] if the given ancestor_ptr is not an ancestor of this pointer
-      def ptr_relative_to(ancestor_ptr)
-        unless ancestor_ptr.contains?(self)
-          raise(ReferenceError, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")
-        end
-        Pointer.new(reference_tokens[ancestor_ptr.reference_tokens.size..-1], type: @type)
-      end
-
-      # @param ptr [JSI::JSON::Pointer]
-      # @return [JSI::JSON::Pointer] a pointer with the reference tokens of this one plus the given ptr's.
-      def +(ptr)
-        unless ptr.is_a?(JSI::JSON::Pointer)
-          raise(TypeError, "ptr must be a JSI::JSON::Pointer; got: #{ptr.inspect}")
-        end
-        Pointer.new(reference_tokens + ptr.reference_tokens, type: @type)
-      end
-
-      # @param n [Integer]
-      # @return [JSI::JSON::Pointer] a Pointer consisting of the first n of our reference_tokens
-      # @raise [ArgumentError] if n is not between 0 and the size of our reference_tokens
-      def take(n)
-        unless (0..reference_tokens.size).include?(n)
-          raise(ArgumentError, "n not in range (0..#{reference_tokens.size}): #{n.inspect}")
-        end
-        Pointer.new(reference_tokens.take(n), type: @type)
-      end
-
-      # appends the given token to this Pointer's reference tokens and returns the result
-      #
-      # @param token [Object]
-      # @return [JSI::JSON::Pointer] pointer to a child node of this pointer with the given token
-      def [](token)
-        Pointer.new(reference_tokens + [token], type: @type)
-      end
-
-      # takes a document and a block. the block is yielded the content of the given document at this
-      # pointer's location. the block must result a modified copy of that content (and MUST NOT modify
-      # the object it is given). this modified copy of that content is incorporated into a modified copy
-      # of the given document, which is then returned. the structure and contents of the document outside
-      # the path pointed to by this pointer is not modified.
-      #
-      # @param document [Object] the document to apply this pointer to
-      # @yield [Object] the content this pointer applies to in the given document
-      #   the block must result in the new content which will be placed in the modified document copy.
-      # @return [Object] a copy of the given document, with the content this pointer applies to
-      #   replaced by the result of the block
-      def modified_document_copy(document, &block)
-        # we need to preserve the rest of the document, but modify the content at our path.
-        #
-        # this is actually a bit tricky. we can't modify the original document, obviously.
-        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
-        # or hash in the path above this node. this node's content is modified by the caller, and
-        # that is recursively merged up to the document root. the recursion is done with a
-        # y combinator, for no other reason than that was a fun way to implement it.
-        modified_document = JSI::Util.ycomb do |rec|
-          proc do |subdocument, subpath|
-            if subpath == []
-              Typelike.modified_copy(subdocument, &block)
-            else
-              car = subpath[0]
-              cdr = subpath[1..-1]
-              if subdocument.respond_to?(:to_hash)
-                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_hash)[car]
-                car_object = rec.call(subdocument_car, cdr)
-                if car_object.object_id == subdocument_car.object_id
-                  subdocument
-                else
-                  (subdocument.respond_to?(:merge) ? subdocument : subdocument.to_hash).merge({car => car_object})
-                end
-              elsif subdocument.respond_to?(:to_ary)
-                if car.is_a?(String) && car =~ /\A\d+\z/
-                  car = car.to_i
-                end
-                unless car.is_a?(Integer)
-                  raise(TypeError, "bad subscript #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect.chomp}")
-                end
-                subdocument_car = (subdocument.respond_to?(:[]) ? subdocument : subdocument.to_ary)[car]
-                car_object = rec.call(subdocument_car, cdr)
-                if car_object.object_id == subdocument_car.object_id
-                  subdocument
-                else
-                  (subdocument.respond_to?(:[]=) ? subdocument : subdocument.to_ary).dup.tap do |arr|
-                    arr[car] = car_object
-                  end
-                end
-              else
-                raise(TypeError, "bad subscript: #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for content: #{subdocument.pretty_inspect.chomp}")
-              end
-            end
-          end
-        end.call(document, reference_tokens)
-        modified_document
-      end
-
-      # if this Pointer points at a $ref node within the given document, #deref attempts
-      # to follow that $ref and return a Pointer to the referenced location. otherwise,
-      # this Pointer is returned.
-      #
-      # if the content this Pointer points to in the document is not hash-like, does not
-      # have a $ref property, its $ref cannot be found, or its $ref points outside the document,
-      # this pointer is returned.
-      #
-      # @param document [Object] the document this pointer applies to
-      # @yield [Pointer] if a block is given (optional), this will yield a deref'd pointer. if this
-      #   pointer does not point to a $ref object in the given document, the block is not called.
-      #   if we point to a $ref which cannot be followed (e.g. a $ref to an external
-      #   document, which is not yet supported), the block is not called.
-      # @return [Pointer] dereferenced pointer, or this pointer
-      def deref(document, &block)
-        block ||= Util::NOOP
-        content = evaluate(document)
-
-        if content.respond_to?(:to_hash)
-          ref = (content.respond_to?(:[]) ? content : content.to_hash)['$ref']
-        end
-        return self unless ref.is_a?(String)
-
-        if ref[/\A#/]
-          return Pointer.from_fragment(ref).tap(&block)
-        end
-
-        # HAX for how google does refs and ids
-        if document['schemas'].respond_to?(:to_hash)
-          if document['schemas'][ref]
-            return Pointer.new(['schemas', ref], type: 'hax').tap(&block)
-          end
-          document['schemas'].each do |k, schema|
-            if schema['id'] == ref
-              return Pointer.new(['schemas', k], type: 'hax').tap(&block)
-            end
-          end
-        end
-
-        #raise(NotImplementedError, "cannot dereference #{ref}") # TODO
-        return self
-      end
-
-      # @return [String] string representation of this Pointer
-      def inspect
-        "#<#{self.class.inspect} #{representation_s}>"
-      end
-
-      # @return [String] string representation of this Pointer
-      def to_s
-        inspect
-      end
-
-      # pointers are equal if the reference_tokens are equal, regardless of @type
-      def fingerprint
-        {class: JSI::JSON::Pointer, reference_tokens: reference_tokens}
-      end
-      include FingerprintHash
-
-      private
-
-      # @return [String] a representation of this pointer based on @type
-      def representation_s
-        if @type == 'fragment'
-          "fragment: #{fragment}"
-        elsif @type == 'pointer'
-          "pointer: #{pointer}"
-        else
-          "reference_tokens: #{reference_tokens.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/jsi/json-schema-fragments.rb

@@ -1,59 +0,0 @@
-require "json-schema"
-
-# apply the changes from https://github.com/ruby-json-schema/json-schema/pull/382 
-
-# json-schema/validator.rb
-
-module JSON
-  class Validator
-    def initialize(schema_data, data, opts={})
-      @options = @@default_opts.clone.merge(opts)
-      @errors = []
-
-      validator = self.class.validator_for_name(@options[:version])
-      @options[:version] = validator
-      @options[:schema_reader] ||= self.class.schema_reader
-
-      @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
-      @validation_options[:insert_defaults] = true if @options[:insert_defaults]
-      @validation_options[:strict] = true if @options[:strict] == true
-      @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
-
-      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
-      @original_data = data
-      @data = initialize_data(data)
-      @@mutex.synchronize { build_schemas(@base_schema) }
-
-      # If the :fragment option is set, try and validate against the fragment
-      if opts[:fragment]
-        @base_schema = schema_from_fragment(@base_schema, opts[:fragment])
-      end
-
-      # validate the schema, if requested
-      if @options[:validate_schema]
-        if @base_schema.schema["$schema"]
-          base_validator = self.class.validator_for_name(@base_schema.schema["$schema"])
-        end
-        metaschema = base_validator ? base_validator.metaschema : validator.metaschema
-        # Don't clear the cache during metaschema validation!
-        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
-      end
-    end
-
-    def schema_from_fragment(base_schema, fragment)
-      schema_uri = base_schema.uri
-
-      pointer = JSI::JSON::Pointer.from_fragment(fragment)
-
-      base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
-
-      if @options[:list]
-        base_schema.to_array_schema
-      elsif base_schema.is_a?(Hash)
-        JSON::Schema.new(base_schema, schema_uri, @options[:version])
-      else
-        base_schema
-      end
-    end
-  end
-end

data/lib/jsi/json.rb

@@ -1,8 +0,0 @@
-module JSI
-  module JSON
-    autoload :Node, 'jsi/json/node'
-    autoload :ArrayNode, 'jsi/json/node'
-    autoload :HashNode, 'jsi/json/node'
-    autoload :Pointer, 'jsi/json/pointer'
-  end
-end

data/test/base_array_test.rb

@@ -1,209 +0,0 @@
-require_relative 'test_helper'
-
-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(:schema_content) do
-    {
-      'type' => 'array',
-      'items' => [
-        {'type' => 'string'},
-        {'type' => 'object', 'items' => {}},
-        {'type' => 'array'},
-      ],
-    }
-  end
-  let(:schema) { JSI::Schema.new(schema_content) }
-  let(:class_for_schema) { JSI.class_for_schema(schema) }
-  let(:subject) { class_for_schema.new(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(:document) { [1] }
-      it 'returns the default value' do
-        assert_equal('foo', subject[2])
-      end
-    end
-    describe 'nondefault value (basic type)' do
-      let(:document) { ['who'] }
-      it 'returns the nondefault value' do
-        assert_equal('who', subject[0])
-      end
-    end
-    describe 'nondefault value (nonbasic type)' do
-      let(:document) { [[2]] }
-      it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), 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(:document) { [{'bar' => 3}] }
-      it 'returns the default value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), subject[1])
-        assert_equal({'foo' => 2}, subject[1].as_json)
-      end
-    end
-    describe 'nondefault value (basic type)' do
-      let(:document) { [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]] }
-      it 'returns the nondefault value' do
-        assert_instance_of(JSI.class_for_schema(schema['items']), 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_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])
-    end
-    it 'modifies the instance, visible to other references to the same instance' do
-      orig_instance = subject.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)
-    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)
-      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('#empty?')    { assert_equal(false, subject.empty?) }
-    it('#length')   { assert_equal(3, subject.length) }
-    it('#size')    { assert_equal(3, subject.size) }
-  end
-  describe 'index + element methods' do
-    it('#|')  { assert_equal(['foo', subject[1], subject[2], 0], subject | [0]) }
-    it('#&')   { assert_equal(['foo'], subject & ['foo']) }
-    it('#*')    { assert_equal(subject.to_a, subject * 1) }
-    it('#+')     { assert_equal(subject.to_a, subject + []) }
-    it('#-')      { assert_equal([subject[1], subject[2]], subject - ['foo']) }
-    it('#<=>')     { assert_equal(1, subject <=> []) }
-    it('#<=>')      { assert_equal(-1, [] <=> subject) }
-    require 'abbrev'
-    it('#abbrev')    { assert_equal({'a' => 'a'}, class_for_schema.new(['a']).abbrev) }
-    it('#assoc')      { assert_equal(['q', 'r'], subject.assoc('q')) }
-    it('#at')          { assert_equal('foo', subject.at(0)) }
-    it('#bsearch')      { assert_equal(nil, subject.bsearch { false }) }
-    it('#bsearch_index') { assert_equal(nil, subject.bsearch_index { false }) } if [].respond_to?(:bsearch_index)
-    it('#combination')  { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.combination(1).to_a) }
-    it('#count')       { assert_equal(1, subject.count('foo')) }
-    it('#cycle')      { assert_equal(subject.to_a, subject.cycle(1).to_a) }
-    it('#dig')       { assert_equal(3, subject.dig(1, 'lamp', 0)) } if [].respond_to?(:dig)
-    it('#drop')      { assert_equal([subject[2]], subject.drop(2)) }
-    it('#drop_while') { assert_equal([subject[1], subject[2]], subject.drop_while { |e| e == 'foo' }) }
-    it('#fetch')     { assert_equal('foo', subject.fetch(0)) }
-    it('#find_index') { assert_equal(0, subject.find_index { true }) }
-    it('#first')     { assert_equal('foo', subject.first) }
-    it('#include?') { assert_equal(true, subject.include?('foo')) }
-    it('#index')   { assert_equal(0, subject.index('foo')) }
-    it('#join')     { assert_equal('a b', class_for_schema.new(['a', 'b']).join(' ')) }
-    it('#last')      { assert_equal(subject[2], subject.last) }
-    it('#pack')       { assert_equal(' ', class_for_schema.new([32]).pack('c')) }
-    it('#permutation') { assert_equal([['foo'], [subject[1]], [subject[2]]], subject.permutation(1).to_a) }
-    it('#product')    { assert_equal([], subject.product([])) }
-    # due to differences in implementation between #assoc and #rassoc, the reason for which
-    # I cannot begin to fathom, assoc works but rassoc does not because rassoc has different
-    # type checking than assoc for the array(like) array elements.
-    # 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')) }
-    it('#repeated_combination') { assert_equal([[]], subject.repeated_combination(0).to_a) }
-    it('#repeated_permutation') { assert_equal([[]], subject.repeated_permutation(0).to_a) }
-    it('#reverse')             { assert_equal([subject[2], subject[1], 'foo'], subject.reverse) }
-    it('#reverse_each')       { assert_equal([subject[2], subject[1], 'foo'], subject.reverse_each.to_a) }
-    it('#rindex')            { assert_equal(0, subject.rindex('foo')) }
-    it('#rotate')           { assert_equal([subject[1], subject[2], 'foo'], subject.rotate) }
-    it('#sample')          { assert_equal('a', class_for_schema.new(['a']).sample) }
-    it('#shelljoin')      { assert_equal('a', class_for_schema.new(['a']).shelljoin) } if [].respond_to?(:shelljoin)
-    it('#shuffle')       { assert_equal(3, subject.shuffle.size) }
-    it('#slice')        { assert_equal(['foo'], subject.slice(0, 1)) }
-    it('#sort')        { assert_equal(['a'], class_for_schema.new(['a']).sort) }
-    it('#take')       { assert_equal(['foo'], subject.take(1)) }
-    it('#take_while') { assert_equal([], subject.take_while { false }) }
-    it('#transpose') { assert_equal([], class_for_schema.new([]).transpose) }
-    it('#uniq')     { assert_equal(subject.to_a, subject.uniq) }
-    it('#values_at') { assert_equal(['foo'], subject.values_at(0)) }
-    it('#zip')      { assert_equal([['foo', 'foo'], [subject[1], subject[1]], [subject[2], subject[2]]], subject.zip(subject)) }
-  end
-  describe 'with an instance that has to_ary but not other ary instance methods' do
-    let(:instance) { SortOfArray.new(['foo', {'lamp' => SortOfArray.new([3])}, SortOfArray.new(['q', 'r'])]) }
-    describe 'delegating instance methods to #to_ary' do
-      it('#each_index') { assert_equal([0, 1, 2], subject.each_index.to_a) }
-      it('#size')      { assert_equal(3, subject.size) }
-      it('#count')    { assert_equal(1, subject.count('foo')) }
-      it('#slice')   { assert_equal(['foo'], subject.slice(0, 1)) }
-      it('#[]')     { assert_equal(SortOfArray.new(['q', 'r']), subject[2].instance) }
-      it('#as_json') { assert_equal(['foo', {'lamp' => [3]}, ['q', 'r']], subject.as_json) }
-    end
-  end
-  describe 'modified copy methods' do
-    it('#reject') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.reject { |e| e != 'foo' }) }
-    it('#reject block var') do
-      subj_a = subject.to_a
-      subject.reject { |e| assert_equal(e, subj_a.shift) }
-    end
-    it('#select') { assert_equal(class_for_schema.new(JSI::JSON::ArrayNode.new(['foo'], pointer)), subject.select { |e| e == 'foo' }) }
-    it('#select block var') do
-      subj_a = subject.to_a
-      subject.select { |e| assert_equal(e, subj_a.shift) }
-    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)
-      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