opal 0.10.6 → 0.11.0.rc1

data/spec/opal/core/language/proc_spec.rb

@@ -1,263 +0,0 @@
-describe "A Proc" do
-  it "captures locals from the surrounding scope" do
-    var = 1
-    lambda { var }.call.should == 1
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "overwrites a captured local when used as an argument" do
-      var = 1
-      lambda { |var| var }.call(2).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
-      lambda { |var| var }.call(2).should == 2
-      var.should == 1
-    end
-  end
-
-  describe "taking zero arguments" do
-    before :each do
-      @l = lambda { 1 }
-    end
-
-    it "does not raise an exception if no values are passed" do
-      @l.call.should == 1
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "does not raise an exception if a value is passed" do
-        @l.call(0).should == 1
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "raises an ArgumentErro if a value is passed" do
-        lambda { @l.call(0) }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "taking || arguments" do
-    before :each do
-      @l = lambda { || 1 }
-    end
-
-    it "does not raise an exception when passed no values" do
-      @l.call.should == 1
-    end
-
-    it "raises an ArgumentError if a value is passed" do
-      lambda { @l.call(0) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "taking |a| arguments" do
-    before :each do
-      @l = lambda { |a| a }
-    end
-
-    it "assigns the value passed to the argument" do
-      @l.call(2).should == 2
-    end
-
-    it "does not destructure a single Array value" do
-      @l.call([1, 2]).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should equal(obj)
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "assigns nil to the argument if no value is passed" do
-        @l.call.should be_nil
-      end
-
-      it "assigns all the values passed to the argument as an Array" do
-        @l.call(1, 2).should == [1, 2]
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "raises an ArgumentError if no value is passed" do
-        lambda { @l.call }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "taking |a, b| arguments" do
-    before :each do
-      @l = lambda { |a, b| [a, b] }
-    end
-
-    it "raises an ArgumentError if passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if passed one value" do
-      lambda { @l.call(0) }.should raise_error(ArgumentError)
-    end
-
-    it "assigns the values passed to the arguments" do
-      @l.call(1, 2).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("proc call to_ary")
-      obj.should_not_receive(:to_ary)
-
-      lambda { @l.call(obj) }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "taking |a, *b| arguments" do
-    before :each do
-      @l = lambda { |a, *b| [a, b] }
-    end
-
-    it "raises an ArgumentError if passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "does not destructure a single Array value yielded" do
-      @l.call([1, 2, 3]).should == [[1, 2, 3], []]
-    end
-
-    it "assigns all passed values after the first to the rest argument" do
-        @l.call(1, 2, 3).should == [1, [2, 3]]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == [obj, []]
-    end
-  end
-
-  describe "taking |*| arguments" do
-    before :each do
-      # @l = lambda { |*| 1 }
-    end
-
-    it "does not raise an exception when passed no values" do
-      @l.call.should == 1
-    end
-
-    it "does not raise an exception when passed multiple values" do
-      @l.call(2, 3, 4).should == 1
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == 1
-    end
-  end
-
-  describe "taking |*a| arguments" do
-    before :each do
-      @l = lambda { |*a| a }
-    end
-
-    it "assigns [] to the argument when passed no values" do
-      @l.call.should == []
-    end
-
-    it "assigns the argument an Array wrapping one passed value" do
-      @l.call(1).should == [1]
-    end
-
-    it "assigns the argument an Array wrapping all values passed" do
-      @l.call(1, 2, 3).should == [1, 2, 3]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == [obj]
-    end
-  end
-
-  describe "taking |a, | arguments" do
-    before :each do
-      # @l = lambda { |a, | a }
-    end
-
-    it "raises an ArgumentError when passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError when passed more than one value" do
-      lambda { @l.call(1, 2) }.should raise_error(ArgumentError)
-    end
-
-    it "assigns the argument the value passed" do
-      @l.call(1).should == 1
-    end
-
-    it "does not destructure when passed a single Array" do
-      @l.call([1,2]).should == [1, 2]
-    end
-
-    it "does not call #to_ary to convert a single passed object to an Array" do
-      obj = mock("block yield to_ary")
-      obj.should_not_receive(:to_ary)
-
-      @l.call(obj).should == obj
-    end
-  end
-
-  describe "taking |(a, b)| arguments" do
-    before :each do
-      # @l = lambda { |(a, b)| [a, b] }
-    end
-
-    it "raises an ArgumentError when passed no values" do
-      lambda { @l.call }.should raise_error(ArgumentError)
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "raises an ArgumentError when passed a single Array" do
-        lambda { @l.call([1, 2]) }.should raise_error(ArgumentError)
-      end
-
-      it "raises an ArgumentError when passed a single object" do
-        obj = mock("block yield to_ary")
-        obj.should_not_receive(:to_ary)
-
-        lambda { @l.call(obj) }.should raise_error(ArgumentError)
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "destructures a single Array value yielded" do
-        @l.call([1, 2]).should == [1, 2]
-      end
-
-      it "calls #to_ary to convert a single passed object to an Array" do
-        obj = mock("block yield to_ary")
-        obj.should_receive(:to_ary).and_return([1, 2])
-
-        @l.call(obj).should == [1, 2]
-      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 { @l.call(obj) }.should raise_error(TypeError)
-      end
-    end
-  end
-end

data/spec/opal/core/language/variables_spec.rb

@@ -1,1366 +0,0 @@
-require File.expand_path('../fixtures/variables', __FILE__)
-
-# TODO: partition these specs into distinct cases based on the
-# real parsed forms, not the superficial code forms.
-describe "Basic assignment" do
-  it "allows the rhs to be assigned to the lhs" do
-    a = nil
-    a.should == nil
-  end
-
-  it "assigns nil to lhs when rhs is an empty expression" do
-    a = ()
-    a.should be_nil
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "assigns nil to lhs when rhs is an empty splat expression" do
-      a = *()
-      a.should be_nil
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "assigns [] to lhs when rhs is an empty splat expression" do
-      a = *()
-      a.should == []
-    end
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "allows the assignment of the rhs to the lhs using the rhs splat operator" do
-      a = *nil;      a.should == nil
-      a = *1;        a.should == 1
-      a = *[];       a.should == nil
-      a = *[1];      a.should == 1
-      a = *[nil];    a.should == nil
-      a = *[[]];     a.should == []
-      a = *[1,2];    a.should == [1,2]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "allows the assignment of the rhs to the lhs using the rhs splat operator" do
-      a = *nil;      a.should == []
-      a = *1;        a.should == [1]
-      a = *[];       a.should == []
-      a = *[1];      a.should == [1]
-      a = *[nil];    a.should == [nil]
-      a = *[[]];     a.should == [[]]
-      a = *[1,2];    a.should == [1,2]
-    end
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "allows the assignment of the rhs to the lhs using the lhs splat operator" do
-      # * = 1,2        # Valid syntax, but pretty useless! Nothing to test
-      *a = nil;      a.should == [nil]
-      *a = 1;        a.should == [1]
-      *a = [];       a.should == [[]]
-      *a = [1];      a.should == [[1]]
-      *a = [1,2];    a.should == [[1,2]]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "allows the assignment of the rhs to the lhs using the lhs splat operator" do
-      # * = 1,2        # Valid syntax, but pretty useless! Nothing to test
-      *a = nil;      a.should == [nil]
-      *a = 1;        a.should == [1]
-      *a = [];       a.should == []
-      *a = [1];      a.should == [1]
-      *a = [1,2];    a.should == [1,2]
-    end
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "allows the assignment of rhs to the lhs using the lhs and rhs splat operators simultaneously" do
-      *a = *nil;      a.should == [nil]
-      *a = *1;        a.should == [1]
-      *a = *[];       a.should == []
-      *a = *[1];      a.should == [1]
-      *a = *[nil];    a.should == [nil]
-      *a = *[1,2];    a.should == [1,2]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "allows the assignment of rhs to the lhs using the lhs and rhs splat operators simultaneously" do
-      *a = *nil;      a.should == []
-      *a = *1;        a.should == [1]
-      *a = *[];       a.should == []
-      *a = *[1];      a.should == [1]
-      *a = *[nil];    a.should == [nil]
-      *a = *[1,2];    a.should == [1,2]
-    end
-  end
-
-  it "sets unavailable values to nil" do
-    ary = []
-    a, b, c = ary
-
-    a.should be_nil
-    b.should be_nil
-    c.should be_nil
-  end
-
-  it "sets the splat to an empty Array if there are no more values" do
-    ary = []
-    a, b, *c = ary
-
-    a.should be_nil
-    b.should be_nil
-    c.should == []
-  end
-
-  it "allows multiple values to be assigned" do
-    a,b,*c = nil;       [a,b,c].should == [nil, nil, []]
-    a,b,*c = 1;         [a,b,c].should == [1, nil, []]
-    a,b,*c = [];        [a,b,c].should == [nil, nil, []]
-    a,b,*c = [1];       [a,b,c].should == [1, nil, []]
-    a,b,*c = [nil];     [a,b,c].should == [nil, nil, []]
-    a,b,*c = [[]];      [a,b,c].should == [[], nil, []]
-    a,b,*c = [1,2];     [a,b,c].should == [1,2,[]]
-
-    a,b,*c = *nil;      [a,b,c].should == [nil, nil, []]
-    a,b,*c = *1;        [a,b,c].should == [1, nil, []]
-    a,b,*c = *[];       [a,b,c].should == [nil, nil, []]
-    a,b,*c = *[1];      [a,b,c].should == [1, nil, []]
-    a,b,*c = *[nil];    [a,b,c].should == [nil, nil, []]
-    a,b,*c = *[[]];     [a,b,c].should == [[], nil, []]
-    a,b,*c = *[1,2];    [a,b,c].should == [1,2,[]]
-  end
-
-  it "calls to_a on the given argument when using a splat" do
-    a,b = *VariablesSpecs::ArrayLike.new([1,2]); [a,b].should == [1,2]
-  end
-
-  it "supports the {|r,| } form of block assignment" do
-    f = lambda {|r,| r.should == []}
-    f.call([], *[])
-
-    f = lambda{|x,| x}
-    f.call(42).should == 42
-    f.call([42]).should == [42]
-    f.call([[42]]).should == [[42]]
-    f.call([42,55]).should == [42,55]
-  end
-
-  it "allows assignment through lambda" do
-    f = lambda {|r,*l| r.should == []; l.should == [1]}
-    f.call([], *[1])
-
-    f = lambda{|x| x}
-    f.call(42).should == 42
-    f.call([42]).should == [42]
-    f.call([[42]]).should == [[42]]
-    f.call([42,55]).should == [42,55]
-
-    f = lambda{|*x| x}
-    f.call(42).should == [42]
-    f.call([42]).should == [[42]]
-    f.call([[42]]).should == [[[42]]]
-    f.call([42,55]).should == [[42,55]]
-    f.call(42,55).should == [42,55]
-  end
-
-  it "allows chained assignment" do
-    (a = 1 + b = 2 + c = 4 + d = 8).should == 15
-    d.should == 8
-    c.should == 12
-    b.should == 14
-    a.should == 15
-  end
-end
-
-describe "Assignment using expansion" do
-  ruby_version_is "" ... "1.9" do
-    it "succeeds without conversion" do
-      *x = (1..7).to_a
-      x.should == [[1, 2, 3, 4, 5, 6, 7]]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "succeeds without conversion" do
-      *x = (1..7).to_a
-      x.should == [1, 2, 3, 4, 5, 6, 7]
-    end
-  end
-end
-
-describe "Basic multiple assignment" do
-  describe "with a single RHS value" do
-    it "does not call #to_ary on an Array instance" do
-      x = [1, 2]
-      x.should_not_receive(:to_ary)
-
-      a, b = x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_a on an Array instance" do
-      x = [1, 2]
-      x.should_not_receive(:to_a)
-
-      a, b = x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_ary on an Array subclass instance" do
-      x = VariablesSpecs::ArraySubclass.new [1, 2]
-      x.should_not_receive(:to_ary)
-
-      a, b = x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_a on an Array subclass instance" do
-      x = VariablesSpecs::ArraySubclass.new [1, 2]
-      x.should_not_receive(:to_a)
-
-      a, b = x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "calls #to_ary on an object" do
-      x = mock("single rhs value for masgn")
-      x.should_receive(:to_ary).and_return([1, 2])
-
-      a, b = x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_a on an object if #to_ary is not defined" do
-      x = mock("single rhs value for masgn")
-      x.should_not_receive(:to_a)
-
-      a, b = x
-      a.should == x
-      b.should be_nil
-    end
-
-    it "does not call #to_a on a String" do
-      x = "one\ntwo"
-
-      a, b = x
-      a.should == x
-      b.should be_nil
-    end
-  end
-
-  describe "with a splatted single RHS value" do
-    it "does not call #to_ary on an Array instance" do
-      x = [1, 2]
-      x.should_not_receive(:to_ary)
-
-      a, b = *x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_a on an Array instance" do
-      x = [1, 2]
-      x.should_not_receive(:to_a)
-
-      a, b = *x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_ary on an Array subclass instance" do
-      x = VariablesSpecs::ArraySubclass.new [1, 2]
-      x.should_not_receive(:to_ary)
-
-      a, b = *x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "does not call #to_a on an Array subclass instance" do
-      x = VariablesSpecs::ArraySubclass.new [1, 2]
-      x.should_not_receive(:to_a)
-
-      a, b = *x
-      a.should == 1
-      b.should == 2
-    end
-
-    it "calls #to_a on an object if #to_ary is not defined" do
-      x = mock("single splatted rhs value for masgn")
-      x.should_receive(:to_a).and_return([1, 2])
-
-      a, b = *x
-      a.should == 1
-      b.should == 2
-    end
-
-    ruby_version_is ""..."1.9" do
-      it "calls #to_ary on an object" do
-        x = mock("single splatted rhs value for masgn")
-        x.should_receive(:to_ary).and_return([1, 2])
-
-        a, b = *x
-        a.should == 1
-        b.should == 2
-      end
-
-      it "calls #to_a on a String" do
-        x = "one\ntwo"
-
-        a, b = *x
-        a.should == "one\n"
-        b.should == "two"
-      end
-    end
-
-    ruby_version_is "1.9" do
-      it "does not call #to_ary on an object" do
-        x = mock("single splatted rhs value for masgn")
-        x.should_not_receive(:to_ary)
-
-        a, b = *x
-        a.should == x
-        b.should be_nil
-      end
-
-      it "does not call #to_a on a String" do
-        x = "one\ntwo"
-
-        a, b = *x
-        a.should == x
-        b.should be_nil
-      end
-    end
-  end
-end
-
-describe "Assigning multiple values" do
-  it "allows parallel assignment" do
-    a, b = 1, 2
-    a.should == 1
-    b.should == 2
-
-    # a, = 1,2
-    a.should == 1
-  end
-
-  it "allows safe parallel swapping" do
-    a, b = 1, 2
-    a, b = b, a
-    a.should == 2
-    b.should == 1
-  end
-
-  not_compliant_on :rubinius do
-    it "returns the rhs values used for assignment as an array" do
-      # x = begin; a, b, c = 1, 2, 3; end
-      x.should == [1,2,3]
-    end
-  end
-
-  ruby_version_is "" ... "1.9" do
-    it "wraps a single value in an Array" do
-      *a = 1
-      a.should == [1]
-
-      b = [1]
-      *a = b
-      a.should == [b]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "wraps a single value in an Array if it's not already one" do
-      *a = 1
-      a.should == [1]
-
-      b = [1]
-      *a = b
-      a.should == b
-    end
-  end
-
-  it "evaluates rhs left-to-right" do
-    a = VariablesSpecs::ParAsgn.new
-    d, e ,f = a.inc, a.inc, a.inc
-    d.should == 1
-    e.should == 2
-    f.should == 3
-  end
-
-  it "supports parallel assignment to lhs args via object.method=" do
-    a = VariablesSpecs::ParAsgn.new
-    a.x, b = 1, 2
-
-    a.x.should == 1
-    b.should == 2
-
-    c = VariablesSpecs::ParAsgn.new
-    c.x, a.x = a.x, b
-
-    c.x.should == 1
-    a.x.should == 2
-  end
-
-  it "supports parallel assignment to lhs args using []=" do
-    a = [1,2,3]
-    a[3], b = 4,5
-
-    a.should == [1,2,3,4]
-    b.should == 5
-  end
-
-  it "bundles remaining values to an array when using the splat operator" do
-    a, *b = 1, 2, 3
-    a.should == 1
-    b.should == [2, 3]
-
-    *a = 1, 2, 3
-    a.should == [1, 2, 3]
-
-    *a = 4
-    a.should == [4]
-
-    *a = nil
-    a.should == [nil]
-
-    a, = *[1]
-    a.should == 1
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "calls #to_ary on rhs arg if rhs has only a single arg" do
-      x = VariablesSpecs::ParAsgn.new
-      a,b,c = x
-      a.should == 1
-      b.should == 2
-      c.should == 3
-
-      a,b,c = x,5
-      a.should == x
-      b.should == 5
-      c.should == nil
-
-      a,b,c = 5,x
-      a.should == 5
-      b.should == x
-      c.should == nil
-
-      a,b,*c = x,5
-      a.should == x
-      b.should == 5
-      c.should == []
-
-      # a,(b,c) = 5,x
-      a.should == 5
-      b.should == 1
-      c.should == 2
-
-      # a,(b,*c) = 5,x
-      a.should == 5
-      b.should == 1
-      c.should == [2,3,4]
-
-      # a,(b,(*c)) = 5,x
-      a.should == 5
-      b.should == 1
-      c.should == [2]
-
-      # a,(b,(*c),(*d)) = 5,x
-      a.should == 5
-      b.should == 1
-      c.should == [2]
-      d.should == [3]
-
-      # a,(b,(*c),(d,*e)) = 5,x
-      a.should == 5
-      b.should == 1
-      c.should == [2]
-      d.should == 3
-      e.should == []
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "calls #to_ary on RHS arg if the corresponding LHS var is a splat" do
-      x = VariablesSpecs::ParAsgn.new
-
-      # a,(*b),c = 5,x
-      a.should == 5
-      b.should == x.to_ary
-      c.should == nil
-    end
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "doen't call #to_ary on RHS arg when the corresponding LHS var is a splat" do
-      x = VariablesSpecs::ParAsgn.new
-
-      # a,(*b),c = 5,x
-      a.should == 5
-      b.should == [x]
-      c.should == nil
-    end
-  end
-
-  it "allows complex parallel assignment" do
-    # a, (b, c), d = 1, [2, 3], 4
-    a.should == 1
-    b.should == 2
-    c.should == 3
-    d.should == 4
-
-    # x, (y, z) = 1, 2, 3
-    [x,y,z].should == [1,2,nil]
-    # x, (y, z) = 1, [2,3]
-    [x,y,z].should == [1,2,3]
-    # x, (y, z) = 1, [2]
-    [x,y,z].should == [1,2,nil]
-
-    # a,(b,c,*d),(e,f),*g = 0,[1,2,3,4],[5,6],7,8
-    a.should == 0
-    b.should == 1
-    c.should == 2
-    d.should == [3,4]
-    e.should == 5
-    f.should == 6
-    g.should == [7,8]
-
-    x = VariablesSpecs::ParAsgn.new
-    # a,(b,c,*d),(e,f),*g = 0,x,[5,6],7,8
-    a.should == 0
-    b.should == 1
-    c.should == 2
-    d.should == [3,4]
-    e.should == 5
-    f.should == 6
-    g.should == [7,8]
-  end
-
-  it "allows a lhs arg to be used in another lhs args parallel assignment" do
-    c = [4,5,6]
-    a,b,c[a] = 1,2,3
-    a.should == 1
-    b.should == 2
-    c.should == [4,3,6]
-
-    c[a],b,a = 7,8,9
-    a.should == 9
-    b.should == 8
-    c.should == [4,7,6]
-  end
-end
-
-describe "Conditional assignment" do
-  it "assigns the lhs if previously unassigned" do
-    a=[]
-    a[0] ||= "bar"
-    a[0].should == "bar"
-
-    h={}
-    h["foo"] ||= "bar"
-    h["foo"].should == "bar"
-
-    h["foo".to_sym] ||= "bar"
-    h["foo".to_sym].should == "bar"
-
-    aa = 5
-    aa ||= 25
-    aa.should == 5
-
-    bb ||= 25
-    bb.should == 25
-
-    cc &&=33
-    cc.should == nil
-
-    cc = 5
-    cc &&=44
-    cc.should == 44
-  end
-
-  it "checks for class variable definition before fetching its value" do
-    class VariableSpecCVarSpec
-      @@cvarspec ||= 5
-      @@cvarspec.should == 5
-    end
-  end
-end
-
-describe "Unconditional operator assignment 'var op= expr'" do
-  it "is equivalent to 'var = var op expr'" do
-    x = 13
-    (x += 5).should == 18
-    x.should == 18
-
-    x = 17
-    (x -= 11).should == 6
-    x.should == 6
-
-    x = 2
-    (x *= 5).should == 10
-    x.should == 10
-
-    x = 36
-    (x /= 9).should == 4
-    x.should == 4
-
-    x = 23
-    (x %= 5).should == 3
-    x.should == 3
-    (x %= 3).should == 0
-    x.should == 0
-
-    x = 2
-    (x **= 3).should == 8
-    x.should == 8
-
-    x = 4
-    (x |= 3).should == 7
-    x.should == 7
-    (x |= 4).should == 7
-    x.should == 7
-
-    x = 6
-    (x &= 3).should == 2
-    x.should == 2
-    (x &= 4).should == 0
-    x.should == 0
-
-    # XOR
-    x = 2
-    (x ^= 3).should == 1
-    x.should == 1
-    (x ^= 4).should == 5
-    x.should == 5
-
-    # Bit-shift left
-    x = 17
-    (x <<= 3).should == 136
-    x.should == 136
-
-    # Bit-shift right
-    x = 5
-    (x >>= 1).should == 2
-    x.should == 2
-  end
-end
-
-describe "Conditional operator assignment 'var op= expr'" do
-  it "assigns the lhs if its truthiness is false for ||, true for &&" do
-    x = nil
-    (x ||= 17).should == 17
-    x.should == 17
-    (x ||= 2).should == 17
-    x.should == 17
-
-    x = false
-    (x &&= true).should == false
-    x.should == false
-    (x &&= false).should == false
-    x.should == false
-    x = true
-    (x &&= true).should == true
-    x.should == true
-    (x &&= false).should == false
-    x.should == false
-  end
-
-  it "may not assign at all, depending on the truthiness of lhs" do
-    Object.new.instance_eval do
-      @falsey = false
-      @truthy = true
-      freeze
-      # lambda{ @truthy ||= 42 }.should_not raise_error
-      # lambda{ @falsey &&= 42 }.should_not raise_error
-    end
-  end
-
-  it "uses short-circuit arg evaluation" do
-    x = 8
-    y = VariablesSpecs::OpAsgn.new
-    (x ||= y.do_side_effect).should == 8
-    y.side_effect.should == nil
-
-    x = nil
-    (x &&= y.do_side_effect).should == nil
-    y.side_effect.should == nil
-
-    y.a = 5
-    (x ||= y.do_side_effect).should == 5
-    y.side_effect.should == true
-  end
-end
-
-describe "Unconditional operator assignment 'obj.meth op= expr'" do
-  it "is equivalent to 'obj.meth = obj.meth op expr'" do
-    @x = VariablesSpecs::OpAsgn.new
-    @x.a = 13
-    (@x.a += 5).should == 18
-    @x.a.should == 18
-
-    @x.a = 17
-    (@x.a -= 11).should == 6
-    @x.a.should == 6
-
-    @x.a = 2
-    (@x.a *= 5).should == 10
-    @x.a.should == 10
-
-    @x.a = 36
-    (@x.a /= 9).should == 4
-    @x.a.should == 4
-
-    @x.a = 23
-    (@x.a %= 5).should == 3
-    @x.a.should == 3
-    (@x.a %= 3).should == 0
-    @x.a.should == 0
-
-    @x.a = 2
-    (@x.a **= 3).should == 8
-    @x.a.should == 8
-
-    @x.a = 4
-    (@x.a |= 3).should == 7
-    @x.a.should == 7
-    (@x.a |= 4).should == 7
-    @x.a.should == 7
-
-    @x.a = 6
-    (@x.a &= 3).should == 2
-    @x.a.should == 2
-    (@x.a &= 4).should == 0
-    @x.a.should == 0
-
-    # XOR
-    @x.a = 2
-    (@x.a ^= 3).should == 1
-    @x.a.should == 1
-    (@x.a ^= 4).should == 5
-    @x.a.should == 5
-
-    @x.a = 17
-    (@x.a <<= 3).should == 136
-    @x.a.should == 136
-
-    @x.a = 5
-    (@x.a >>= 1).should == 2
-    @x.a.should == 2
-  end
-end
-
-describe "Conditional operator assignment 'obj.meth op= expr'" do
-  it "is equivalent to 'obj.meth op obj.meth = expr'" do
-    @x = VariablesSpecs::OpAsgn.new
-    @x.a = nil
-    (@x.a ||= 17).should == 17
-    @x.a.should == 17
-    (@x.a ||= 2).should == 17
-    @x.a.should == 17
-
-    @x.a = false
-    (@x.a &&= true).should == false
-    @x.a.should == false
-    (@x.a &&= false).should == false
-    @x.a.should == false
-    @x.a = true
-    (@x.a &&= true).should == true
-    @x.a.should == true
-    (@x.a &&= false).should == false
-    @x.a.should == false
-  end
-
-  it "may not assign at all, depending on the truthiness of lhs" do
-    m = mock("object")
-    m.should_receive(:foo).and_return(:truthy)
-    m.should_not_receive(:foo=)
-    # m.foo ||= 42
-
-    m.should_receive(:bar).and_return(false)
-    m.should_not_receive(:bar=)
-    # m.bar &&= 42
-  end
-
-  it "uses short-circuit arg evaluation" do
-    x = 8
-    y = VariablesSpecs::OpAsgn.new
-    (x ||= y.do_side_effect).should == 8
-    y.side_effect.should == nil
-
-    x = nil
-    (x &&= y.do_side_effect).should == nil
-    y.side_effect.should == nil
-
-    y.a = 5
-    (x ||= y.do_side_effect).should == 5
-    y.side_effect.should == true
-  end
-end
-
-describe "Operator assignment 'obj.meth op= expr'" do
-  it "evaluates lhs one time" do
-    x = VariablesSpecs::OpAsgn.new
-    x.a = 5
-    (x.do_more_side_effects.a += 5).should == 15
-    x.a.should == 15
-
-    x.a = 5
-    (x.do_more_side_effects.a -= 4).should == 6
-    x.a.should == 6
-
-    x.a = 2
-    (x.do_more_side_effects.a *= 5).should == 35
-    x.a.should == 35
-
-    x.a = 31
-    (x.do_more_side_effects.a /= 9).should == 4
-    x.a.should == 4
-
-    x.a = 18
-    (x.do_more_side_effects.a %= 5).should == 3
-    x.a.should == 3
-
-    x.a = 0
-    (x.do_more_side_effects.a **= 3).should == 125
-    x.a.should == 125
-
-    x.a = -1
-    (x.do_more_side_effects.a |= 3).should == 7
-    x.a.should == 7
-
-    x.a = 1
-    (x.do_more_side_effects.a &= 3).should == 2
-    x.a.should == 2
-
-    # XOR
-    x.a = -3
-    (x.do_more_side_effects.a ^= 3).should == 1
-    x.a.should == 1
-
-    x.a = 12
-    (x.do_more_side_effects.a <<= 3).should == 136
-    x.a.should == 136
-
-    x.a = 0
-    (x.do_more_side_effects.a >>= 1).should == 2
-    x.a.should == 2
-
-    x.a = nil
-    x.b = 0
-    (x.do_bool_side_effects.a ||= 17).should == 17
-    x.a.should == 17
-    x.b.should == 1
-
-    x.a = false
-    x.b = 0
-    (x.do_bool_side_effects.a &&= true).should == false
-    x.a.should == false
-    x.b.should == 1
-    (x.do_bool_side_effects.a &&= false).should == false
-    x.a.should == false
-    x.b.should == 2
-    x.a = true
-    x.b = 0
-    (x.do_bool_side_effects.a &&= true).should == true
-    x.a.should == true
-    x.b.should == 1
-    (x.do_bool_side_effects.a &&= false).should == false
-    x.a.should == false
-    x.b.should == 2
-  end
-end
-
-describe "Unconditional operator assignment 'obj[idx] op= expr'" do
-  it "is equivalent to 'obj[idx] = obj[idx] op expr'" do
-    # x = [2,13,7]
-    # (x[1] += 5).should == 18
-    # x.should == [2,18,7]
-
-    # x = [17,6]
-    # (x[0] -= 11).should == 6
-    # x.should == [6,6]
-
-    # x = [nil,2,28]
-    # (x[2] *= 2).should == 56
-    # x.should == [nil,2,56]
-
-    # x = [3,9,36]
-    # (x[2] /= x[1]).should == 4
-    # x.should == [3,9,4]
-
-    # x = [23,4]
-    # (x[0] %= 5).should == 3
-    # x.should == [3,4]
-    # (x[0] %= 3).should == 0
-    # x.should == [0,4]
-
-    # x = [1,2,3]
-    # (x[1] **= 3).should == 8
-    # x.should == [1,8,3]
-
-    # x = [4,5,nil]
-    # (x[0] |= 3).should == 7
-    # x.should == [7,5,nil]
-    # (x[0] |= 4).should == 7
-    # x.should == [7,5,nil]
-
-    # x = [3,6,9]
-    # (x[1] &= 3).should == 2
-    # x.should == [3,2,9]
-    # (x[1] &= 4).should == 0
-    # x.should == [3,0,9]
-
-    # # XOR
-    # x = [0,1,2]
-    # (x[2] ^= 3).should == 1
-    # x.should == [0,1,1]
-    # (x[2] ^= 4).should == 5
-    # x.should == [0,1,5]
-
-    # x = [17]
-    # (x[0] <<= 3).should == 136
-    # x.should == [136]
-
-    # x = [nil,5,8]
-    # (x[1] >>= 1).should == 2
-    # x.should == [nil,2,8]
-  end
-end
-
-describe "Conditional operator assignment 'obj[idx] op= expr'" do
-  it "is equivalent to 'obj[idx] op obj[idx] = expr'" do
-    # x = [1,nil,12]
-    # (x[1] ||= 17).should == 17
-    # x.should == [1,17,12]
-    # (x[1] ||= 2).should == 17
-    # x.should == [1,17,12]
-
-    # x = [true, false, false]
-    # (x[1] &&= true).should == false
-    # x.should == [true, false, false]
-    # (x[1] &&= false).should == false
-    # x.should == [true, false, false]
-    # (x[0] &&= true).should == true
-    # x.should == [true, false, false]
-    # (x[0] &&= false).should == false
-    # x.should == [false, false, false]
-  end
-
-  it "may not assign at all, depending on the truthiness of lhs" do
-    # m = mock("object")
-    # m.should_receive(:[]).and_return(:truthy)
-    # m.should_not_receive(:[]=)
-    # m[:foo] ||= 42
-
-    # m = mock("object")
-    # m.should_receive(:[]).and_return(false)
-    # m.should_not_receive(:[]=)
-    # m[:bar] &&= 42
-  end
-
-  it "uses short-circuit arg evaluation" do
-    # x = 8
-    # y = VariablesSpecs::OpAsgn.new
-    # (x ||= y.do_side_effect).should == 8
-    # y.side_effect.should == nil
-
-    # x = nil
-    # (x &&= y.do_side_effect).should == nil
-    # y.side_effect.should == nil
-
-    # y.a = 5
-    # (x ||= y.do_side_effect).should == 5
-    # y.side_effect.should == true
-  end
-end
-
-describe "Operator assignment 'obj[idx] op= expr'" do
-  class ArrayWithDefaultIndex < Array
-    def [](index=nil)
-      super(index || 0)
-    end
-
-    def []=(first_arg, second_arg=nil)
-      if second_arg
-        index = fist_arg
-        value = second_arg
-      else
-        index = 0
-        value = first_arg
-      end
-
-      super(index, value)
-    end
-  end
-
-  it "handles empty index (idx) arguments" do
-#     array = ArrayWithDefaultIndex.new
-#     array << 1
-#     (array[] += 5).should == 6
-  end
-
-  it "handles complex index (idx) arguments" do
-#     x = [1,2,3,4]
-#     (x[0,2] += [5]).should == [1,2,5]
-#     x.should == [1,2,5,3,4]
-#     (x[0,2] += [3,4]).should == [1,2,3,4]
-#     x.should == [1,2,3,4,5,3,4]
-
-#     (x[2..3] += [8]).should == [3,4,8]
-#     x.should == [1,2,3,4,8,5,3,4]
-
-#     y = VariablesSpecs::OpAsgn.new
-#     y.a = 1
-#     (x[y.do_side_effect] *= 2).should == 4
-#     x.should == [1,4,3,4,8,5,3,4]
-
-#     h = {'key1' => 23, 'key2' => 'val'}
-#     (h['key1'] %= 5).should == 3
-#     (h['key2'] += 'ue').should == 'value'
-#     h.should == {'key1' => 3, 'key2' => 'value'}
-  end
-
-  it "handles empty splat index (idx) arguments" do
-#     array = ArrayWithDefaultIndex.new
-#     array << 5
-#     splat_index = []
-
-#     (array[*splat_index] += 5).should == 10
-#     array.should== [10]
-  end
-
-  it "handles single splat index (idx) arguments" do
-#     array = [1,2,3,4]
-#     splat_index = [0]
-
-#     (array[*splat_index] += 5).should == 6
-#     array.should == [6,2,3,4]
-  end
-
-  it "handles multiple splat index (idx) arguments" do
-#     array = [1,2,3,4]
-#     splat_index = [0,2]
-
-#     (array[*splat_index] += [5]).should == [1,2,5]
-#     array.should == [1,2,5,3,4]
-  end
-
-  it "handles splat index (idx) arguments with normal arguments" do
-#     array = [1,2,3,4]
-#     splat_index = [2]
-
-#     (array[0, *splat_index] += [5]).should == [1,2,5]
-#     array.should == [1,2,5,3,4]
-  end
-
-  # This example fails on 1.9 because of bug #2050
-  it "returns result of rhs not result of []=" do
-#     a = VariablesSpecs::Hashalike.new
-
-#     (a[123] =   2).should == 2
-#     (a[123] +=  2).should == 125
-#     (a[123] -=  2).should == 121
-#     (a[123] *=  2).should == 246
-#     # Guard against the Mathn library
-#     # TODO: Make these specs not rely on specific behaviour / result values
-#     # by using mocks.
-#     conflicts_with :Prime do
-#       (a[123] /=  2).should == 61
-#     end
-#     (a[123] %=  2).should == 1
-#     (a[123] **= 2).should == 15129
-#     (a[123] |=  2).should == 123
-#     (a[123] &=  2).should == 2
-#     (a[123] ^=  2).should == 121
-#     (a[123] <<= 2).should == 492
-#     (a[123] >>= 2).should == 30
-#     (a[123] ||= 2).should == 123
-#     (a[nil] ||= 2).should == 2
-#     (a[123] &&= 2).should == 2
-#     (a[nil] &&= 2).should == nil
-  end
-end
-
-describe "Single assignment" do
-  it "Assignment does not modify the lhs, it reassigns its reference" do
-    a = 'Foobar'
-    b = a
-    b = 'Bazquux'
-    a.should == 'Foobar'
-    b.should == 'Bazquux'
-  end
-
-  it "Assignment does not copy the object being assigned, just creates a new reference to it" do
-    a = []
-    b = a
-    b << 1
-    a.should == [1]
-  end
-
-  it "If rhs has multiple arguments, lhs becomes an Array of them" do
-    a = 1, 2, 3
-    a.should == [1, 2, 3]
-
-    a = 1, (), 3
-    a.should == [1, nil, 3]
-  end
-end
-
-describe "Multiple assignment without grouping or splatting" do
-  it "An equal number of arguments on lhs and rhs assigns positionally" do
-    a, b, c, d = 1, 2, 3, 4
-    a.should == 1
-    b.should == 2
-    c.should == 3
-    d.should == 4
-  end
-
-  it "If rhs has too few arguments, the missing ones on lhs are assigned nil" do
-    a, b, c = 1, 2
-    a.should == 1
-    b.should == 2
-    c.should == nil
-  end
-
-  it "If rhs has too many arguments, the extra ones are silently not assigned anywhere" do
-    a, b = 1, 2, 3
-    a.should == 1
-    b.should == 2
-  end
-
-  it "The assignments are done in parallel so that lhs and rhs are independent of eachother without copying" do
-    o_of_a, o_of_b = mock('a'), mock('b')
-    a, b = o_of_a, o_of_b
-    a, b = b, a
-    a.should equal(o_of_b)
-    b.should equal(o_of_a)
-  end
-end
-
-describe "Multiple assignments with splats" do
-  ruby_version_is ""..."1.9" do
-    it "* on the lhs has to be applied to the last parameter" do
-      lambda { eval 'a, *b, c = 1, 2, 3' }.should raise_error(SyntaxError)
-    end
-  end
-
-  it "* on the lhs collects all parameters from its position onwards as an Array or an empty Array" do
-    a, *b = 1, 2
-    c, *d = 1
-    e, *f = 1, 2, 3
-    g, *h = 1, [2, 3]
-    *i = 1, [2,3]
-    *k = 1,2,3
-
-    a.should == 1
-    b.should == [2]
-    c.should == 1
-    d.should == []
-    e.should == 1
-    f.should == [2, 3]
-    g.should == 1
-    h.should == [[2, 3]]
-    i.should == [1, [2, 3]]
-    k.should == [1,2,3]
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "* on the LHS returns the Array on the RHS enclosed in an Array" do
-      *j = [1,2,3]
-      j.should == [[1,2,3]]
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "* on the LHS returns the Array on the RHS without enclosing it in an Array" do
-      *j = [1,2,3]
-      j.should == [1,2,3]
-    end
-  end
-end
-
-describe "Multiple assignments with grouping" do
-  it "A group on the lhs is considered one position and treats its corresponding rhs position like an Array" do
-    # a, (b, c), d = 1, 2, 3, 4
-    # e, (f, g), h = 1, [2, 3, 4], 5
-    # i, (j, k), l = 1, 2, 3
-    a.should == 1
-    b.should == 2
-    c.should == nil
-    d.should == 3
-    e.should == 1
-    f.should == 2
-    g.should == 3
-    h.should == 5
-    i.should == 1
-    j.should == 2
-    k.should == nil
-    l.should == 3
-  end
-
-  it "supports multiple levels of nested groupings" do
-    # a,(b,(c,d)) = 1,[2,[3,4]]
-    a.should == 1
-    b.should == 2
-    c.should == 3
-    d.should == 4
-
-    # a,(b,(c,d)) = [1,[2,[3,4]]]
-    a.should == 1
-    b.should == 2
-    c.should == 3
-    d.should == 4
-
-    x = [1,[2,[3,4]]]
-    # a,(b,(c,d)) = x
-    a.should == 1
-    b.should == 2
-    c.should == 3
-    d.should == 4
-  end
-
-  it "rhs cannot use parameter grouping, it is a syntax error" do
-    lambda { eval '(a, b) = (1, 2)' }.should raise_error(SyntaxError)
-  end
-end
-
-# TODO: merge the following two describe blocks and partition the specs
-# into distinct cases.
-describe "Multiple assignment" do
-  not_compliant_on :rubinius do
-    it "has the proper return value" do
-      # (a,b,*c = *[5,6,7,8,9,10]).should == [5,6,7,8,9,10]
-      # (d,e = VariablesSpecs.reverse_foo(4,3)).should == [3,4]
-      # (f,g,h = VariablesSpecs.reverse_foo(6,7)).should == [7,6]
-      # (i,*j = *[5,6,7]).should == [5,6,7]
-      # (k,*l = [5,6,7]).should == [5,6,7]
-      a.should == 5
-      b.should == 6
-      c.should == [7,8,9,10]
-      d.should == 3
-      e.should == 4
-      f.should == 7
-      g.should == 6
-      h.should == nil
-      i.should == 5
-      j.should == [6,7]
-      k.should == 5
-      l.should == [6,7]
-    end
-  end
-
-  # TODO: write Rubinius versions
-end
-
-# For now, masgn is deliberately non-compliant with MRI wrt the return val from an masgn.
-# Rubinius returns true as the result of the assignment, but MRI returns an array
-# containing all the elements on the rhs. As this result is never used, the cost
-# of creating and then discarding this array is avoided
-describe "Multiple assignment, array-style" do
-  not_compliant_on :rubinius do
-    it "returns an array of all rhs values" do
-      (a,b = 5,6,7).should == [5,6,7]
-      a.should == 5
-      b.should == 6
-
-      (c,d,*e = 99,8).should == [99,8]
-      c.should == 99
-      d.should == 8
-      e.should == []
-
-      (f,g,h = 99,8).should == [99,8]
-      f.should == 99
-      g.should == 8
-      h.should == nil
-    end
-  end
-
-  deviates_on :rubinius do
-    it "returns true" do
-      (a,b = 5,6,7).should == true
-      a.should == 5
-      b.should == 6
-
-      (c,d,*e = 99,8).should == true
-      c.should == 99
-      d.should == 8
-      e.should == []
-
-      (f,g,h = 99,8).should == true
-      f.should == 99
-      g.should == 8
-      h.should == nil
-    end
-  end
-end
-
-describe "Scope of variables" do
-  it "instance variables not overwritten by local variable in each block" do
-
-    class ScopeVariables
-      attr_accessor :v
-
-      def initialize
-        @v = ['a', 'b', 'c']
-      end
-
-      def check_access
-        v.should == ['a', 'b', 'c']
-        self.v.should == ['a', 'b', 'c']
-      end
-
-      def check_local_variable
-        v = nil
-        self.v.should == ['a', 'b', 'c']
-      end
-
-      def check_each_block
-        self.v.each { |v|
-          # Don't actually do anything
-        }
-        self.v.should == ['a', 'b', 'c']
-        v.should == ['a', 'b', 'c']
-        self.v.object_id.should == v.object_id
-      end
-    end # Class ScopeVariables
-
-    instance = ScopeVariables.new()
-    instance.check_access
-    instance.check_local_variable
-    instance.check_each_block
-  end
-end
-
-describe "A local variable in a #define_method scope" do
-  ruby_bug '#1322', '1.8.7.228' do
-    it "shares the lexical scope containing the call to #define_method" do
-      # We need a new scope to reproduce this bug.
-      handle = mock("handle for containing scope method")
-
-      def handle.produce_bug
-        local = 1
-
-        klass = Class.new
-        klass.send :define_method, :set_local do |arg|
-          lambda { local = 2 }.call
-        end
-
-        # We must call with at least one argument to reproduce the bug.
-        klass.new.set_local(nil)
-
-        local
-      end
-
-      handle.produce_bug.should == 2
-    end
-  end
-end
-
-language_version __FILE__, "variables"