opal 0.3.41 → 0.3.42

data/spec/language/and_spec.rb

@@ -1,23 +1,27 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
 describe "The '&&' statement" do
+
   it "short-circuits evaluation at the first condition to be false" do
     x = nil
     true && false && x = 1
     x.should be_nil
   end
 
-  it "evaluates to the first condition not to be true" do
+  it "evalutes to the first condition not to be true" do
     ("yes" && 1 && nil && true).should == nil
     ("yes" && 1 && false && true).should == false
   end
 
-  it "evaluates to the last condition if all are true" do
+  it "evalutes to the last condition if all are true" do
     ("yes" && 1).should == 1
     (1 && "yes").should == "yes"
   end
 
   it "evaluates the full set of chained conditions during assignment" do
-    x = y = nil
+    x, y = nil
     x = 1 && y = 2
+    # "1 && y = 2" is evaluated and then assigned to x
     x.should == 2
   end
 
@@ -26,6 +30,7 @@ describe "The '&&' statement" do
     (true && ()).should be_nil
     (() && ()).should be_nil
   end
+
 end
 
 describe "The 'and' statement" do
@@ -35,19 +40,20 @@ describe "The 'and' statement" do
     x.should be_nil
   end
 
-  it "evaluates to the first condition not to be true" do
+  it "evalutes to the first condition not to be true" do
     ("yes" and 1 and nil and true).should == nil
     ("yes" and 1 and false and true).should == false
   end
 
-  it "evaluates to the last condition if all are true" do
+  it "evalutes to the last condition if all are true" do
     ("yes" and 1).should == 1
     (1 and "yes").should == "yes"
   end
 
   it "when used in assignment, evaluates and assigns expressions individually" do
-    x = y = nil
+    x, y = nil
     x = 1 and y = 2
+    # evaluates (x=1) and (y=2)
     x.should == 1
   end
 
@@ -56,4 +62,5 @@ describe "The 'and' statement" do
     (true and ()).should be_nil
     (() and ()).should be_nil
   end
-end
+
+end

data/spec/language/array_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/array', __FILE__)
+
 describe "Array literals" do
   it "[] should return a new array populated with the given elements" do
     array = [1, 'a', nil]
@@ -22,7 +25,7 @@ describe "Array literals" do
   end
 end
 
-describe "Barewood array literal" do
+describe "Bareword array literal" do
   it "%w() transforms unquoted barewords into an array" do
     a = 3
     %w(a #{3+a} 3).should == ["a", '#{3+a}', "3"]
@@ -40,7 +43,7 @@ describe "Barewood array literal" do
 
   it "treats consecutive whitespace characters the same as one" do
     %w(a  b c  d).should == ["a", "b", "c", "d"]
-    %w(hello
+    %W(hello
        world).should == ["hello", "world"]
   end
 
@@ -54,12 +57,61 @@ c d).should == ["a", "b\nc", "d"]
 end
 
 describe "The unpacking splat operator (*)" do
-  it "when applied to a literal nested array, unpacks its elements into then containing array" do
+  it "when applied to a literal nested array, unpacks its elements into the containing array" do
     [1, 2, *[3, 4, 5]].should == [1, 2, 3, 4, 5]
   end
 
-  it "when applied to a nested references array, unpacks its elements into the containing array" do
+  it "when applied to a nested referenced array, unpacks its elements into the containing array" do
     splatted_array = [3, 4, 5]
     [1, 2, *splatted_array].should == [1, 2, 3, 4, 5]
   end
-end
+
+  ruby_bug "#5124", "1.9.3.194" do
+    pending "returns a new array containing the same values when applied to an array inside an empty array" do
+      splatted_array = [3, 4, 5]
+      [*splatted_array].should == splatted_array
+      [*splatted_array].should_not equal(splatted_array)
+    end
+  end
+
+  pending "unpacks the start and count arguments in an array slice assignment" do
+    alphabet_1 = ['a'..'z'].to_a
+    alphabet_2 = alphabet_1.dup
+    start_and_count_args = [1, 10]
+
+    alphabet_1[1, 10] = 'a'
+    alphabet_2[*start_and_count_args] = 'a'
+
+    alphabet_1.should == alphabet_2
+  end
+
+  pending "unpacks arguments as if they were listed statically" do
+    static = [1,2,3,4]
+    receiver = static.dup
+    args = [0,1]
+    static[0,1] = []
+    static.should == [2,3,4]
+    receiver[*args] = []
+    receiver.should == static
+  end
+
+  it "unpacks a literal array into arguments in a method call" do
+    tester = ArraySpec::Splat.new
+    tester.unpack_3args(*[1, 2, 3]).should == [1, 2, 3]
+    tester.unpack_4args(1, 2, *[3, 4]).should == [1, 2, 3, 4]
+    tester.unpack_4args("a", %w(b c), *%w(d e)).should == ["a", ["b", "c"], "d", "e"]
+  end
+
+  it "unpacks a referenced array into arguments in a method call" do
+    args = [1, 2, 3]
+    tester = ArraySpec::Splat.new
+    tester.unpack_3args(*args).should == [1, 2, 3]
+    tester.unpack_4args(0, *args).should == [0, 1, 2, 3]
+  end
+end
+
+describe "The packing splat operator (*)" do
+
+end
+
+# language_version __FILE__, "array"

data/spec/language/block_spec.rb

@@ -1,22 +1,5 @@
-module BlockSpecs
-  class Yielder
-    def z
-      yield
-    end
-
-    def m(*a)
-      yield(*a)
-    end
-
-    def s(a)
-      yield(a)
-    end
-
-    def r(a)
-      yield(*a)
-    end
-  end
-end
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/block', __FILE__)
 
 describe "A block" do
   before :each do
@@ -28,17 +11,33 @@ describe "A block" do
     @y.z { var }.should == 1
   end
 
-  it "does not capture a local when an argument has the same name" do
-    var = 1
-    @y.s(2) { |var| var }.should == 2
-    var.should == 1
+  pending "allows for a leading space before the arguments" do
+    # res = @y.s (:a){ 1 }
+    # res.should == 1
   end
 
-  describe "taking zero arguments" do
-    before :each do
-      @y = BlockSpecs::Yielder.new
+  pending "allows to define a block variable with the same name as the enclosing block" do
+    o = BlockSpecs::OverwriteBlockVariable.new
+    o.z { 1 }.should == 1
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "overwrites a captured local when used as an argument" do
+      var = 1
+      @y.s(2) { |var| var }.should == 2
+      var.should == 2
     end
+  end
 
+  ruby_version_is "1.9" do
+    it "does not capture a local when an argument has the same name" do
+      var = 1
+      @y.s(2) { |var| var }.should == 2
+      var.should == 1
+    end
+  end
+
+  describe "taking zero arguments" do
     it "does not raise an exception when no values are yielded" do
       @y.z { 1 }.should == 1
     end
@@ -49,10 +48,6 @@ describe "A block" do
   end
 
   describe "taking || arguments" do
-    before :each do
-      @y = BlockSpecs::Yielder.new
-    end
-
     it "does not raise an exception when no values are yielded" do
       @y.z { || 1 }.should == 1
     end
@@ -63,10 +58,6 @@ describe "A block" do
   end
 
   describe "taking |a| arguments" do
-    before :each do
-      @y = BlockSpecs::Yielder.new
-    end
-
     it "assigns nil to the argument when no values are yielded" do
       @y.z { |a| a }.should be_nil
     end
@@ -75,21 +66,32 @@ describe "A block" do
       @y.s(1) { |a| a }.should == 1
     end
 
-    it "assigns the first value yielded to the argument" do
-      @y.m(1, 2) { |a| a }.should == 1
+    pending "does not call #to_ary to convert a single yielded object to an Array" do
+      obj = mock("block yield to_ary")
+      obj.should_not_receive(:to_ary)
+
+      @y.s(obj) { |a| a }.should equal(obj)
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "assigns all the values yielded to the argument as an Array" do
+        @y.m(1, 2) { |a| a }.should == [1, 2]
+      end
+    end
+
+    ruby_version_is "1.9" do
+      it "assigns the first value yielded to the argument" do
+        @y.m(1, 2) { |a| a }.should == 1
+      end
     end
 
-    it "does not deconstruct a single Array value" do
+    it "does not destructure a single Array value" do
       @y.s([1, 2]) { |a| a }.should == [1, 2]
     end
   end
 
   describe "taking |a, b| arguments" do
-    before :each do
-      @y = BlockSpecs::Yielder.new
-    end
-
-    it "assigns nil to the arguments when no values are yielded" do
+    it "assgins nil to the arguments when no values are yielded" do
       @y.z { |a, b| [a, b] }.should == [nil, nil]
     end
 
@@ -101,22 +103,437 @@ describe "A block" do
       @y.m(1, 2, 3) { |a, b| [a, b] }.should == [1, 2]
     end
 
-    it "does not destructive an Array value as one of the several values yielded" do
+    it "does not destructure an Array value as one of several values yielded" do
       @y.m([1, 2], 3, 4) { |a, b| [a, b] }.should == [[1, 2], 3]
     end
-  end
 
-  describe "taking |a, *b| arguments" do
-    before :each do
-      @y = BlockSpecs::Yielder.new
+    pending "assigns 'nil' and 'nil' to the arguments when a single, empty Array is yielded" do
+      @y.s([]) { |a, b| [a, b] }.should == [nil, nil]
+    end
+
+    pending "assigns the element of a single element Array to the first argument" do
+      @y.s([1]) { |a, b| [a, b] }.should == [1, nil]
+      @y.s([nil]) { |a, b| [a, b] }.should == [nil, nil]
+      @y.s([[]]) { |a, b| [a, b] }.should == [[], nil]
+    end
+
+    pending "destructures a single Array value yielded" do
+      @y.s([1, 2, 3]) { |a, b| [a, b] }.should == [1, 2]
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "does not destructure a splatted Array" do
+        @y.r([[]]) { |a, b| [a, b] }.should == [[], nil]
+        @y.r([[1]]) { |a, b| [a, b] }.should == [[1], nil]
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "destructures a splatted Array" do
+        @y.r([[]]) { |a, b| [a, b] }.should == [nil, nil]
+        @y.r([[1]]) { |a, b| [a, b] }.should == [1, nil]
+      end
+    end
+
+    pending "calls #to_ary to convert a single yielded object to an Array" do
+      obj = mock("block yield to_ary")
+      obj.should_receive(:to_ary).and_return([1, 2])
+
+      @y.s(obj) { |a, b| [a, b] }.should == [1, 2]
     end
 
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      @y.s(obj) { |a, b| [a, b] }.should == [1, 2]
+    end
+
+    it "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      @y.s(obj) { |a, b| [a, b] }.should == [obj, nil]
+    end
+
+    pending "raises an TypeError if #to_ary does not return an Array" do
+      obj = mock("block yield to_ary invalid")
+      obj.should_receive(:to_ary).and_return(1)
+
+      lambda { @y.s(obj) { |a, b| } }.should raise_error(TypeError)
+    end
+  end
+
+  describe "taking |a, *b| arguments" do
     it "assigns 'nil' and '[]' to the arguments when no values are yielded" do
       @y.z { |a, *b| [a, b] }.should == [nil, []]
     end
 
-    it "assigns all yielded values after the first to the rest arguments" do
+    it "assigns all yielded values after the first to the rest argument" do
       @y.m(1, 2, 3) { |a, *b| [a, b] }.should == [1, [2, 3]]
     end
+
+    pending "assigns 'nil' and '[]' to the arguments when a single, empty Array is yielded" do
+      @y.s([]) { |a, *b| [a, b] }.should == [nil, []]
+    end
+
+    pending "assigns the element of a single element Array to the first argument" do
+      @y.s([1]) { |a, *b| [a, b] }.should == [1, []]
+      @y.s([nil]) { |a, *b| [a, b] }.should == [nil, []]
+      @y.s([[]]) { |a, *b| [a, b] }.should == [[], []]
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "does not destructure a splatted Array" do
+        @y.r([[]]) { |a, *b| [a, b] }.should == [[], []]
+        @y.r([[1]]) { |a, *b| [a, b] }.should == [[1], []]
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "destructures a splatted Array" do
+        @y.r([[]]) { |a, *b| [a, b] }.should == [nil, []]
+        @y.r([[1]]) { |a, *b| [a, b] }.should == [1, []]
+      end
+    end
+
+    pending "destructures a single Array value assigning the remaining values to the rest argument" do
+      @y.s([1, 2, 3]) { |a, *b| [a, b] }.should == [1, [2, 3]]
+    end
+
+    pending "calls #to_ary to convert a single yielded object to an Array" do
+      obj = mock("block yield to_ary")
+      obj.should_receive(:to_ary).and_return([1, 2])
+
+      @y.s(obj) { |a, *b| [a, b] }.should == [1, [2]]
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      @y.s(obj) { |a, *b| [a, b] }.should == [1, [2]]
+    end
+
+    it "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      @y.s(obj) { |a, *b| [a, b] }.should == [obj, []]
+    end
+
+    pending "raises an TypeError if #to_ary does not return an Array" do
+      obj = mock("block yield to_ary invalid")
+      obj.should_receive(:to_ary).and_return(1)
+
+      lambda { @y.s(obj) { |a, *b| } }.should raise_error(TypeError)
+    end
+  end
+
+  describe "taking |*| arguments" do
+    pending "does not raise an exception when no values are yielded" do
+      # @y.z { |*| 1 }.should == 1
+    end
+
+    pending "does not raise an exception when values are yielded" do
+      # @y.s(0) { |*| 1 }.should == 1
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      # @y.s(obj) { |*| 1 }.should == 1
+    end
+
+    pending "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      # @y.s(obj) { |*| 1 }.should == 1
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "calls #to_ary to convert a single yielded object to an Array" do
+        obj = mock("block yield to_ary")
+        obj.should_receive(:to_ary).and_return([1, 2])
+
+        # @y.s(obj) { |*| 1 }.should == 1
+      end
+
+      pending "does not raise a TypeError if #to_ary returns nil" do
+        obj = mock("block yield to_ary nil")
+        obj.should_receive(:to_ary).and_return(nil)
+
+        # @y.s(obj) { |*o| o }.should == [obj]
+      end
+
+      pending "raises an TypeError if #to_ary does not return an Array" do
+        obj = mock("block yield to_ary invalid")
+        obj.should_receive(:to_ary).and_return(1)
+
+        # lambda { @y.s(obj) { |*| } }.should raise_error(TypeError)
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "does not call #to_ary to convert a single yielded object to an Array" do
+        obj = mock("block yield to_ary")
+        obj.should_not_receive(:to_ary)
+
+        # @y.s(obj) { |*| 1 }.should == 1
+      end
+    end
+  end
+
+  describe "taking |*a| arguments" do
+    it "assigns '[]' to the argument when no values are yielded" do
+      @y.z { |*a| a }.should == []
+    end
+
+    it "assigns a single value yielded to the argument as an Array" do
+      @y.s(1) { |*a| a }.should == [1]
+    end
+
+    it "assigns all the values passed to the argument as an Array" do
+      @y.m(1, 2, 3) { |*a| a }.should == [1, 2, 3]
+    end
+
+    it "assigns '[[]]' to the argument when passed an empty Array" do
+      @y.s([]) { |*a| a }.should == [[]]
+    end
+
+    it "assigns a single Array value passed to the argument by wrapping it in an Array" do
+      @y.s([1, 2, 3]) { |*a| a }.should == [[1, 2, 3]]
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      @y.s(obj) { |*a| a }.should == [[1, 2]]
+    end
+
+    it "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      @y.s(obj) { |*a| a }.should == [obj]
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "calls #to_ary to convert a single yielded object to an Array" do
+        obj = mock("block yield to_ary")
+        obj.should_receive(:to_ary).and_return([1, 2])
+
+        @y.s(obj) { |*a| a }.should == [obj]
+      end
+
+      it "raises an TypeError if #to_ary does not return an Array" do
+        obj = mock("block yield to_ary invalid")
+        obj.should_receive(:to_ary).and_return(1)
+
+        lambda { @y.s(obj) { |*a| } }.should raise_error(TypeError)
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "does not call #to_ary to convert a single yielded object to an Array" do
+        obj = mock("block yield to_ary")
+        obj.should_not_receive(:to_ary)
+
+        @y.s(obj) { |*a| a }.should == [obj]
+      end
+    end
+  end
+
+  describe "taking |a, | arguments" do
+    pending "assigns nil to the argument when no values are yielded" do
+      # @y.z { |a, | a }.should be_nil
+    end
+
+    pending "assgins the argument a single value yielded" do
+      # @y.s(1) { |a, | a }.should == 1
+    end
+
+    pending "assigns the argument the first value yielded" do
+      # @y.m(1, 2) { |a, | a }.should == 1
+    end
+
+    pending "assigns the argument the first of several values yielded when it is an Array" do
+      # @y.m([1, 2], 3) { |a, | a }.should == [1, 2]
+    end
+
+    pending "assigns nil to the argument when passed an empty Array" do
+      # @y.s([]) { |a, | a }.should be_nil
+    end
+
+    pending "assigns the argument the first element of the Array when passed a single Array" do
+      # @y.s([1, 2]) { |a, | a }.should == 1
+    end
+
+    pending "calls #to_ary to convert a single yielded object to an Array" do
+      # obj = mock("block yield to_ary")
+      # obj.should_receive(:to_ary).and_return([1, 2])
+
+      # @y.s(obj) { |a, | a }.should == 1
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      # obj = [1, 2]
+      # obj.should_not_receive(:to_ary)
+
+      # @y.s(obj) { |a, | a }.should == 1
+    end
+
+    pending "does not call #to_ary if the object does not respond to #to_ary" do
+      # obj = mock("block yield no to_ary")
+
+      # @y.s(obj) { |a, | a }.should == obj
+    end
+
+    pending "raises an TypeError if #to_ary does not return an Array" do
+      # obj = mock("block yield to_ary invalid")
+      # obj.should_receive(:to_ary).and_return(1)
+
+      # lambda { @y.s(obj) { |a, | } }.should raise_error(TypeError)
+    end
+  end
+
+  describe "taking |(a, b)| arguments" do
+    pending "assigns nil to the arguments when yielded no values" do
+      # @y.z { |(a, b)| [a, b] }.should == [nil, nil]
+    end
+
+    pending "destructures a single Array value yielded" do
+      # @y.s([1, 2]) { |(a, b)| [a, b] }.should == [1, 2]
+    end
+
+    pending "calls #to_ary to convert a single yielded object to an Array" do
+      obj = mock("block yield to_ary")
+      obj.should_receive(:to_ary).and_return([1, 2])
+
+      # @y.s(obj) { |(a, b)| [a, b] }.should == [1, 2]
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      # @y.s(obj) { |(a, b)| [a, b] }.should == [1, 2]
+    end
+
+    pending "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      # @y.s(obj) { |(a, b)| [a, b] }.should == [obj, nil]
+    end
+
+    pending "raises an TypeError if #to_ary does not return an Array" do
+      obj = mock("block yield to_ary invalid")
+      obj.should_receive(:to_ary).and_return(1)
+
+      # lambda { @y.s(obj) { |(a, b)| } }.should raise_error(TypeError)
+    end
   end
-end
+
+  describe "taking |(a, b), c| arguments" do
+    pending "assigns nil to the arguments when yielded no values" do
+      # @y.z { |(a, b), c| [a, b, c] }.should == [nil, nil, nil]
+    end
+
+    pending "destructures a single one-level Array value yielded" do
+      # @y.s([1, 2]) { |(a, b), c| [a, b, c] }.should == [1, nil, 2]
+    end
+
+    pending "destructures a single multi-level Array value yielded" do
+      # @y.s([[1, 2, 3], 4]) { |(a, b), c| [a, b, c] }.should == [1, 2, 4]
+    end
+
+    pending "calls #to_ary to convert a single yielded object to an Array" do
+      obj = mock("block yield to_ary")
+      obj.should_receive(:to_ary).and_return([1, 2])
+
+      # @y.s(obj) { |(a, b), c| [a, b, c] }.should == [1, nil, 2]
+    end
+
+    pending "does not call #to_ary if the single yielded object is an Array" do
+      obj = [1, 2]
+      obj.should_not_receive(:to_ary)
+
+      # @y.s(obj) { |(a, b), c| [a, b, c] }.should == [1, nil, 2]
+    end
+
+    pending "does not call #to_ary if the object does not respond to #to_ary" do
+      obj = mock("block yield no to_ary")
+
+      # @y.s(obj) { |(a, b), c| [a, b, c] }.should == [obj, nil, nil]
+    end
+
+    pending "raises an TypeError if #to_ary does not return an Array" do
+      obj = mock("block yield to_ary invalid")
+      obj.should_receive(:to_ary).and_return(1)
+
+      # lambda { @y.s(obj) { |(a, b), c| } }.should raise_error(TypeError)
+    end
+  end
+
+  describe "taking nested |a, (b, (c, d))|" do
+    pending "assigns nil to the arguments when yielded no values" do
+      # @y.m { |a, (b, (c, d))| [a, b, c, d] }.should == [nil, nil, nil, nil]
+    end
+
+    pending "destructures separate yielded values" do
+      # @y.m(1, 2) { |a, (b, (c, d))| [a, b, c, d] }.should == [1, 2, nil, nil]
+    end
+
+    pending "destructures a single multi-level Array value yielded" do
+      # @y.m(1, [2, 3]) { |a, (b, (c, d))| [a, b, c, d] }.should == [1, 2, 3, nil]
+    end
+
+    pending "destructures a single multi-level Array value yielded" do
+      # @y.m(1, [2, [3, 4]]) { |a, (b, (c, d))| [a, b, c, d] }.should == [1, 2, 3, 4]
+    end
+  end
+
+  describe "taking nested |a, ((b, c), d)|" do
+    pending "assigns nil to the arguments when yielded no values" do
+      # @y.m { |a, ((b, c), d)| [a, b, c, d] }.should == [nil, nil, nil, nil]
+    end
+
+    pending "destructures separate yielded values" do
+      # @y.m(1, 2) { |a, ((b, c), d)| [a, b, c, d] }.should == [1, 2, nil, nil]
+    end
+
+    pending "destructures a single multi-level Array value yielded" do
+      # @y.m(1, [2, 3]) { |a, ((b, c), d)| [a, b, c, d] }.should == [1, 2, nil, 3]
+    end
+
+    pending "destructures a single multi-level Array value yielded" do
+      # @y.m(1, [[2, 3], 4]) { |a, ((b, c), d)| [a, b, c, d] }.should == [1, 2, 3, 4]
+    end
+  end
+
+  describe "arguments with _" do
+
+    ruby_version_is ""..."1.9" do
+      it "extracts arguments with _" do
+        # @y.m([[1, 2, 3], 4]) { |(_, a, _), _| a }.should == 4
+      end
+
+      it "assigns the last variable named" do
+        # @y.m(1, 2) { |_, _| _ }.should == 2
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "extracts arguments with _" do
+        # @y.m([[1, 2, 3], 4]) { |(_, a, _), _| a }.should == 2
+      end
+
+      pending "assigns the first variable named" do
+        # @y.m(1, 2) { |_, _| _ }.should == 1
+      end
+    end
+
+  end
+
+end
+
+# language_version __FILE__, "block"