opal 0.3.41 → 0.3.42

data/spec/core/array/join_spec.rb

@@ -1,9 +1,34 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/join', __FILE__)
+
 describe "Array#join" do
-  it "returns a string formed by concatenating each element with separator" do
-    [1, 2, 3, 4, 5].join(' | ').should == "1 | 2 | 3 | 4 | 5"
-  end
+  it_behaves_like :array_join_with_string_separator,  :join
+
+  it_behaves_like :array_join_with_default_separator, :join
 
   it "does not separate elements when the passed separator is nil" do
     [1, 2, 3].join(nil).should == '123'
   end
-end
+
+  it "calls #to_str to convert the separator to a String" do
+    sep = mock("separator")
+    sep.should_receive(:to_str).and_return(", ")
+    [1, 2].join(sep).should == "1, 2"
+  end
+
+  it "does not call #to_str on the separator if the array is empty" do
+    sep = mock("separator")
+    sep.should_not_receive(:to_str)
+    [].join(sep).should == ""
+  end
+
+  it "raises a TypeError if the separator cannot be coerced to a String by calling #to_str" do
+    obj = mock("not a string")
+    lambda { [1, 2].join(obj) }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError if passed false as the separator" do
+    lambda { [1, 2].join(false) }.should raise_error(TypeError)
+  end
+end

data/spec/core/array/keep_if_spec.rb

@@ -1,7 +1,14 @@
-describe "Array#keep_if" do
-  it "deletes elements for which the block returns a false value" do
-    array = [1, 2, 3, 4, 5]
-    array.keep_if { |item| item > 3 }.should equal(array)
-    array.should == [4, 5]
+require File.expand_path('../shared/keep_if', __FILE__)
+
+ruby_version_is "1.9" do
+  describe "Array#keep_if" do
+    it "returns the same array if no changes were made" do
+      array = [1, 2, 3]
+      array.keep_if { true }.should equal(array)
+    end
+
+    pending do
+      it_behaves_like :keep_if, :keep_if
+    end
   end
-end
+end

data/spec/core/array/last_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#last" do
   it "returns the last element" do
     [1, 1, 1, 1, 2].last.should == 2
@@ -42,6 +45,37 @@ describe "Array#last" do
     ary.should == [1, 2, 3, 4, 5]
   end
 
+  it "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.last.should equal(empty)
+
+    array = ArraySpecs.recursive_array
+    array.last.should equal(array)
+  end
+
+  it "tries to convert the passed argument to an Integer usinig #to_int" do
+    obj = mock('to_int')
+    def obj.to_int; 2 ; end 
+    obj.to_int.should == 2
+    [1, 2, 3, 4, 5].last(obj).should == [4, 5]
+  end
+
+  it "raises a TypeError if the passed argument is not numeric" do
+    lambda { [1,2].last(nil) }.should raise_error(TypeError)
+    lambda { [1,2].last("a") }.should raise_error(TypeError)
+
+    obj = mock("nonnumeric")
+    lambda { [1,2].last(obj) }.should raise_error(TypeError)
+  end
+
+  it "does not return subclass instance on Array subclasses" do
+    ArraySpecs::MyArray[].last(0).should be_kind_of(Array)
+    ArraySpecs::MyArray[].last(2).should be_kind_of(Array)
+    ArraySpecs::MyArray[1, 2, 3].last(0).should be_kind_of(Array)
+    ArraySpecs::MyArray[1, 2, 3].last(1).should be_kind_of(Array)
+    ArraySpecs::MyArray[1, 2, 3].last(2).should be_kind_of(Array)
+  end
+
   it "is not destructive" do
     a = [1, 2, 3]
     a.last
@@ -51,4 +85,4 @@ describe "Array#last" do
     a.last(3)
     a.should == [1, 2, 3]
   end
-end
+end

data/spec/core/array/length_spec.rb

@@ -1,6 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/length', __FILE__)
+
 describe "Array#length" do
-  it "returns the number of elements" do
-    [].length.should == 0
-    [1, 2, 3].length.should == 3
+  pending do
+    it_behaves_like(:array_length, :length)
   end
-end
+end

data/spec/core/array/map_spec.rb

@@ -1,53 +1,15 @@
-describe "Array#map" do
-  it "returns a copy of array with each element replaced by the value returned by block" do
-    a = ['a', 'b', 'c', 'd']
-    b = a.map { |i| i + '!' }
-    b.should == ['a!', 'b!', 'c!', 'd!']
-    b.object_id.should_not == a.object_id
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/collect', __FILE__)
 
-  it "does not change self" do
-    a = ['a', 'b', 'c', 'd']
-    b = a.map { |i| i + '!' }
-    a.should == ['a', 'b', 'c', 'd']
-  end
-
-  it "returns the evaluated value of block if it broke in the block" do
-    a = ['a', 'b', 'c', 'd']
-    b = a.map {|i|
-      if i == 'c'
-        break 0
-      else
-        i + '!'
-      end
-    }
-    b.should == 0
+describe "Array#map" do
+  pending do
+    it_behaves_like(:array_collect, :map)
   end
 end
 
 describe "Array#map!" do
-  it "replaces each element with the value returned by block" do
-    a = [7, 9, 3, 5]
-    a.map! { |i| i - 1 }.should equal(a)
-    a.should == [6, 8, 2, 4]
+  pending do
+    it_behaves_like(:array_collect_b, :map!)
   end
-
-  it "returns self" do
-    a = [1, 2, 3, 4, 5]
-    b = a.map! {|i| i+1 }
-    a.object_id.should == b.object_id
-  end
-
-  it "returns the evaluated value of block but its contents is partially modified, if it broke in the block" do
-    a = ['a', 'b', 'c', 'd']
-    b = a.map! {|i|
-      if i == 'c'
-        break 0
-      else
-        i + '!'
-      end
-    }
-    b.should == 0
-    a.should == ['a!', 'b!', 'c', 'd']
-  end
-end
+end

data/spec/core/array/minus_spec.rb

@@ -1,23 +1,87 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#-" do
   it "creates an array minus any items from other array" do
-    ([] - [1, 2, 4]).should == []
+    ([] - [ 1, 2, 4 ]).should == []
     ([1, 2, 4] - []).should == [1, 2, 4]
-    ([1, 2, 3, 4, 5] - [1, 2, 4]).should == [3, 5]
+    ([ 1, 2, 3, 4, 5 ] - [ 1, 2, 4 ]).should == [3, 5]
   end
 
   it "removes multiple items on the lhs equal to one on the rhs" do
     ([1, 1, 2, 2, 3, 3, 4, 5] - [1, 2, 4]).should == [3, 3, 5]
   end
 
+  ruby_bug "#", "1.8.6.277" do
+    pending "properly handles recursive arrays" do
+      empty = ArraySpecs.empty_recursive_array
+      (empty - empty).should == []
+
+      ([] - ArraySpecs.recursive_array).should == []
+
+      array = ArraySpecs.recursive_array
+      (array - array).should == []
+    end
+  end
+
+  pending "tries to convert the passed arguments to Arrays using #to_ary" do
+    obj = mock('[2,3,3,4]')
+    obj.should_receive(:to_ary).and_return([2, 3, 3, 4])
+    ([1, 1, 2, 2, 3, 4] - obj).should == [1, 1]
+  end
+
+  pending "raises a TypeError if the argument cannot be coerced to an Array by calling #to_ary" do
+    obj = mock('not an array')
+    lambda { [1, 2, 3] - obj }.should raise_error(TypeError)
+  end
+
+  it "does not return subclass instance for Array subclasses" do
+    (ArraySpecs::MyArray[1, 2, 3] - []).should be_kind_of(Array)
+    (ArraySpecs::MyArray[1, 2, 3] - ArraySpecs::MyArray[]).should be_kind_of(Array)
+    ([1, 2, 3] - ArraySpecs::MyArray[]).should be_kind_of(Array)
+  end
+
+  it "does not call to_ary on array subclasses" do
+    ([5, 6, 7] - ArraySpecs::ToAryArray[7]).should == [5, 6]
+  end
+
+  pending "removes an item identified as equivalent via #hash and #eql?" do
+    obj1 = mock('1')
+    obj2 = mock('2')
+    obj1.should_receive(:hash).and_return(0)
+    obj2.should_receive(:hash).and_return(0)
+    obj1.should_receive(:eql?).with(obj2).and_return(true)
+
+    ([obj1] - [obj2]).should == []
+  end
+
+  pending "doesn't remove an item with the same hash but not #eql?" do
+    obj1 = mock('1')
+    obj2 = mock('2')
+    obj1.should_receive(:hash).and_return(0)
+    obj2.should_receive(:hash).and_return(0)
+    obj1.should_receive(:eql?).with(obj2).and_return(false)
+
+    ([obj1] - [obj2]).should == [obj1]
+  end
+
+  pending "removes an identical item even when its #eql? isn't reflexive" do
+    x = mock('x')
+    x.should_receive(:hash).any_number_of_times.and_return(42)
+    x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI.
+
+    ([x] - [x]).should == []
+  end
+
   it "is not destructive" do
     a = [1, 2, 3]
     a - []
     a.should == [1, 2, 3]
     a - [1]
     a.should == [1, 2, 3]
-    a - [1, 2, 3]
+    a - [1,2,3]
     a.should == [1, 2, 3]
     a - [:a, :b, :c]
     a.should == [1, 2, 3]
   end
-end
+end

data/spec/core/array/multiply_spec.rb

@@ -1,13 +1,145 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/join', __FILE__)
+
+describe "Array#*" do
+  pending "tries to convert the passed argument to a String using #to_str" do
+    obj = mock('separator')
+    obj.should_receive(:to_str).and_return('::')
+    ([1, 2, 3, 4] * obj).should == '1::2::3::4'
+  end
+
+  pending "tires to convert the passed argument to an Integer using #to_int" do
+    obj = mock('count')
+    obj.should_receive(:to_int).and_return(2)
+    ([1, 2, 3, 4] * obj).should == [1, 2, 3, 4, 1, 2, 3, 4]
+  end
+
+  pending "raises a TypeError if the argument can neither be converted to a string nor an integer" do
+    obj = mock('not a string or integer')
+    lambda{ [1,2] * obj }.should raise_error(TypeError)
+  end
+
+  pending "converts the passed argument to a String rather than an Integer" do
+    obj = mock('2')
+    def obj.to_int() 2 end
+    def obj.to_str() "2" end
+    ([:a, :b, :c] * obj).should == "a2b2c"
+  end
+
+  pending "raises a TypeError is the passed argument is nil" do
+    lambda{ [1,2] * nil }.should raise_error(TypeError)
+  end
+
+  it "raises an ArgumentError when passed 2 or more arguments" do
+    lambda{ [1,2].send(:*, 1, 2) }.should raise_error(ArgumentError)
+  end
+
+  it "raises an ArgumentError when passed no arguments" do
+    lambda{ [1,2].send(:*) }.should raise_error(ArgumentError)
+  end
+end
+
 describe "Array#* with an integer" do
   it "concatenates n copies of the array when passed an integer" do
-    ([1, 2, 3] * 0).should == []
-    ([1, 2, 3] * 1).should == [1, 2, 3]
-    ([1, 2, 3] * 3).should == [1, 2, 3, 1, 2, 3, 1, 2, 3]
+    ([ 1, 2, 3 ] * 0).should == []
+    ([ 1, 2, 3 ] * 1).should == [1, 2, 3]
+    ([ 1, 2, 3 ] * 3).should == [1, 2, 3, 1, 2, 3, 1, 2, 3]
+    ([] * 10).should == []
+  end
+
+  it "does not return self even if the passed integer is 1" do
+    ary = [1, 2, 3]
+    (ary * 1).should_not equal(ary)
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    (empty * 0).should == []
+    (empty * 1).should == empty
+    (empty * 3).should == [empty, empty, empty]
+
+    array = ArraySpecs.recursive_array
+    (array * 0).should == []
+    (array * 1).should == array
+  end
+
+  pending "raises an ArgumentError when passed a negative integer" do
+    lambda { [ 1, 2, 3 ] * -1 }.should raise_error(ArgumentError)
+    lambda { [] * -1 }.should raise_error(ArgumentError)
+  end
+
+  describe "with a subclass of Array" do
+    before :each do
+      ScratchPad.clear
+
+      @array = ArraySpecs::MyArray[1, 2, 3, 4, 5]
+    end
+
+    pending "returns a subclass instance" do
+      (@array * 0).should be_an_instance_of(ArraySpecs::MyArray)
+      (@array * 1).should be_an_instance_of(ArraySpecs::MyArray)
+      (@array * 2).should be_an_instance_of(ArraySpecs::MyArray)
+    end
+
+    it "does not call #initialize on the subclass instance" do
+      (@array * 2).should == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
+      ScratchPad.recorded.should be_nil
+    end
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "does not copy the taint status of the original array if the passed count is 0" do
+      ary = [1, 2, 3]
+      ary.taint
+      (ary * 0).tainted?.should == false
+    end
+  end
+  ruby_version_is '1.9' do
+    pending "copies the taint status of the original array even if the passed count is 0" do
+      ary = [1, 2, 3]
+      ary.taint
+      (ary * 0).tainted?.should == true
+    end
+  end
+
+  pending "copies the taint status of the original array even if the array is empty" do
+    ary = []
+    ary.taint
+    (ary * 3).tainted?.should == true
+  end
+
+  pending "copies the taint status of the original array if the passed count is not 0" do
+    ary = [1, 2, 3]
+    ary.taint
+    (ary * 1).tainted?.should == true
+    (ary * 2).tainted?.should == true
+  end
+
+  ruby_version_is '1.9' do
+    pending "copies the untrusted status of the original array even if the passed count is 0" do
+      ary = [1, 2, 3]
+      ary.untrust
+      (ary * 0).untrusted?.should == true
+    end
+
+    pending "copies the untrusted status of the original array even if the array is empty" do
+      ary = []
+      ary.untrust
+      (ary * 3).untrusted?.should == true
+    end
+
+    pending "copies the untrusted status of the original array if the passed count is not 0" do
+      ary = [1, 2, 3]
+      ary.untrust
+      (ary * 1).untrusted?.should == true
+      (ary * 2).untrusted?.should == true
+    end
   end
 end
 
 describe "Array#* with a string" do
-  it "returns a string formed by concatenating each element with separator" do
-    ([1, 2, 3, 4, 5] * ' | ').should == "1 | 2 | 3 | 4 | 5"
+  pending do
+    it_behaves_like :array_join_with_string_separator, :*
   end
-end
+end

data/spec/core/array/new_spec.rb

@@ -1,12 +1,32 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array.new" do
   it "returns an instance of Array" do
     Array.new.should be_kind_of(Array)
   end
+
+  pending "returns an instance of a subclass" do
+    ArraySpecs::MyArray.new(1, 2).should be_an_instance_of(ArraySpecs::MyArray)
+  end
+
+  pending "raise an ArgumentError if passed 3 or more arguments" do
+    lambda do
+      [1, 2].send :initialize, 1, 'x', true
+    end.should raise_error(ArgumentError)
+    lambda do
+      [1, 2].send(:initialize, 1, 'x', true) {}
+    end.should raise_error(ArgumentError)
+  end
 end
 
 describe "Array.new with no arguments" do
-  it "returns an empty array" do
-    Array.new.empty?.should be_true
+  pending "returns an empty array" do
+    Array.new.should be_empty
+  end
+
+  it "does not use the given block" do
+    lambda{ Array.new { raise } }.should_not raise_error
   end
 end
 
@@ -15,6 +35,27 @@ describe "Array.new with (array)" do
     b = [4, 5, 6]
     Array.new(b).should == b
   end
+
+  it "does not use the given block" do
+    lambda{ Array.new([1, 2]) { raise } }.should_not raise_error
+  end
+
+  pending "calls #to_ary to convert the value to an array" do
+    a = mock("array")
+    a.should_receive(:to_ary).and_return([1, 2])
+    a.should_not_receive(:to_int)
+    Array.new(a).should == [1, 2]
+  end
+
+  pending "does not call #to_ary on instances of Array or subclasses of Array" do
+    a = [1, 2]
+    a.should_not_receive(:to_ary)
+    Array.new(a)
+  end
+
+  pending "raises a TypeError if an Array type argument and a default object" do
+    lambda { Array.new([1, 2], 1) }.should raise_error(TypeError)
+  end
 end
 
 describe "Array.new with (size, object=nil)" do
@@ -30,6 +71,45 @@ describe "Array.new with (size, object=nil)" do
     Array.new(3).should == [nil, nil, nil]
   end
 
+  pending "raises an ArgumentError if size is negative" do
+    lambda { Array.new(-1, :a) }.should raise_error(ArgumentError)
+    lambda { Array.new(-1) }.should raise_error(ArgumentError)
+  end
+
+  pending do
+  platform_is :wordsize => 32 do
+    it "raises an ArgumentError if size is too large" do
+      max_size = ArraySpecs.max_32bit_size
+      lambda { Array.new(max_size + 1) }.should raise_error(ArgumentError)
+    end
+  end
+
+  platform_is :wordsize => 64 do
+    it "raises an ArgumentError if size is too large" do
+      max_size = ArraySpecs.max_64bit_size
+      lambda { Array.new(max_size + 1) }.should raise_error(ArgumentError)
+    end
+  end
+  end
+
+  pending "calls #to_int to convert the size argument to an Integer when object is given" do
+    obj = mock('1')
+    obj.should_receive(:to_int).and_return(1)
+    Array.new(obj, :a).should == [:a]
+  end
+
+  pending "calls #to_int to convert the size argument to an Integer when object is not given" do
+    obj = mock('1')
+    obj.should_receive(:to_int).and_return(1)
+    Array.new(obj).should == [nil]
+  end
+
+  pending "raises a TypeError if the size argument is not an Integer type" do
+    obj = mock('nonnumeric')
+    obj.stub!(:to_ary).and_return([1, 2])
+    lambda{ Array.new(obj, :a) }.should raise_error(TypeError)
+  end
+
   it "yields the index of the element and sets the element to the value of the block" do
     Array.new(3) { |i| i.to_s }.should == ['0', '1', '2']
   end
@@ -37,4 +117,13 @@ describe "Array.new with (size, object=nil)" do
   it "uses the block value instead of using the default value" do
     Array.new(3, :obj) { |i| i.to_s }.should == ['0', '1', '2']
   end
-end
+
+  pending "returns the value passed to break" do
+    a = Array.new(3) do |i|
+      break if i == 2
+      i.to_s
+    end
+
+    a.should == nil
+  end
+end