opal 0.3.41 → 0.3.42

data/spec/core/array/replace_spec.rb

@@ -1,31 +1,9 @@
-describe "Array#replace" do
-  it "replaces the elements with elements from other array" do
-    a = [1, 2, 3, 4, 5]
-    b = ['a', 'b', 'c']
-    a.replace(b).should equal(a)
-    a.should == b
-    a.should_not equal(b)
-
-    a.replace([4] * 10)
-    a.should == [4] * 10
-
-    a.replace([])
-    a.should == []
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/replace', __FILE__)
 
-  it "returns self" do
-    ary = [1, 2, 3]
-    other = [:a, :b, :c]
-    ary.replace(other).should equal(ary)
-  end
-
-  it "does not make self dependent to the original array" do
-    ary = [1, 2, 3]
-    other = [:a, :b, :c]
-    ary.replace(other)
-    ary.should == [:a, :b, :c]
-    ary << :d
-    ary.should == [:a, :b, :c, :d]
-    other.should == [:a, :b, :c]
+describe "Array#replace" do
+  pending do
+    it_behaves_like(:array_replace, :replace)
   end
-end
+end

data/spec/core/array/reverse_each_spec.rb

@@ -1,3 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/enumeratorize', __FILE__)
+
+# Modifying a collection while the contents are being iterated
+# gives undefined behavior. See
+# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/23633
+
 describe "Array#reverse_each" do
   before :each do
     ScratchPad.record []
@@ -12,4 +20,20 @@ describe "Array#reverse_each" do
     a = [:a, :b, :c]
     a.reverse_each { |x| }.should equal(a)
   end
-end
+
+  pending "yields only the top level element of an empty recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.reverse_each { |i| ScratchPad << i }
+    ScratchPad.recorded.should == [empty]
+  end
+
+  pending "yields only the top level element of a recursive array" do
+    array = ArraySpecs.recursive_array
+    array.reverse_each { |i| ScratchPad << i }
+    ScratchPad.recorded.should == [array, array, array, array, array, 3.0, 'two', 1]
+  end
+
+  pending do
+    it_behaves_like :enumeratorize, :reverse_each
+  end
+end

data/spec/core/array/reverse_spec.rb

@@ -1,6 +1,58 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#reverse" do
   it "returns a new array with the elements in reverse order" do
     [].reverse.should == []
     [1, 3, 5, 2].reverse.should == [2, 5, 3, 1]
   end
-end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.reverse.should == empty
+
+    array = ArraySpecs.recursive_array
+    array.reverse.should == [array, array, array, array, array, 3.0, 'two', 1]
+  end
+
+  ruby_version_is "" ... "1.9.3" do
+    pending "returns subclass instance on Array subclasses" do
+      ArraySpecs::MyArray[1, 2, 3].reverse.should be_kind_of(ArraySpecs::MyArray)
+    end
+  end
+
+  ruby_version_is "1.9.3" do
+    it "does not return subclass instance on Array subclasses" do
+      ArraySpecs::MyArray[1, 2, 3].reverse.should be_kind_of(Array)
+    end
+  end
+end
+
+describe "Array#reverse!" do
+  pending "reverses the elements in place" do
+    a = [6, 3, 4, 2, 1]
+    a.reverse!.should equal(a)
+    a.should == [1, 2, 4, 3, 6]
+    [].reverse!.should == []
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.reverse!.should == [empty]
+
+    array = ArraySpecs.recursive_array
+    array.reverse!.should == [array, array, array, array, array, 3.0, 'two', 1]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.reverse! }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.reverse! }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/core/array/rindex_spec.rb

@@ -1,6 +1,22 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+# Modifying a collection while the contents are being iterated
+# gives undefined behavior. See
+# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/23633
+
 describe "Array#rindex" do
-  it "returns the first index backwards from the end where element == to object" do
-    [2, 1, 3, 5, 1].rindex(3).should == 2
+  pending "returns the first index backwards from the end where element == to object" do
+    key = 3
+    uno = mock('one')
+    dos = mock('two')
+    tres = mock('three')
+    tres.should_receive(:==).any_number_of_times.and_return(false)
+    dos.should_receive(:==).any_number_of_times.and_return(true)
+    uno.should_not_receive(:==)
+    ary = [uno, dos, tres]
+
+    ary.rindex(key).should == 1
   end
 
   it "returns size-1 if last element == to object" do
@@ -15,7 +31,41 @@ describe "Array#rindex" do
     [1, 1, 3, 2, 1, 3].rindex(4).should == nil
   end
 
-  it "accepts a block instead of an argument" do
-    [4, 2, 1, 5, 1, 3].rindex { |x| x < 2 }.should == 4
+  pending "properly handles empty recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.rindex(empty).should == 0
+    empty.rindex(1).should be_nil
+  end
+
+  pending "properly handles recursive arrays" do
+    array = ArraySpecs.recursive_array
+    array.rindex(1).should == 0
+    array.rindex(array).should == 7
+  end
+
+  ruby_version_is "1.8.7" do
+    it "accepts a block instead of an argument" do
+      [4, 2, 1, 5, 1, 3].rindex { |x| x < 2 }.should == 4
+    end
+
+    it "ignore the block if there is an argument" do
+      [4, 2, 1, 5, 1, 3].rindex(5) { |x| x < 2 }.should == 3
+    end
+
+    it "rechecks the array size during iteration" do
+      ary = [4, 2, 1, 5, 1, 3]
+      seen = []
+      ary.rindex { |x| seen << x; ary.clear; false }
+
+      seen.should == [3]
+    end
+
+    describe "given no argument and no block" do
+      it "produces an Enumerator" do
+        enum = [4, 2, 1, 5, 1, 3].rindex
+        enum.should be_kind_of(enumerator_class)
+        enum.each { |x| x < 2 }.should == 4
+      end
+    end
   end
-end
+end

data/spec/core/array/select_spec.rb

@@ -1,13 +1,40 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/enumeratorize', __FILE__)
+require File.expand_path('../shared/keep_if', __FILE__)
+
 describe "Array#select" do
-  it "returns a new array of elements for which block is true" do
-    [1, 3, 4, 5, 6, 9].select { |i| i.odd? }.should == [1, 3, 5, 9]
-    [1, 2, 3, 4, 5, 6].select { true }.should == [1, 2, 3, 4, 5, 6]
-    [1, 2, 3, 4, 5, 6].select { false }.should == []
+  pending do
+    it_behaves_like :enumeratorize, :select
+  end
+
+  pending "returns a new array of elements for which block is true" do
+    [1, 3, 4, 5, 6, 9].select { |i| i % ((i + 1) / 2) == 0}.should == [1, 4, 6]
+  end
+
+  it "does not return subclass instance on Array subclasses" do
+    ArraySpecs::MyArray[1, 2, 3].select { true }.should be_kind_of(Array)
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.select { true }.should == empty
+    empty.select { false }.should == []
+
+    array = ArraySpecs.recursive_array
+    array.select { true }.should == [1, 'two', 3.0, array, array, array, array, array]
+    array.select { false }.should == []
   end
 end
 
-describe "Array#select!" do
-  it "returns nil if no changes were made in the array" do
-    [1, 2, 3].select! { true }.should be_nil
+ruby_version_is "1.9" do
+  describe "Array#select!" do
+    it "returns nil if no changes were made in the array" do
+      [1, 2, 3].select! { true }.should be_nil
+    end
+
+    pending do
+      it_behaves_like :keep_if, :select!
+    end
   end
-end
+end

data/spec/core/array/shared/enumeratorize.rb

@@ -0,0 +1,12 @@
+describe :enumeratorize, :shared => true do
+  ruby_version_is '' ... '1.8.7' do
+    it "raises a LocalJumpError if no block given" do
+      lambda{ [1,2].send(@method) }.should raise_error(LocalJumpError)
+    end
+  end
+  ruby_version_is '1.8.7' do
+    it "returns an Enumerator if no block given" do
+      [1,2].send(@method).should be_an_instance_of(enumerator_class)
+    end
+  end
+end

data/spec/core/array/shared/eql.rb

@@ -0,0 +1,95 @@
+describe :array_eql, :shared => true do
+  it "returns true if other is the same array" do
+    a = [1]
+    a.send(@method, a).should be_true
+  end
+
+  it "returns true if corresponding elements are #eql?" do
+    [].send(@method, []).should be_true
+    [1, 2, 3, 4].send(@method, [1, 2, 3, 4]).should be_true
+  end
+
+  it "returns false if other is shorter than self" do
+    [1, 2, 3, 4].send(@method, [1, 2, 3]).should be_false
+  end
+
+  it "returns false if other is longer than self" do
+    [1, 2, 3, 4].send(@method, [1, 2, 3, 4, 5]).should be_false
+  end
+
+  it "returns false immediately when sizes of the arrays differ" do
+    obj = mock('1')
+    obj.should_not_receive(@method)
+
+    []        .send(@method,    [obj]  ).should be_false
+    [obj]     .send(@method,    []     ).should be_false
+  end
+
+  ruby_bug "ruby-core #1448", "1.9.1" do
+    it "handles well recursive arrays" do
+      a = ArraySpecs.empty_recursive_array
+      a       .send(@method,    [a]    ).should be_true
+      a       .send(@method,    [[a]]  ).should be_true
+      [a]     .send(@method,    a      ).should be_true
+      [[a]]   .send(@method,    a      ).should be_true
+      # These may be surprising, but no difference can be
+      # found between these arrays, so they are ==.
+      # There is no "path" that will lead to a difference
+      # (contrary to other examples below)
+
+      a2 = ArraySpecs.empty_recursive_array
+      a       .send(@method,    a2     ).should be_true
+      a       .send(@method,    [a2]   ).should be_true
+      a       .send(@method,    [[a2]] ).should be_true
+      [a]     .send(@method,    a2     ).should be_true
+      [[a]]   .send(@method,    a2     ).should be_true
+
+      back = []
+      forth = [back]; back << forth;
+      back   .send(@method,  a  ).should be_true
+
+      x = []; x << x << x
+      x       .send(@method,    a                ).should be_false  # since x.size != a.size
+      x       .send(@method,    [a, a]           ).should be_false  # since x[0].size != [a, a][0].size
+      x       .send(@method,    [x, a]           ).should be_false  # since x[1].size != [x, a][1].size
+      [x, a]  .send(@method,    [a, x]           ).should be_false  # etc...
+      x       .send(@method,    [x, x]           ).should be_true
+      x       .send(@method,    [[x, x], [x, x]] ).should be_true
+
+      tree = [];
+      branch = []; branch << tree << tree; tree << branch
+      tree2 = [];
+      branch2 = []; branch2 << tree2 << tree2; tree2 << branch2
+      forest = [tree, branch, :bird, a]; forest << forest
+      forest2 = [tree2, branch2, :bird, a2]; forest2 << forest2
+
+      forest .send(@method,     forest2         ).should be_true
+      forest .send(@method,     [tree2, branch, :bird, a, forest2]).should be_true
+
+      diffforest = [branch2, tree2, :bird, a2]; diffforest << forest2
+      forest .send(@method,     diffforest      ).should be_false # since forest[0].size == 1 != 3 == diffforest[0]
+      forest .send(@method,     [nil]           ).should be_false
+      forest .send(@method,     [forest]        ).should be_false
+    end
+  end
+
+  it "does not call #to_ary on its argument" do
+    obj = mock('to_ary')
+    obj.should_not_receive(:to_ary)
+
+    [1, 2, 3].send(@method, obj).should be_false
+  end
+
+  it "does not call #to_ary on Array subclasses" do
+    ary = ArraySpecs::ToAryArray[5, 6, 7]
+    ary.should_not_receive(:to_ary)
+    [5, 6, 7].send(@method, ary).should be_true
+  end
+
+  it "ignores array class differences" do
+    ArraySpecs::MyArray[1, 2, 3].send(@method, [1, 2, 3]).should be_true
+    ArraySpecs::MyArray[1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_true
+    [1, 2, 3].send(@method, ArraySpecs::MyArray[1, 2, 3]).should be_true
+  end
+end
+

data/spec/core/array/shared/index.rb

@@ -0,0 +1,37 @@
+describe :array_index, :shared => true do
+  it "returns the index of the first element == to object" do
+    x = mock('3')
+    def x.==(obj) 3 == obj; end
+
+    [2, x, 3, 1, 3, 1].send(@method, 3).should == 1
+    [2, 3.0, 3, x, 1, 3, 1].send(@method, x).should == 1
+  end
+
+  it "returns 0 if first element == to object" do
+    [2, 1, 3, 2, 5].send(@method, 2).should == 0
+  end
+
+  it "returns size-1 if only last element == to object" do
+    [2, 1, 3, 1, 5].send(@method, 5).should == 4
+  end
+
+  it "returns nil if no element == to object" do
+    [2, 1, 1, 1, 1].send(@method, 3).should == nil
+  end
+
+  ruby_version_is "1.8.7" do
+    it "accepts a block instead of an argument" do
+      [4, 2, 1, 5, 1, 3].send(@method) {|x| x < 2}.should == 2
+    end
+
+    it "ignore the block if there is an argument" do
+      [4, 2, 1, 5, 1, 3].send(@method, 5) {|x| x < 2}.should == 3
+    end
+
+    describe "given no argument and no block" do
+      it "produces an Enumerator" do
+        [].send(@method).should be_kind_of(enumerator_class)
+      end
+    end
+  end
+end

data/spec/core/array/shared/inspect.rb

@@ -0,0 +1,3 @@
+describe :array_inspect, :shared => true do
+
+end

data/spec/core/array/shared/join.rb

@@ -0,0 +1,7 @@
+describe :array_join_with_default_separator, :shared => true do
+
+end
+
+describe :array_join_with_string_separator, :shared => true do
+
+end

data/spec/core/array/shift_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#shift" do
   it "removes and returns the first element" do
     a = [5, 1, 1, 5, 4]
@@ -13,39 +16,145 @@ describe "Array#shift" do
     a.should == []
   end
 
-  it "returns nil whent the array is empty" do
+  it "returns nil when the array is empty" do
     [].shift.should == nil
   end
 
-  describe "passed a number n as an argument" do
-    it "removes and returns an array with the first n element of the array" do
-      a = [1, 2, 3, 4, 5, 6]
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.shift.should == []
+    empty.should == []
 
-      a.shift(0).should == []
-      a.should == [1, 2, 3, 4, 5, 6]
+    array = ArraySpecs.recursive_array
+    array.shift.should == 1
+    array[0..2].should == ['two', 3.0, array]
+  end
 
-      a.shift(1).should == [1]
-      a.should == [2, 3, 4, 5, 6]
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.shift }.should raise_error(TypeError)
+    end
+    it "raises a TypeError on an empty frozen array" do
+      lambda { ArraySpecs.empty_frozen_array.shift }.should raise_error(TypeError)
+    end
+  end
 
-      a.shift(2).should == [2, 3]
-      a.should == [4, 5, 6]
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.shift }.should raise_error(RuntimeError)
+    end
+    it "raises a RuntimeError on an empty frozen array" do
+      lambda { ArraySpecs.empty_frozen_array.shift }.should raise_error(RuntimeError)
+    end
+  end
 
-      a.shift(3).should == [4, 5, 6]
-      a.should == []
+  ruby_version_is '' ... '1.8.7' do
+    it "raises an ArgumentError if passed an argument" do
+      lambda{ [1, 2].shift(1) }.should raise_error(ArgumentError)
     end
+  end
 
-    it "does not corrupt the array when shift without arguments is followed by shift with an argument" do
-      a = [1, 2, 3, 4, 5]
+  describe "passed a number n as an argument" do
+    ruby_version_is '1.8.7' do
+      it "removes and returns an array with the first n element of the array" do
+        a = [1, 2, 3, 4, 5, 6]
 
-      a.shift.should == 1
-      a.shift(3).should == [2, 3, 4]
-      a.should == [5]
-    end
+        a.shift(0).should == []
+        a.should == [1, 2, 3, 4, 5, 6]
+
+        a.shift(1).should == [1]
+        a.should == [2, 3, 4, 5, 6]
+
+        a.shift(2).should == [2, 3]
+        a.should == [4, 5, 6]
+
+        a.shift(3).should == [4, 5, 6]
+        a.should == []
+      end
+
+      it "does not corrupt the array when shift without arguments is followed by shift with an argument" do
+        a = [1, 2, 3, 4, 5]
+
+        a.shift.should == 1
+        a.shift(3).should == [2, 3, 4]
+        a.should == [5]
+      end
+
+      it "returns a new empty array if there are no more elements" do
+        a = []
+        popped1 = a.shift(1)
+        popped1.should == []
+        a.should == []
+
+        popped2 = a.shift(2)
+        popped2.should == []
+        a.should == []
+
+        popped1.should_not equal(popped2)
+      end
+
+      it "returns whole elements if n exceeds size of the array" do
+        a = [1, 2, 3, 4, 5]
+        a.shift(6).should == [1, 2, 3, 4, 5]
+        a.should == []
+      end
+
+      it "does not return self even when it returns whole elements" do
+        a = [1, 2, 3, 4, 5]
+        a.shift(5).should_not equal(a)
+
+        a = [1, 2, 3, 4, 5]
+        a.shift(6).should_not equal(a)
+      end
+
+      it "raises an ArgumentError if n is negative" do
+        lambda{ [1, 2, 3].shift(-1) }.should raise_error(ArgumentError)
+      end
+
+      it "tries to convert n to an Integer using #to_int" do
+        a = [1, 2, 3, 4]
+        a.shift(2.3).should == [1, 2]
+
+        obj = mock('to_int')
+        obj.should_receive(:to_int).and_return(2)
+        a.should == [3, 4]
+        a.shift(obj).should == [3, 4]
+        a.should == []
+      end
+
+      it "raises a TypeError when the passed n can be coerced to Integer" do
+        lambda{ [1, 2].shift("cat") }.should raise_error(TypeError)
+        lambda{ [1, 2].shift(nil) }.should raise_error(TypeError)
+      end
+
+      it "raises an ArgumentError if more arguments are passed" do
+        lambda{ [1, 2].shift(1, 2) }.should raise_error(ArgumentError)
+      end
+
+      it "does not return subclass instances with Array subclass" do
+        ArraySpecs::MyArray[1, 2, 3].shift(2).should be_kind_of(Array)
+      end
+
+      it "returns an untainted array even if the array is tainted" do
+        ary = [1, 2].taint
+        ary.shift(2).tainted?.should be_false
+        ary.shift(0).tainted?.should be_false
+      end
+
+      it "keeps taint status" do
+        a = [1, 2].taint
+        a.shift(2)
+        a.tainted?.should be_true
+        a.shift(2)
+        a.tainted?.should be_true
+      end
 
-    it "returns whole elements if n exceeds size of the array" do
-      a = [1, 2, 3, 4, 5]
-      a.shift(6).should == [1, 2, 3, 4, 5]
-      a.should == []
+      ruby_version_is '' ... '1.9' do
+        it "raises a TypeError on a frozen array" do
+          lambda { ArraySpecs.frozen_array.shift(2) }.should raise_error(TypeError)
+          lambda { ArraySpecs.frozen_array.shift(0) }.should raise_error(TypeError)
+        end
+      end
     end
   end
-end
+end