opal 0.3.41 → 0.3.42

data/spec/core/array/ntimes_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+# Array#nitems was removed from Ruby 1.9.
+ruby_version_is '' ... '1.9' do
+  describe "Array#nitems" do
+    it "returns the number of non-nil elements" do
+      [nil].nitems.should == 0
+      [].nitems.should == 0
+      [1, 2, 3, nil].nitems.should == 3
+      [1, 2, 3].nitems.should == 3
+      [1, nil, 2, 3, nil, nil, 4].nitems.should == 4
+      [1, nil, 2, false, 3, nil, nil, 4].nitems.should == 5
+    end
+
+    it "properly handles recursive arrays" do
+      empty = ArraySpecs.empty_recursive_array
+      empty.nitems.should == 1
+
+      array = ArraySpecs.recursive_array
+      array.nitems.should == 8
+
+      [nil, empty, array].nitems.should == 2
+    end
+  end
+end

data/spec/core/array/plus_spec.rb

@@ -1,6 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#+" do
   it "concatenates two arrays" do
-    ([ 1, 2, 3 ] + [ 3, 4, 5 ] ).should == [1, 2, 3, 3, 4, 5]
+    ([ 1, 2, 3 ] + [ 3, 4, 5 ]).should == [1, 2, 3, 3, 4, 5]
     ([ 1, 2, 3 ] + []).should == [1, 2, 3]
     ([] + [ 1, 2, 3 ]).should == [1, 2, 3]
     ([] + []).should == []
@@ -10,4 +13,47 @@ describe "Array#+" do
     ary = [1, 2, 3]
     (ary + ary).should == [1, 2, 3, 1, 2, 3]
   end
-end
+
+  pending "tries to convert the passed argument to an Array using #to_ary" do
+    obj = mock('["x", "y"]')
+    obj.should_receive(:to_ary).and_return(["x", "y"])
+    ([1, 2, 3] + obj).should == [1, 2, 3, "x", "y"]
+  end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    (empty + empty).should == [empty, empty]
+
+    array = ArraySpecs.recursive_array
+    (empty + array).should == [empty, 1, 'two', 3.0, array, array, array, array, array]
+    (array + array).should == [
+      1, 'two', 3.0, array, array, array, array, array,
+      1, 'two', 3.0, array, array, array, array, array]
+  end
+
+  it "does return subclass instances with 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] + ArraySpecs::ToAryArray[1, 2]).should == [5, 6, 1, 2]
+  end
+
+  pending "does not get infected even if an original array is tainted" do
+    ([1, 2] + [3, 4]).tainted?.should be_false
+    ([1, 2].taint + [3, 4]).tainted?.should be_false
+    ([1, 2] + [3, 4].taint).tainted?.should be_false
+    ([1, 2].taint + [3, 4].taint).tainted?.should be_false
+  end
+
+  ruby_version_is '1.9' do
+    pending "does not infected even if an original array is untrusted" do
+      ([1, 2] + [3, 4]).untrusted?.should be_false
+      ([1, 2].untrust + [3, 4]).untrusted?.should be_false
+      ([1, 2] + [3, 4].untrust).untrusted?.should be_false
+      ([1, 2].untrust + [3, 4].untrust).untrusted?.should be_false
+    end
+  end
+end

data/spec/core/array/pop_spec.rb

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

data/spec/core/array/push_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#push" do
   it "appends the arguments to the array" do
     a = [ "a", "b", "c" ]
@@ -13,4 +16,29 @@ describe "Array#push" do
     a.push("foo")
     a.should == ["b", "c", "foo"]
   end
-end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.push(:last).should == [empty, :last]
+
+    array = ArraySpecs.recursive_array
+    array.push(:last).should == [1, 'two', 3.0, array, array, array, array, array, :last]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array if modification takes place" do
+      lambda { ArraySpecs.frozen_array.push(1) }.should raise_error(TypeError)
+    end
+
+    it "does not raise on a frozen array if no modification is made" do
+      ArraySpecs.frozen_array.push.should == [1, 2, 3]
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.push(1) }.should raise_error(RuntimeError)
+      lambda { ArraySpecs.frozen_array.push }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/core/array/rassoc_spec.rb

@@ -1,9 +1,38 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Array#rassoc" do
-  it "returns the first contained array whose second element it == object" do
+  it "returns the first contained array whose second element is == object" do
     ary = [[1, "a", 0.5], [2, "b"], [3, "b"], [4, "c"], [], [5], [6, "d"]]
     ary.rassoc("a").should == [1, "a", 0.5]
     ary.rassoc("b").should == [2, "b"]
     ary.rassoc("d").should == [6, "d"]
     ary.rassoc("z").should == nil
   end
-end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.rassoc([]).should be_nil
+    [[empty, empty]].rassoc(empty).should == [empty, empty]
+
+    array = ArraySpecs.recursive_array
+    array.rassoc(array).should be_nil
+    [[empty, array]].rassoc(array).should == [empty, array]
+  end
+
+  pending "calls elem == obj on the second element of each contained array" do
+    key = 'foobar'
+    o = mock('foobar')
+    def o.==(other); other == 'foobar'; end
+
+    [[1, :foobar], [2, o], [3, mock('foo')]].rassoc(key).should == [2, o]
+  end
+
+  pending "does not check the last element in each contained but speficically the second" do
+    key = 'foobar'
+    o = mock('foobar')
+    def o.==(other); other == 'foobar'; end
+
+    [[1, :foobar, o], [2, o, 1], [3, mock('foo')]].rassoc(key).should == [2, o, 1]
+  end
+end

data/spec/core/array/reject_spec.rb

@@ -1,3 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/enumeratorize', __FILE__)
+
 describe "Array#reject" do
   it "returns a new array without elements for which block is true" do
     ary = [1, 2, 3, 4, 5]
@@ -6,6 +10,7 @@ describe "Array#reject" do
     ary.reject { false }.object_id.should_not == ary.object_id
     ary.reject { nil }.should == ary
     ary.reject { nil }.object_id.should_not == ary.object_id
+    ary.reject { 5 }.should == []
     ary.reject { |i| i < 3 }.should == [3, 4, 5]
     ary.reject { |i| i % 2 == 0 }.should == [1, 3, 5]
   end
@@ -15,6 +20,46 @@ describe "Array#reject" do
     array.shift
     array.reject { |x| true }.should == []
   end
+
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty.reject { false }.should == [empty]
+    empty.reject { true }.should == []
+
+    array = ArraySpecs.recursive_array
+    array.reject { false }.should == [1, 'two', 3.0, array, array, array, array, array]
+    array.reject { true }.should == []
+  end
+
+  ruby_version_is "" ... "1.9.3" do
+    not_compliant_on :ironruby do
+      it "returns subclass instance on Array subclasses" do
+        ArraySpecs::MyArray[1, 2, 3].reject { |x| x % 2 == 0 }.should be_kind_of(ArraySpecs::MyArray)
+      end
+    end if false
+
+    deviates_on :ironruby do
+      it "does not return subclass instance on Array subclasses" do
+        ArraySpecs::MyArray[1, 2, 3].reject { |x| x % 2 == 0 }.should be_kind_of(Array)
+      end
+    end if false
+  end
+
+  ruby_version_is "1.9.3" do
+    it "does not return subclass instance on Array subclasses" do
+      ArraySpecs::MyArray[1, 2, 3].reject { |x| x % 2 == 0 }.should be_kind_of(Array)
+    end
+
+    it "does not retain instance variables" do
+      array = []
+      array.instance_variable_set("@variable", "value")
+      array.reject { false }.instance_variable_get("@variable").should == nil
+    end
+  end
+
+  pending do
+    it_behaves_like :enumeratorize, :reject
+  end
 end
 
 describe "Array#reject!" do
@@ -34,7 +79,27 @@ describe "Array#reject!" do
     a.should == []
   end
 
-  it "returns nil when called on an array emptied with #shift" do
+  pending "properly handles recursive arrays" do
+    empty = ArraySpecs.empty_recursive_array
+    empty_dup = empty.dup
+    empty.reject! { false }.should == nil
+    empty.should == empty_dup
+
+    empty = ArraySpecs.empty_recursive_array
+    empty.reject! { true }.should == []
+    empty.should == []
+
+    array = ArraySpecs.recursive_array
+    array_dup = array.dup
+    array.reject! { false }.should == nil
+    array.should == array_dup
+
+    array = ArraySpecs.recursive_array
+    array.reject! { true }.should == []
+    array.should == []
+  end
+
+  it "returns nil when called on an Array emptied with #shift" do
     array = [1]
     array.shift
     array.reject! { |x| true }.should == nil
@@ -48,4 +113,26 @@ describe "Array#reject!" do
     a.reject! { true }
     a.reject! { true }.should == nil
   end
-end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.reject! {} }.should raise_error(TypeError)
+    end
+    it "raises a TypeError on an empty frozen array" do
+      lambda { ArraySpecs.empty_frozen_array.reject! {} }.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.reject! {} }.should raise_error(RuntimeError)
+    end
+    it "raises a RuntimeError on an empty frozen array" do
+      lambda { ArraySpecs.empty_frozen_array.reject! {} }.should raise_error(RuntimeError)
+    end
+  end
+
+  pending do
+    it_behaves_like :enumeratorize, :reject!
+  end
+end