rhodes 2.0.0.beta11 → 2.0.0.rc1

data/spec/framework_spec/app/spec/language/super_spec.rb

@@ -57,7 +57,7 @@ describe "The super keyword" do
     Super::S4::B.new.foo([],"test").should == ["B#foo(a,test)", "A#foo"]
   end
 
-  ruby_bug "#1151 [ruby-core:22040]", "1.8.6" do
+  ruby_bug "#1151 [ruby-core:22040]", "1.8.7.174" do
     it "raises an error error when super method does not exist" do
       sup = Class.new
       sub_normal = Class.new(sup) do
@@ -76,6 +76,14 @@ describe "The super keyword" do
     end
   end
 
+  it "calls the superclass method when in a block" do
+    Super::S6.new.here.should == :good
+  end
+
+  it "calls the superclass method when initial method is defined_method'd" do
+    Super::S7.new.here.should == :good
+  end
+
   it "supers up appropriate name even if used for multiple method names" do
     sup = Class.new do
       def a; "a"; end
@@ -85,7 +93,7 @@ describe "The super keyword" do
     sub = Class.new(sup) do
       [:a, :b].each do |name|
         define_method name do
-          super
+          super()
         end
       end
     end
@@ -94,4 +102,44 @@ describe "The super keyword" do
     sub.new.b.should == "b"
     sub.new.a.should == "a"
   end
+
+  ruby_version_is ""..."1.9" do
+    it "can be used with implicit arguments from a method defined with define_method" do
+      sup = Class.new do
+        def a; "a"; end
+      end
+
+      sub = Class.new(sup) do
+        define_method :a do
+          super
+        end
+      end
+
+      sub.new.a.should == "a"
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "can't be used with implicit arguments from a method defined with define_method" do
+      Class.new do
+        define_method :a do
+          super
+        end.should raise_error(RuntimeError)
+      end
+    end
+  end
+
+  # Rubinius ticket github#157
+  it "calls method_missing when a superclass method is not found" do
+    lambda {
+      Super::MM_B.new.is_a?(Hash).should == false
+    }.should_not raise_error(NoMethodError)
+  end
+
+  # Rubinius ticket github#180
+  it "respects the original module a method is aliased from" do
+    lambda {
+      Super::Alias3.new.name3.should == [:alias2, :alias1]
+    }.should_not raise_error(RuntimeError)
+  end
 end

data/spec/framework_spec/app/spec/language/throw_spec.rb

@@ -9,7 +9,7 @@ describe "The throw keyword" do
         throw :done if i > 4
       end
       i += 1
-    end    
+    end
     i.should == 5
   end
   
@@ -27,17 +27,34 @@ describe "The throw keyword" do
     msg.should == nil
   end
 
-  it "only allows symbols and strings as it's argument" do
-    lambda { throw 1 }.should raise_error(ArgumentError)    
-    lambda { throw Object.new }.should raise_error(TypeError)    
+  ruby_version_is "" ... "1.9" do
+    it "only allows symbols and strings as its argument" do
+      lambda { throw 1 }.should raise_error(ArgumentError)
+      lambda { throw Object.new }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "only any object as its argument" do
+      lambda { catch(1) { throw 1 } }.should_not raise_error
+      lambda { o = Object.new; catch(o) { throw o } }.should_not raise_error
+    end
   end
 
-  it "converts strings to a symbol" do
-    lambda { catch(:exit) { throw "exit" } }.should_not raise_error
-    a = "exit"
-    lambda { catch(:exit) { throw a } }.should_not raise_error
+  ruby_version_is "" ... "1.9" do
+    it "converts strings to a symbol" do
+      lambda { catch(:exit) { throw "exit" } }.should_not raise_error
+      a = "exit"
+      lambda { catch(:exit) { throw a } }.should_not raise_error
+    end
   end
-    
+
+  ruby_version_is "1.9" do
+    it "does not convert strings to a symbol" do
+      lambda { catch(:exit) { throw "exit" } }.should raise_error(ArgumentError)
+    end
+  end
+
   it "unwinds stack from within a method" do
     def throw_method(handler,val)
       throw handler,val
@@ -52,19 +69,42 @@ describe "The throw keyword" do
     c = lambda { throw :foo, :msg }
     catch(:foo) { c.call }.should == :msg
   end
-  
-  it "raises a name error if outside of scope of a matching catch" do    
-    lambda { throw :test,5 }.should raise_error(NameError)
-    lambda { catch(:different) { throw :test,5 } }.should raise_error(NameError)
+
+  ruby_version_is "" ... "1.9" do 
+    it "raises a NameError if outside of scope of a matching catch" do
+      lambda { throw :test,5 }.should raise_error(NameError)
+      lambda { catch(:different) { throw :test,5 } }.should raise_error(NameError)
+    end
   end
 
-  it "raises a ThreadError if used to exit a thread" do
-    lambda {
-      catch(:what) do
-        Thread.new do
-          throw :what
-        end.join
-      end
-    }.should raise_error(ThreadError)
-  end    
+  ruby_version_is "1.9" do
+    it "raises an ArgumentError if outside of scope of a matching catch" do
+      lambda { throw :test,5 }.should raise_error(ArgumentError)
+      lambda { catch(:different) { throw :test,5 } }.should raise_error(ArgumentError)
+    end
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a ThreadError if used to exit a thread" do
+      lambda {
+        catch(:what) do
+          Thread.new do
+            throw :what
+          end.join
+        end
+      }.should raise_error(ThreadError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a ArgumentError if used to exit a thread" do
+      lambda {
+        catch(:what) do
+          Thread.new do
+            throw :what
+          end.join
+        end
+      }.should raise_error(ArgumentError)
+    end
+  end
 end

data/spec/framework_spec/app/spec/language/undef_spec.rb

@@ -6,9 +6,9 @@ end
 
 describe "The undef keyword" do
   it "undefines 'meth='" do
-    obj = UndefSpecClass.new
+    obj = ::UndefSpecClass.new
     (obj.meth 5).should == 5
-    class UndefSpecClass
+    class ::UndefSpecClass
       undef meth
     end
     lambda { obj.meth 5 }.should raise_error(NoMethodError)

data/spec/framework_spec/app/spec/language/variables_spec.rb

@@ -152,6 +152,10 @@ describe "Basic assignment" do
     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([], *[])
@@ -206,6 +210,157 @@ describe "Assignment using expansion" do
   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
@@ -223,6 +378,15 @@ describe "Assigning multiple values" do
     b.should == 1
   end
 
+  not_compliant_on :rubinius do
+    it "returns the rhs values used for assignment as an array" do
+      o = Object.new
+      def o.masgn; a, b, c = 1, 2, 3; end
+
+      o.masgn.should == [1,2,3]
+    end
+  end
+
   it "evaluates rhs left-to-right" do
     a = VariablesSpecs::ParAsgn.new
     d,e,f = a.inc, a.inc, a.inc
@@ -272,62 +436,81 @@ describe "Assigning multiple values" do
     a.should == [[1]]
   end
 
-# XXX eval not supported
-#  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 == [x]
-#    c.should == nil
-#
-#    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
+
+  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
@@ -413,7 +596,7 @@ describe "Conditional assignment" do
   end
 end
 
-describe "Operator assignment 'var op= expr'" do
+describe "Unconditional operator assignment 'var op= expr'" do
   it "is equivalent to 'var = var op expr'" do
     x = 13
     (x += 5).should == 18
@@ -469,7 +652,11 @@ describe "Operator assignment 'var op= expr'" do
     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
@@ -488,7 +675,17 @@ describe "Operator assignment 'var op= expr'" do
     x.should == false
   end
 
-  it "uses short-circuit arg evaluation for operators ||= and &&=" do
+  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
@@ -504,7 +701,7 @@ describe "Operator assignment 'var op= expr'" do
   end
 end
 
-describe "Operator assignment 'obj.meth op= expr'" do
+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
@@ -559,9 +756,14 @@ describe "Operator assignment 'obj.meth op= expr'" do
     @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 ||= 17).should == 17
     @x.a.should == 17
     (@x.a ||= 2).should == 17
     @x.a.should == 17
@@ -578,7 +780,18 @@ describe "Operator assignment 'obj.meth op= expr'" do
     @x.a.should == false
   end
 
-  it "uses short-circuit arg evaluation for operators ||= and &&=" do
+  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
@@ -592,7 +805,9 @@ describe "Operator assignment 'obj.meth op= expr'" do
     (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
@@ -665,7 +880,7 @@ describe "Operator assignment 'obj.meth op= expr'" do
   end
 end
 
-describe "Operator assignment 'obj[idx] op= expr'" do
+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
@@ -719,7 +934,11 @@ describe "Operator assignment 'obj[idx] op= expr'" do
     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]
@@ -737,7 +956,19 @@ describe "Operator assignment 'obj[idx] op= expr'" do
     x.should == [false, false, false]
   end
 
-  it "uses short-circuit arg evaluation for operators ||= and &&=" do
+  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
@@ -751,7 +982,9 @@ describe "Operator assignment 'obj[idx] op= expr'" do
     (x ||= y.do_side_effect).should == 5
     y.side_effect.should == true
   end
+end
 
+describe "Operator assignment 'obj[idx] op= expr'" do
   it "handles complex index (idx) arguments" do
     x = [1,2,3,4]
     (x[0,2] += [5]).should == [1,2,5]
@@ -772,7 +1005,9 @@ describe "Operator assignment 'obj[idx] op= expr'" do
     (h['key2'] += 'ue').should == 'value'
     h.should == {'key1' => 3, 'key2' => 'value'}
   end
-
+  
+  # This example fails on 1.9 because of bug #2050
+=begin
   it "returns result of rhs not result of []=" do
     a = VariablesSpecs::Hashalike.new
 
@@ -798,6 +1033,7 @@ describe "Operator assignment 'obj[idx] op= expr'" do
     (a[123] &&= 2).should == 2
     (a[nil] &&= 2).should == nil
   end
+=end
 end
 
 describe "Single assignment" do
@@ -857,9 +1093,11 @@ describe "Multiple assignment without grouping or splatting" do
 end
 
 describe "Multiple assignments with splats" 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
+  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
@@ -867,7 +1105,6 @@ describe "Multiple assignments with splats" do
     e, *f = 1, 2, 3
     g, *h = 1, [2, 3]
     *i = 1, [2,3]
-    *j = [1,2,3]
     *k = 1,2,3
 
     a.should == 1
@@ -879,9 +1116,22 @@ describe "Multiple assignments with splats" do
     g.should == 1
     h.should == [[2, 3]]
     i.should == [1, [2, 3]]
-    j.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
@@ -923,10 +1173,10 @@ describe "Multiple assignments with grouping" do
     c.should == 3
     d.should == 4
   end
-# XXX eval not supported
-#  it "rhs cannot use parameter grouping, it is a syntax error" do
-#    lambda { eval '(a, b) = (1, 2)' }.should raise_error(SyntaxError)
-#  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
@@ -1035,3 +1285,30 @@ describe "Scope of variables" do
     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"