opal 0.3.41 → 0.3.42

data/spec/core/array/take_spec.rb

@@ -1,21 +1,29 @@
-describe "Array#take" do
-  it "returns the first specified number of elements" do
-    [1, 2, 3].take(2).should == [1, 2]
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
 
-  it "returns all elements when the argument is greater than the Array size" do
-    [1, 2].take(99).should == [1, 2]
-  end
+ruby_version_is "1.8.7" do
+  describe "Array#take" do
+    it "returns the first specified number of elements" do
+      [1, 2, 3].take(2).should == [1, 2]
+    end
 
-  it "returns all elements when the argument is less than the Array size" do
-    [1, 2].take(4).should == [1, 2]
-  end
+    it "returns all elements when the argument is greater than the Array size" do
+      [1, 2].take(99).should == [1, 2]
+    end
 
-  it "returns an empty Array when passed zero" do
-    [1].take(0).should == []
-  end
+    it "returns all elements when the argument is less than the Array size" do
+      [1, 2].take(4).should == [1, 2]
+    end
+
+    it "returns an empty Array when passed zero" do
+      [1].take(0).should == []
+    end
+
+    it "returns an empty Array when called on an empty Array" do
+      [].take(3).should == []
+    end
 
-  it "returns an empty Array when called on an empty Array" do
-    [].take(3).should == []
+    it "raises an ArgumentError when the argument is negative" do
+      lambda{ [1].take(-3) }.should raise_error(ArgumentError)
+    end
   end
-end
+end

data/spec/core/array/take_while_spec.rb

@@ -1,13 +1,17 @@
-describe "Array#take_while" do
-  it "returns all elements until the block returns false" do
-    [1, 2, 3].take_while{ |element| element < 3 }.should == [1, 2]
-  end
+require File.expand_path('../../../spec_helper', __FILE__)
 
-  it "returns all elements until the block returns nil" do
-    [1, 2, nil, 4].take_while{ |element| element }.should == [1, 2]
-  end
+ruby_version_is "1.8.7" do
+  describe "Array#take_while" do
+    it "returns all elements until the block returns false" do
+      [1, 2, 3].take_while{ |element| element < 3 }.should == [1, 2]
+    end
+
+    it "returns all elements until the block returns nil" do
+      [1, 2, nil, 4].take_while{ |element| element }.should == [1, 2]
+    end
 
-  it "returns all elements until the block returns false" do
-    [1, 2, false, 4].take_while{ |element| element }.should == [1, 2]
+    it "returns all elements until the block returns false" do
+      [1, 2, false, 4].take_while{ |element| element }.should == [1, 2]
+    end
   end
-end
+end

data/spec/core/array/to_a_spec.rb

@@ -1,7 +1,24 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#to_a" do
   it "returns self" do
     a = [1, 2, 3]
     a.to_a.should == [1, 2, 3]
     a.should equal(a.to_a)
   end
-end
+
+  pending "does not return subclass instance on Array subclasses" do
+    e = ArraySpecs::MyArray.new(1, 2)
+    e.to_a.should be_an_instance_of(Array)
+    e.to_a.should == [1, 2]
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.to_a.should == empty
+
+    array = ArraySpecs.recursive_array
+    array.to_a.should == array
+  end
+end

data/spec/core/array/to_ary_spec.rb

@@ -1,6 +1,20 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#to_ary" do
   it "returns self" do
     a = [1, 2, 3]
     a.should equal(a.to_ary)
+    a = ArraySpecs::MyArray[1, 2, 3]
+    a.should equal(a.to_ary)
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.to_ary.should == empty
+
+    array = ArraySpecs.recursive_array
+    array.to_ary.should == array
   end
-end
+
+end

data/spec/core/array/try_convert_spec.rb

@@ -3,13 +3,50 @@ require File.expand_path('../fixtures/classes', __FILE__)
 
 ruby_version_is "1.9" do
   describe "Array.try_convert" do
-    it "returns the argument if it's a Array" do
+    it "returns the argument if it's an Array" do
       x = Array.new
       Array.try_convert(x).should equal(x)
     end
 
-    it "returns nil when the argument does not respond to #to_ary" do
+    pending "returns the argument if it's a kind of Array" do
+      x = ArraySpecs::MyArray[]
+      Array.try_convert(x).should equal(x)
+    end
+
+    pending "returns nil when the argument does not respond to #to_ary" do
       Array.try_convert(Object.new).should be_nil
     end
+
+    pending "sends #to_ary to the argument and returns the result if it's nil" do
+      obj = mock("to_ary")
+      obj.should_receive(:to_ary).and_return(nil)
+      Array.try_convert(obj).should be_nil
+    end
+
+    pending "sends #to_ary to the argument and returns the result if it's an Array" do
+      x = Array.new
+      obj = mock("to_ary")
+      obj.should_receive(:to_ary).and_return(x)
+      Array.try_convert(obj).should equal(x)
+    end
+
+    pending "sends #to_ary to the argument and returns the result if it's a kind of Array" do
+      x = ArraySpecs::MyArray[]
+      obj = mock("to_ary")
+      obj.should_receive(:to_ary).and_return(x)
+      Array.try_convert(obj).should equal(x)
+    end
+
+    pending "sends #to_ary to the argument and raises TypeError if it's not a kind of Array" do
+      obj = mock("to_ary")
+      obj.should_receive(:to_ary).and_return(Object.new)
+      lambda { Array.try_convert obj }.should raise_error(TypeError)
+    end
+
+    pending "does not rescue exceptions raised by #to_ary" do
+      obj = mock("to_ary")
+      obj.should_receive(:to_ary).and_raise(RuntimeError)
+      lambda { Array.try_convert obj }.should raise_error(RuntimeError)
+    end
   end
 end

data/spec/core/array/uniq_spec.rb

@@ -1,10 +1,102 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#uniq" do
   it "returns an array with no duplicates" do
     ["a", "a", "b", "b", "c"].uniq.should == ["a", "b", "c"]
   end
 
-  it "uses eql? semantics" do
-    [1.0, 1].should == [1.0, 1]
+  ruby_bug "#", "1.8.6.277" do
+    pending "properly handles recursive arrays" do
+      empty = ArraySpecs.empty_recursive_array
+      empty.uniq.should == [empty]
+
+      array = ArraySpecs.recursive_array
+      array.uniq.should == [1, 'two', 3.0, array]
+    end
+  end
+
+  pending "uses eql? semantics" do
+    [1.0, 1].uniq.should == [1.0, 1]
+  end
+
+  it "compares elements first with hash" do
+    # Can't use should_receive because it uses hash internally
+    x = mock('0')
+    def x.hash() 0 end
+    y = mock('0')
+    def y.hash() 0 end
+
+    [x, y].uniq.should == [x, y]
+  end
+
+  it "does not compare elements with different hash codes via eql?" do
+    # Can't use should_receive because it uses hash and eql? internally
+    x = mock('0')
+    def x.eql?(o) raise("Shouldn't receive eql?") end
+    y = mock('1')
+    def y.eql?(o) raise("Shouldn't receive eql?") end
+
+    def x.hash() 0 end
+    def y.hash() 1 end
+
+    [x, y].uniq.should == [x, y]
+  end
+
+  pending "compares elements with matching hash codes with #eql?" do
+    # Can't use should_receive because it uses hash and eql? internally
+    a = Array.new(2) do
+      obj = mock('0')
+
+      def obj.hash()
+        # It's undefined whether the impl does a[0].eql?(a[1]) or
+        # a[1].eql?(a[0]) so we taint both.
+        def self.eql?(o) taint; o.taint; false; end
+        return 0
+      end
+
+      obj
+    end
+
+    a.uniq.should == a
+    a[0].tainted?.should == true
+    a[1].tainted?.should == true
+
+    a = Array.new(2) do
+      obj = mock('0')
+
+      def obj.hash()
+        # It's undefined whether the impl does a[0].eql?(a[1]) or
+        # a[1].eql?(a[0]) so we taint both.
+        def self.eql?(o) taint; o.taint; true; end
+        return 0
+      end
+
+      obj
+    end
+
+    a.uniq.size.should == 1
+    a[0].tainted?.should == true
+    a[1].tainted?.should == true
+  end
+
+  ruby_version_is "1.9" do
+    pending "compares elements based on the value returned from the block" do
+      a = [1, 2, 3, 4]
+      a.uniq { |x| x >= 2 ? 1 : 0 }.should == [1, 2]
+    end
+  end
+
+  ruby_version_is "" ... "1.9.3" do
+    pending "returns subclass instance on Array subclasses" do
+      ArraySpecs::MyArray[1, 2, 3].uniq.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].uniq.should be_kind_of(Array)
+    end
   end
 end
 
@@ -19,4 +111,57 @@ describe "Array#uniq!" do
     a = [ "a", "a", "b", "b", "c" ]
     a.should equal(a.uniq!)
   end
-end
+
+  ruby_bug "#", "1.8.6.277" do
+    pending "properly handles recursive arrays" do
+      empty = ArraySpecs.empty_recursive_array
+      empty_dup = empty.dup
+      empty.uniq!
+      empty.should == empty_dup
+
+      array = ArraySpecs.recursive_array
+      expected = array[0..3]
+      array.uniq!
+      array.should == expected
+    end
+  end
+
+  it "returns nil if no changes are made to the array" do
+    [ "a", "b", "c" ].uniq!.should == nil
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError on a frozen array when the array is modified" do
+      dup_ary = [1, 1, 2]
+      dup_ary.freeze
+      lambda { dup_ary.uniq! }.should raise_error(TypeError)
+    end
+
+    it "does not raise an exception on a frozen array when the array would not be modified" do
+      ArraySpecs.frozen_array.uniq!.should be_nil
+    end
+  end
+
+  ruby_version_is "1.9" do
+    pending "raises a RuntimeError on a frozen array when the array is modified" do
+      dup_ary = [1, 1, 2]
+      dup_ary.freeze
+      lambda { dup_ary.uniq! }.should raise_error(RuntimeError)
+    end
+
+    # see [ruby-core:23666]
+    it "raises a RuntimeError on a frozen array when the array would not be modified" do
+      lambda { ArraySpecs.frozen_array.uniq!}.should raise_error(RuntimeError)
+      lambda { ArraySpecs.empty_frozen_array.uniq!}.should raise_error(RuntimeError)
+    end
+
+    it "doesn't yield to the block on a frozen array" do
+      lambda { ArraySpecs.frozen_array.uniq!{ raise RangeError, "shouldn't yield"}}.should raise_error(RuntimeError)
+    end
+
+    pending "compares elements based on the value returned from the block" do
+      a = [1, 2, 3, 4]
+      a.uniq! { |x| x >= 2 ? 1 : 0 }.should == [1, 2]
+    end
+  end
+end

data/spec/core/array/unshift_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#unshift" do
   it "prepends object to the original array" do
     a = [1, 2, 3]
@@ -26,4 +29,36 @@ describe "Array#unshift" do
     [].unshift().should == []
     [].unshift(*[]).should == []
   end
-end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.unshift(:new).should == [:new, empty]
+
+    array = ArraySpecs.recursive_array
+    array.unshift(:new)
+    array[0..5].should == [:new, 1, 'two', 3.0, array, array]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.unshift(1) }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen array when the array is modified" do
+      lambda { ArraySpecs.frozen_array.unshift(1) }.should raise_error(RuntimeError)
+    end
+
+    # see [ruby-core:23666]
+    it "raises a RuntimeError on a frozen array when the array would not be modified" do
+      lambda { ArraySpecs.frozen_array.unshift    }.should raise_error(RuntimeError)
+    end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "does not raise an exception on a frozen array if no modification takes place" do
+      ArraySpecs.frozen_array.unshift.should == [1, 2, 3]
+    end
+  end
+end

data/spec/core/array/zip_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#zip" do
   it "returns an array of arrays containing corresponding elements of each array" do
     [1, 2, 3, 4].zip(["a", "b", "c", "d", "e"]).should ==
@@ -9,6 +12,34 @@ describe "Array#zip" do
       [[1, "a"], [2, "b"], [3, "c"], [4, "d"], [5, nil]]
   end
 
+  pending "properly handles recursive arrays" do
+    a = []; a << a
+    b = [1]; b << b
+
+    a.zip(a).should == [ [a[0], a[0]] ]
+    a.zip(b).should == [ [a[0], b[0]] ]
+    b.zip(a).should == [ [b[0], a[0]], [b[1], a[1]] ]
+    b.zip(b).should == [ [b[0], b[0]], [b[1], b[1]] ]
+  end
+
+  pending "calls #to_ary to convert the argument to an Array" do
+    obj = mock('[3,4]')
+    obj.should_receive(:to_ary).and_return([3, 4])
+    [1, 2].zip(obj).should == [[1, 3], [2, 4]]
+  end
+
+  ruby_version_is "1.9.2" do
+    it "uses #each to extract arguments' elements when #to_ary fails" do
+      obj = Class.new do
+        def each(&b)
+          [3,4].each(&b)
+        end
+      end.new
+
+      [1, 2].zip(obj).should == [[1, 3], [2, 4]]
+    end
+  end
+
   it "calls block if supplied" do
     values = []
     [1, 2, 3, 4].zip(["a", "b", "c", "d", "e"]) { |value|
@@ -17,4 +48,8 @@ describe "Array#zip" do
 
     values.should == [[1, "a"], [2, "b"], [3, "c"], [4, "d"]]
   end
-end
+
+  it "does not return subclass instance on Array subclasses" do
+    ArraySpecs::MyArray[1, 2, 3].zip(["a", "b"]).should be_kind_of(Array)
+  end
+end

data/spec/core/class/new_spec.rb

@@ -100,12 +100,14 @@ describe "Class#new" do
   end
 
   it "passes the block to #initialize" do
-    klass = Class.new do
-      def initialize(&block)
-        raise "no block given" unless block_given?
+    lambda {
+      klass = Class.new do
+        def initialize(&block)
+          raise "no block given" unless block_given?
+        end
       end
-    end
 
-    klass.new { 42 }
+      klass.new { 42 }
+    }.should_not raise_error(Exception)
   end
-end
+end