opal-wedge 0.9.0.dev

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

@@ -0,0 +1,20 @@
+describe "Literal Regexps" do
+  it "yields a Regexp" do
+    /Hello/.should be_kind_of(Regexp)
+  end
+end
+
+describe "Regexps with interpolation" do
+  it "allows interpolation of strings" do
+    str = "foo|bar"
+    /#{str}/.should == /foo|bar/
+  end
+
+  it "allows interpolation to interact with other Regexp constructs" do
+    str = "foo)|(bar"
+    /(#{str})/.should == /(foo)|(bar)/
+
+    str = "a"
+    /[#{str}-z]/.should == /[a-z]/
+  end
+end

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

@@ -0,0 +1,225 @@
+require File.expand_path('../fixtures/send', __FILE__)
+
+# Why so many fixed arg tests?  JRuby and I assume other Ruby impls have
+# separate call paths for simple fixed arity methods.  Testing up to five
+# will verify special and generic arity code paths for all impls.
+#
+# Method naming conventions:
+# M - Manditory Args
+# O - Optional Arg
+# R - Rest Arg
+# Q - Post Manditory Args (1.9)
+
+specs = LangSendSpecs
+
+describe "Invoking a method" do
+  describe "with zero arguments" do
+    it "requires no arguments passed" do
+      specs.fooM0.should == 100
+    end
+
+    it "raises ArgumentError if the method has a positive arity" do
+      lambda {
+        specs.fooM1
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "with only manditory arguments" do
+    it "requires exactly the same number of passed values" do
+      specs.fooM1(1).should == [1]
+      specs.fooM2(1,2).should == [1,2]
+      specs.fooM3(1,2,3).should == [1,2,3]
+      specs.fooM4(1,2,3,4).should == [1,2,3,4]
+      specs.fooM5(1,2,3,4,5).should == [1,2,3,4,5]
+    end
+
+    it "raises ArgumentError if the methods arity doesn't match" do
+      lambda {
+        specs.fooM1(1,2)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "with optional arguments" do
+    it "uses the optional argument if none is is passed" do
+      specs.fooM0O1.should == [1]
+    end
+
+    it "uses the passed argument if available" do
+      specs.fooM0O1(2).should == [2]
+    end
+
+    it "raises ArgumentError if extra arguments are passed" do
+      lambda {
+        specs.fooM0O1(2,3)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "with manditory and optional arguments" do
+    it "uses the passed values in left to right order" do
+      specs.fooM1O1(2).should == [2,1]
+    end
+
+    it "raises an ArgumentError if there are no values for the manditory args" do
+      lambda {
+        specs.fooM1O1
+      }.should raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError if too many values are passed" do
+      lambda {
+        specs.fooM1O1(1,2,3)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "with a rest argument" do
+    it "is an empty array if there are no additional arguments" do
+      specs.fooM0R().should == []
+      specs.fooM1R(1).should == [1, []]
+    end
+
+    it "gathers unused arguments" do
+      specs.fooM0R(1).should == [1]
+      specs.fooM1R(1,2).should == [1, [2]]
+    end
+  end
+
+  it "with a block makes it available to yield" do
+    specs.oneb(10) { 200 }.should == [10,200]
+  end
+
+  it "with a block converts the block to a Proc" do
+    prc = specs.makeproc { "hello" }
+    prc.should be_kind_of(Proc)
+    prc.call.should == "hello"
+  end
+
+  it "with an object as a block uses 'to_proc' for coercion" do
+    o = LangSendSpecs::ToProc.new(:from_to_proc)
+
+    specs.makeproc(&o).call.should == :from_to_proc
+
+    specs.yield_now(&o).should == :from_to_proc
+  end
+
+  it "raises a SyntaxError with both a literal block and an object as block" do
+    lambda {
+      eval "specs.oneb(10, &l){ 42 }"
+    }.should raise_error(SyntaxError)
+  end
+
+  it "with same names as existing variables is ok" do
+    foobar = 100
+
+    def foobar; 200; end
+
+    foobar.should == 100
+    foobar().should == 200
+  end
+
+  it "with splat operator makes the object the direct arguments" do
+    a = [1,2,3]
+    specs.fooM3(*a).should == [1,2,3]
+  end
+
+  it "without parentheses works" do
+    (specs.fooM3 1,2,3).should == [1,2,3]
+  end
+
+  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
+    specs.weird_parens().should == "55"
+  end
+
+  ruby_version_is "" ... "1.9" do
+    describe "allows []=" do
+      before :each do
+        @obj = LangSendSpecs::AttrSet.new
+      end
+
+      it "with *args in the [] expanded to individual arguments" do
+        ary = [2,3]
+        (@obj[1, *ary] = 4).should == 4
+        @obj.result.should == [1,2,3,4]
+      end
+
+      it "with multiple *args" do
+        ary = [2,3]
+        post = [4,5]
+        (@obj[1, *ary] = *post).should == [4,5]
+        @obj.result.should == [1,2,3,[4,5]]
+      end
+
+      it "with multiple *args and unwraps the last splat" do
+        ary = [2,3]
+        post = [4]
+        (@obj[1, *ary] = *post).should == 4
+        @obj.result.should == [1,2,3,4]
+      end
+
+      it "with a *args and multiple rhs args" do
+        ary = [2,3]
+        (@obj[1, *ary] = 4, 5).should == [4,5]
+        @obj.result.should == [1,2,3,[4,5]]
+      end
+    end
+  end
+
+  it "passes literal hashes without curly braces as the last parameter" do
+    specs.fooM3('abc', 456, 'rbx' => 'cool',
+         'specs' => 'fail sometimes', 'oh' => 'weh').should == \
+     ['abc', 456, {'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
+  end
+
+  it "passes a literal hash without curly braces or parens" do
+    (specs.fooM3 'abc', 456, 'rbx' => 'cool',
+        'specs' => 'fail sometimes', 'oh' => 'weh').should == \
+     ['abc', 456, { 'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
+  end
+
+  it "allows to literal hashes without curly braces as the only parameter" do
+    specs.fooM1(:rbx => :cool, :specs => :fail_sometimes).should ==
+      [{ :rbx => :cool, :specs => :fail_sometimes }]
+
+    (specs.fooM1 :rbx => :cool, :specs => :fail_sometimes).should ==
+      [{ :rbx => :cool, :specs => :fail_sometimes }]
+  end
+
+  describe "when the method is not available" do
+    it "invokes method_missing" do
+      o = LangSendSpecs::MethodMissing.new
+      o.not_there(1,2)
+      o.message.should == :not_there
+      o.args.should == [1,2]
+    end
+  end
+
+end
+
+describe "Invoking a private setter method" do
+  describe "permits self as a receiver" do
+    it "for normal assignment" do
+      receiver = LangSendSpecs::PrivateSetter.new
+      receiver.call_self_foo_equals(42)
+      receiver.foo.should == 42
+    end
+
+    it "for multiple assignment" do
+      receiver = LangSendSpecs::PrivateSetter.new
+      receiver.call_self_foo_equals_masgn(42)
+      receiver.foo.should == 42
+    end
+  end
+end
+
+describe "Invoking a private getter method" do
+  it "does not permit self as a receiver" do
+    receiver = LangSendSpecs::PrivateGetter.new
+    lambda { receiver.call_self_foo }.should raise_error(NoMethodError)
+    lambda { receiver.call_self_foo_or_equals(6) }.should raise_error(NoMethodError)
+  end
+end
+
+# language_version __FILE__, "send"

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

@@ -0,0 +1,44 @@
+describe "Ruby character strings" do
+  it "are produced from character shortcuts" do
+    ?z.should == 'z'
+  end
+
+  it "should parse string into %[]" do 
+    %[foo].should == "foo"
+    %|bar|.should == "bar"
+    %'baz'.should == "baz"
+  end
+
+  it "interpolate string" do 
+    a = 1
+    %[#{a}23].should == "123"
+  end
+
+  it "should not process escape characters in single-quoted heredocs" do
+    s = <<'EOD'
+      hey\now\brown\cow
+    EOD
+    s.strip.should == 'hey\now\brown\cow'
+  end
+
+  it "should ignore single-quote escapes in single-quoted heredocs" do
+    s = <<'EOD'
+      they\'re greeeeaaat!
+    EOD
+    s.strip.should == 'they\\\'re greeeeaaat!'
+  end
+
+  it "should process escape characters in double quoted heredocs" do
+    s = <<"EOD"
+      hey\now\brown\cow
+    EOD
+    s.strip.should == "hey\now\brown\cow"
+  end
+
+  it "should treat bare-word heredoc identifiers as double-quoted" do
+    s = <<EOD
+      hey\now\brown\cow
+    EOD
+    s.strip.should == "hey\now\brown\cow"
+  end
+end

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

@@ -0,0 +1,1366 @@
+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"