opal 0.3.41 → 0.3.42

data/spec/core/array/flatten_spec.rb

@@ -1,10 +1,90 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#flatten" do
   it "returns a one-dimensional flattening recursively" do
-    [[[1, [2, 3]], [2, 3, [4, [4, [5, 5]], [1, 2, 3]]], [4]], []].flatten.should == [1, 2, 3, 2, 3, 4, 4, 5, 5, 1, 2, 3, 4]
+    [[[1, [2, 3]],[2, 3, [4, [4, [5, 5]], [1, 2, 3]]], [4]], []].flatten.should == [1, 2, 3, 2, 3, 4, 4, 5, 5, 1, 2, 3, 4]
+  end
+
+  ruby_version_is "1.8.7" do
+    it "takes an optional argument that determines the level of recursion" do
+      [ 1, 2, [3, [4, 5] ] ].flatten(1).should == [1, 2, 3, [4, 5]]
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "returns self when the level of recursion is 0" do
+        a = [ 1, 2, [3, [4, 5] ] ]
+        a.flatten(0).should equal(a)
+      end
+    end
+
+    ruby_version_is "1.9" do
+      it "returns dup when the level of recursion is 0" do
+        a = [ 1, 2, [3, [4, 5] ] ]
+        a.flatten(0).should == a
+        a.flatten(0).should_not equal(a)
+      end
+    end
+
+    it "ignores negative levels" do
+      [ 1, 2, [ 3, 4, [5, 6] ] ].flatten(-1).should == [1, 2, 3, 4, 5, 6]
+      [ 1, 2, [ 3, 4, [5, 6] ] ].flatten(-10).should == [1, 2, 3, 4, 5, 6]
+    end
+
+    it "tries to convert passed Objects to Integers using #to_int" do
+      obj = mock("Converted to Integer")
+      obj.should_receive(:to_int).and_return(1)
+
+      [ 1, 2, [3, [4, 5] ] ].flatten(obj).should == [1, 2, 3, [4, 5]]
+    end
+
+    it "raises a TypeError when the passed Object can't be converted to an Integer" do
+      obj = mock("Not converted")
+      lambda { [ 1, 2, [3, [4, 5] ] ].flatten(obj) }.should raise_error(TypeError)
+    end
+  end
+
+  it "does not call flatten on elements" do
+    obj = mock('[1,2]')
+    obj.should_not_receive(:flatten)
+    [obj, obj].flatten.should == [obj, obj]
+
+    obj = [5, 4]
+    obj.should_not_receive(:flatten)
+    [obj, obj].flatten.should == [5, 4, 5, 4]
   end
 
-  it "takes an optional argument that determines the level of recursion" do
-    [1, 2, [3, [4, 5]]].flatten(1).should == [1, 2, 3, [4, 5]]
+  it "raises an ArgumentError on recursive arrays" do
+    x = []
+    x << x
+    lambda { x.flatten }.should raise_error(ArgumentError)
+
+    x = []
+    y = []
+    x << y
+    y << x
+    lambda { x.flatten }.should raise_error(ArgumentError)
+  end
+
+  it "flattens any element which responds to #to_ary, using the return value of said method" do
+    x = mock("[3,4]")
+    x.should_receive(:to_ary).at_least(:once).and_return([3, 4])
+    [1, 2, x, 5].flatten.should == [1, 2, 3, 4, 5]
+
+    y = mock("MyArray[]")
+    y.should_receive(:to_ary).at_least(:once).and_return(ArraySpecs::MyArray[])
+    [y].flatten.should == []
+
+    z = mock("[2,x,y,5]")
+    z.should_receive(:to_ary).and_return([2, x, y, 5])
+    [1, z, 6].flatten.should == [1, 2, 3, 4, 5, 6]
+  end
+
+  it "returns subclass instance for Array subclasses" do
+    ArraySpecs::MyArray[].flatten.should be_kind_of(ArraySpecs::MyArray)
+    ArraySpecs::MyArray[1, 2, 3].flatten.should be_kind_of(ArraySpecs::MyArray)
+    ArraySpecs::MyArray[1, [2], 3].flatten.should be_kind_of(ArraySpecs::MyArray)
+    [ArraySpecs::MyArray[1, 2, 3]].flatten.should be_kind_of(Array)
   end
 
   it "is not destructive" do
@@ -12,10 +92,30 @@ describe "Array#flatten" do
     ary.flatten
     ary.should == [1, [2, 3]]
   end
+
+  describe "with a non-Array object in the Array" do
+    before :each do
+      @obj = mock("Array#flatten")
+    end
+
+    it "does not call #to_ary if the method does not exist" do
+      [@obj].flatten.should == [@obj]
+    end
+
+    it "ignores the return value of #to_ary if it is nil" do
+      @obj.should_receive(:to_ary).and_return(nil)
+      [@obj].flatten.should == [@obj]
+    end
+
+    it "raises a TypeError if the return value of #to_ary is not an Array" do
+      @obj.should_receive(:to_ary).and_return(1)
+      lambda { [@obj].flatten }.should raise_error(TypeError)
+    end
+  end
 end
 
 describe "Array#flatten!" do
-  it "modified array to produce a one-dimensional flattening recursively" do
+  it "modifies array to produce a one-dimensional flattening recursively" do
     a = [[[1, [2, 3]],[2, 3, [4, [4, [5, 5]], [1, 2, 3]]], [4]], []]
     a.flatten!
     a.should == [1, 2, 3, 2, 3, 4, 4, 5, 5, 1, 2, 3, 4]
@@ -33,7 +133,100 @@ describe "Array#flatten!" do
     a.flatten!.should_not == nil
   end
 
-  it "takes an optional argument that determines the level of recursion" do
-    [1, 2, [3, [4, 5]]].flatten!(1).should == [1, 2, 3, [4, 5]]
+  ruby_version_is "1.8.7" do
+    it "takes an optional argument that determines the level of recursion" do
+      [ 1, 2, [3, [4, 5] ] ].flatten!(1).should == [1, 2, 3, [4, 5]]
+    end
+
+    ruby_bug "redmine #1440", "1.9.1" do
+      it "returns nil when the level of recursion is 0" do
+        a = [ 1, 2, [3, [4, 5] ] ]
+        a.flatten!(0).should == nil
+      end
+    end
+
+    it "treats negative levels as no arguments" do
+      [ 1, 2, [ 3, 4, [5, 6] ] ].flatten!(-1).should == [1, 2, 3, 4, 5, 6]
+      [ 1, 2, [ 3, 4, [5, 6] ] ].flatten!(-10).should == [1, 2, 3, 4, 5, 6]
+    end
+
+    it "tries to convert passed Objects to Integers using #to_int" do
+      obj = mock("Converted to Integer")
+      obj.should_receive(:to_int).and_return(1)
+
+      [ 1, 2, [3, [4, 5] ] ].flatten!(obj).should == [1, 2, 3, [4, 5]]
+    end
+
+    it "raises a TypeError when the passed Object can't be converted to an Integer" do
+      obj = mock("Not converted")
+      lambda { [ 1, 2, [3, [4, 5] ] ].flatten!(obj) }.should raise_error(TypeError)
+    end
+  end
+
+  it "does not call flatten! on elements" do
+    obj = mock('[1,2]')
+    obj.should_not_receive(:flatten!)
+    [obj, obj].flatten!.should == nil
+
+    obj = [5, 4]
+    obj.should_not_receive(:flatten!)
+    [obj, obj].flatten!.should == [5, 4, 5, 4]
+  end
+
+  it "raises an ArgumentError on recursive arrays" do
+    x = []
+    x << x
+    lambda { x.flatten! }.should raise_error(ArgumentError)
+
+    x = []
+    y = []
+    x << y
+    y << x
+    lambda { x.flatten! }.should raise_error(ArgumentError)
   end
-end
+
+  it "flattens any elements which responds to #to_ary, using the return value of said method" do
+    x = mock("[3,4]")
+    x.should_receive(:to_ary).at_least(:once).and_return([3, 4])
+    [1, 2, x, 5].flatten!.should == [1, 2, 3, 4, 5]
+
+    y = mock("MyArray[]")
+    y.should_receive(:to_ary).at_least(:once).and_return(ArraySpecs::MyArray[])
+    [y].flatten!.should == []
+
+    z = mock("[2,x,y,5]")
+    z.should_receive(:to_ary).and_return([2, x, y, 5])
+    [1, z, 6].flatten!.should == [1, 2, 3, 4, 5, 6]
+
+    ary = [ArraySpecs::MyArray[1, 2, 3]]
+    ary.flatten!
+    ary.should be_kind_of(Array)
+    ary.should == [1, 2, 3]
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError on frozen arrays when the array is modified" do
+      nested_ary = [1, 2, []]
+      nested_ary.freeze
+      lambda { nested_ary.flatten! }.should raise_error(TypeError)
+    end
+
+    it "does not raise on frozen arrays when the array would not be modified" do
+      ArraySpecs.frozen_array.flatten!.should be_nil
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on frozen arrays when the array is modified" do
+      nested_ary = [1, 2, []]
+      nested_ary.freeze
+      lambda { nested_ary.flatten! }.should raise_error(RuntimeError)
+    end
+
+    # see [ruby-core:23663]
+    it "raises a RuntimeError on frozen arrays when the array would not be modified" do
+      lambda { ArraySpecs.frozen_array.flatten! }.should raise_error(RuntimeError)
+      lambda { ArraySpecs.empty_frozen_array.flatten! }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/core/array/frozen_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Array#frozen?" do
+  it "returns true if array is frozen" do
+    a = [1, 2, 3]
+    a.frozen?.should == false
+    a.freeze
+    a.frozen?.should == true
+  end
+
+  not_compliant_on :rubinius do
+    ruby_version_is "" .. "1.9" do
+      it "returns true for an array being sorted by #sort!" do
+        a = [1, 2, 3]
+        a.sort! { |x,y| a.frozen?.should == true; x <=> y }
+      end
+    end
+
+    ruby_version_is "1.9" do
+      it "returns false for an array being sorted by #sort!" do
+        a = [1, 2, 3]
+        a.sort! { |x,y| a.frozen?.should == false; x <=> y }
+      end
+    end
+
+    it "returns false for an array being sorted by #sort" do
+      a = [1, 2, 3]
+      a.sort { |x,y| a.frozen?.should == false; x <=> y }
+    end
+  end
+end

data/spec/core/array/include_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#include?" do
   it "returns true if object is present, false otherwise" do
     [1, 2, "a", "b"].include?("c").should == false
@@ -15,4 +18,16 @@ describe "Array#include?" do
 
     [1, 2.0, 3].include?(2).should == true
   end
-end
+
+  it "calls == on elements from left to right until success" do
+    key = "x"
+    one = mock('one')
+    two = mock('two')
+    three = mock('three')
+    one.should_receive(:==).any_number_of_times.and_return(false)
+    two.should_receive(:==).any_number_of_times.and_return(true)
+    three.should_not_receive(:==)
+    ary = [one, two, three]
+    ary.include?(key).should == true
+  end
+end

data/spec/core/array/index_spec.rb

@@ -1,26 +1,6 @@
-describe "Array#index" do
-  it "returns the index of the first element == to object" do
-    [1, 2, 3, 4, 5, 6].index(3).should == 2
-    [1, 2, 3, 4, 5, 6].index(4).should == 3
-  end
-
-  it "returns 0 if first element == to object" do
-    [2, 1, 3, 2, 5].index(2).should == 0
-  end
-
-  it "returns size-1 if only last element == to object" do
-    [2, 1, 3, 1, 5].index(5).should == 4
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/index', __FILE__)
 
-  it "returns nil if no element == to object" do
-    [2, 1, 1, 1, 1].index(3).should == nil
-  end
-
-  it "accepts a block instead of an argument" do
-    [4, 2, 1, 5, 1, 3].index { |x| x < 2 }.should == 2
-  end
-
-  it "ignores the block if there is an argument" do
-    [4, 2, 1, 5, 1, 3].index(5) { |x| x < 2 }.should == 3
-  end
-end
+describe "Array#index" do
+  it_behaves_like(:array_index, :index)
+end

data/spec/core/array/insert_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#insert" do
   it "returns self" do
     ary = []
@@ -43,14 +46,45 @@ describe "Array#insert" do
   end
 
   it "raises an IndexError if the negative index is out of bounds" do
-    lambda { [].insert(-2, 1) }.should raise_error(IndexError)
+    lambda { [].insert(-2, 1)  }.should raise_error(IndexError)
     lambda { [1].insert(-3, 2) }.should raise_error(IndexError)
   end
 
-  it "does nothing if no object is passed" do
+  it "does nothing of no object is passed" do
     [].insert(0).should == []
     [].insert(-1).should == []
     [].insert(10).should == []
     [].insert(-2).should == []
   end
-end
+
+  it "tries to convert the passed position argument to an Integer using #to_int" do
+    obj = mock('2')
+    obj.should_receive(:to_int).and_return(2)
+    [].insert(obj, 'x').should == [nil, nil, 'x']
+  end
+
+  it "raises an ArgumentError if no argument passed" do
+    lambda { [].insert() }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError on frozen arrays when the array is modified" do
+      lambda { ArraySpecs.frozen_array.insert(0, 'x') }.should raise_error(TypeError)
+    end
+
+    it "does not raise on frozen arrays when the array would not be modified" do
+      ArraySpecs.frozen_array.insert(0).should == [1, 2, 3]
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on frozen arrays when the array is modified" do
+      lambda { ArraySpecs.frozen_array.insert(0, 'x') }.should raise_error(RuntimeError)
+    end
+
+    # see [ruby-core:23666]
+    it "raises a RuntimeError on frozen arrays when the array would not be modified" do
+      lambda { ArraySpecs.frozen_array.insert(0)      }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/core/array/inspect_spec.rb

@@ -1,13 +1,7 @@
-describe "Array#inspect" do
-  it "returns a String" do
-    [1, 2, 3].inspect.should be_kind_of(String)
-  end
-
-  it "returns '[]' for an empty Array" do
-    [].inspect.should == "[]"
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/inspect', __FILE__)
 
-  it "calls inspect on its elements and joins the results with commas" do
-    [0, 1, 2].inspect.should == "[0, 1, 2]"
-  end
-end
+describe "Array#inspect" do
+  it_behaves_like :array_inspect, :inspect
+end

data/spec/core/array/intersection_spec.rb

@@ -1,17 +1,20 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#&" do
   it "creates an array with elements common to both arrays (intersection)" do
     ([] & []).should == []
     ([1, 2] & []).should == []
     ([] & [1, 2]).should == []
-    ([1, 3, 5] & [1, 2, 3]).should == [1, 3]
+    ([ 1, 3, 5 ] & [ 1, 2, 3 ]).should == [1, 3]
   end
 
   it "creates an array with no duplicates" do
-    ([1, 1, 3, 5] & [1, 2, 3]).uniq!.should == nil
+    ([ 1, 1, 3, 5 ] & [ 1, 2, 3 ]).uniq!.should == nil
   end
 
   it "creates an array with elements in order they are first encountered" do
-    ([1, 2, 3, 2, 5] & [5, 2, 3, 4]).should == [2, 3, 5]
+    ([ 1, 2, 3, 2, 5 ] & [ 5, 2, 3, 4 ]).should == [2, 3, 5]
   end
 
   it "does not modify the original Array" do
@@ -19,4 +22,52 @@ describe "Array#&" do
     a & [1, 2, 3]
     a.should == [1, 1, 3, 5]
   end
-end
+
+  ruby_bug "ruby-core #1448", "1.9.1" do
+    it "properly handles recursive arrays" do
+      empty = ArraySpecs.empty_recursive_array
+      (empty & empty).should == empty
+
+      (ArraySpecs.recursive_array & []).should == []
+      ([] & ArraySpecs.recursive_array).should == []
+
+      (ArraySpecs.recursive_array & ArraySpecs.recursive_array).should == [1, 'two', 3.0, ArraySpecs.recursive_array]
+    end
+  end
+
+  it "tries to convert the passed argument to an Array using #to_ary" do
+    obj = mock('[1,2,3]')
+    obj.should_receive(:to_ary).and_return([1, 2, 3])
+    ([1, 2] & obj).should == ([1, 2])
+  end
+
+  it "determines equivalence between elements in the sense of eql?" do
+    ([5.0, 4.0] & [5, 4]).should == []
+    str = "x"
+    ([str] & [str.dup]).should == [str]
+
+    obj1 = mock('1')
+    obj2 = mock('2')
+    def obj1.hash; 0; end
+    def obj2.hash; 0; end
+    def obj1.eql? a; true; end
+    def obj2.eql? a; true; end
+
+    ([obj1] & [obj2]).should == [obj1]
+
+    def obj1.eql? a; false; end
+    def obj2.eql? a; false; end
+
+    ([obj1] & [obj2]).should == []
+  end
+
+  it "does return subclass instances for Array subclasses" do
+    (ArraySpecs::MyArray[1, 2, 3] & []).should be_kind_of(Array)
+    (ArraySpecs::MyArray[1, 2, 3] & ArraySpecs::MyArray[1, 2, 3]).should be_kind_of(Array)
+    ([] & ArraySpecs::MyArray[1, 2, 3]).should be_kind_of(Array)
+  end
+
+  it "does not call to_ary on array subclasses" do
+    ([5, 6] & ArraySpecs::ToAryArray[1, 2, 5, 6]).should == [5, 6]
+  end
+end