opal 0.3.41 → 0.3.42

data/spec/language/retry_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The retry statement" do
+  pending "re-executes the closest block" do
+    retry_first = true
+    retry_second = true
+    results = []
+    begin
+      results << 1
+      raise
+    rescue
+      results << 2
+      if retry_first
+        results << 3
+        retry_first = false
+        retry
+      end
+      begin
+        results << 4
+        raise
+      rescue
+        results << 5
+        if retry_second
+          results << 6
+          retry_second = false
+          retry
+        end
+      end
+    end
+
+    results.should == [1, 2, 3, 1, 2, 4, 5, 6, 4, 5]
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a SyntaxError when used outside of a begin statement" do
+      lambda { eval 'retry' }.should raise_error(SyntaxError)
+    end
+  end
+end
+
+describe "The retry keyword inside a begin block's rescue block" do
+  pending "causes the begin block to be executed again" do
+    counter = 0
+
+    begin
+      counter += 1
+      raise "An exception"
+    rescue
+      retry unless counter == 7
+    end
+
+    counter.should == 7
+  end
+end
+
+# language_version __FILE__, "retry"

data/spec/language/return_spec.rb

@@ -0,0 +1,281 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/return', __FILE__)
+
+describe "The return keyword" do
+  it "returns any object directly" do
+    def r; return 1; end
+    r().should == 1
+  end
+
+  it "returns an single element array directly" do
+    def r; return [1]; end
+    r().should == [1]
+  end
+
+  it "returns an multi element array directly" do
+    def r; return [1,2]; end
+    r().should == [1,2]
+  end
+
+  it "returns nil by default" do
+    def r; return; end
+    r().should be_nil
+  end
+
+  describe "in a Thread" do
+    ruby_version_is "" ... "1.9" do
+      it "raises a ThreadError if used to exit a thread" do
+        lambda { Thread.new { return }.join }.should raise_error(ThreadError)
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "raises a LocalJumpError if used to exit a thread" do
+        lambda { Thread.new { return }.join }.should raise_error(LocalJumpError)
+      end
+    end
+  end
+
+  describe "when passed a splat" do
+    ruby_version_is "" ... "1.9" do
+      it "returns nil when the ary is empty" do
+        def r; ary = []; return *ary; end
+        r.should be_nil
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "returns [] when the ary is empty" do
+        def r; ary = []; return *ary; end
+        r.should == []
+      end
+    end
+
+    ruby_version_is "" ... "1.9" do
+      it "returns the first element when the array is size of 1" do
+        def r; ary = [1]; return *ary; end
+        r.should == 1
+      end
+    end
+
+    ruby_version_is "1.9" do
+      it "returns the array when the array is size of 1" do
+        def r; ary = [1]; return *ary; end
+        r.should == [1]
+      end
+    end
+
+    it "returns the whole array when size is greater than 1" do
+      def r; ary = [1,2]; return *ary; end
+      r.should == [1,2]
+
+      def r; ary = [1,2,3]; return *ary; end
+      r.should == [1,2,3]
+    end
+
+    ruby_version_is "" ... "1.9" do
+      it "returns a non-array when used as a splat" do
+        def r; value = 1; return *value; end
+        r.should == 1
+      end
+    end
+
+    ruby_version_is "1.9" do
+      pending "returns an array when used as a splat" do
+        def r; value = 1; return *value; end
+        r.should == [1]
+      end
+    end
+
+
+    pending "calls 'to_a' on the splatted value first" do
+      def r
+        obj = Object.new
+        def obj.to_a
+          [1,2]
+        end
+
+        return *obj
+      end
+
+      r().should == [1,2]
+    end
+
+    ruby_version_is "" ... "1.9" do
+      it "calls 'to_ary' on the splatted value first" do
+        def r
+          obj = Object.new
+          def obj.to_ary
+            [1,2]
+          end
+
+          return *obj
+        end
+
+        r().should == [1,2]
+      end
+    end
+  end
+
+  describe "within a begin" do
+    before :each do
+      ScratchPad.record []
+    end
+
+    it "executes ensure before returning" do
+      def f()
+        begin
+          ScratchPad << :begin
+          return :begin
+          ScratchPad << :after_begin
+        ensure
+          ScratchPad << :ensure
+        end
+        ScratchPad << :function
+      end
+      f().should == :begin
+      ScratchPad.recorded.should == [:begin, :ensure]
+    end
+
+    it "returns last value returned in ensure" do
+      def f()
+        begin
+          ScratchPad << :begin
+          return :begin
+          ScratchPad << :after_begin
+        ensure
+          ScratchPad << :ensure
+          return :ensure
+          ScratchPad << :after_ensure
+        end
+        ScratchPad << :function
+      end
+      f().should == :ensure
+      ScratchPad.recorded.should == [:begin, :ensure]
+    end
+
+    pending "executes nested ensures before returning" do
+      # def f()
+      #   begin
+      #     begin
+      #       ScratchPad << :inner_begin
+      #       return :inner_begin
+      #       ScratchPad << :after_inner_begin
+      #     ensure
+      #       ScratchPad << :inner_ensure
+      #     end
+      #     ScratchPad << :outer_begin
+      #     return :outer_begin
+      #     ScratchPad << :after_outer_begin
+      #   ensure
+      #     # ScratchPad << :outer_ensure
+      #   end
+      #   ScratchPad << :function
+      # end
+      # f().should == :inner_begin
+      # ScratchPad.recorded.should == [:inner_begin, :inner_ensure, :outer_ensure]
+    end
+
+    pending "returns last value returned in nested ensures" do
+      # def f()
+      #   begin
+      #     begin
+      #       ScratchPad << :inner_begin
+      #       return :inner_begin
+      #       ScratchPad << :after_inner_begin
+      #     ensure
+      #       ScratchPad << :inner_ensure
+      #       return :inner_ensure
+      #       ScratchPad << :after_inner_ensure
+      #     end
+      #     ScratchPad << :outer_begin
+      #     return :outer_begin
+      #     ScratchPad << :after_outer_begin
+      #   ensure
+      #     ScratchPad << :outer_ensure
+      #     return :outer_ensure
+      #     ScratchPad << :after_outer_ensure
+      #   end
+      #   ScratchPad << :function
+      # end
+      # f().should == :outer_ensure
+      # ScratchPad.recorded.should == [:inner_begin, :inner_ensure, :outer_ensure]
+    end
+
+    it "executes the ensure clause when begin/ensure are inside a lambda" do
+      lambda do
+        begin
+          return
+        ensure
+          ScratchPad.recorded << :ensure
+        end
+      end.call
+      ScratchPad.recorded.should == [:ensure]
+    end
+  end
+
+  describe "within a block" do
+    before :each do
+      ScratchPad.clear
+    end
+
+    ruby_version_is "" ... "1.9" do
+      it "raises a LocalJumpError if there is no lexicaly enclosing method" do
+        def f; yield; end
+        lambda { f { return 5 } }.should raise_error(LocalJumpError)
+      end
+    end
+
+    it "causes lambda to return nil if invoked without any arguments" do
+      lambda { return; 456 }.call.should be_nil
+    end
+
+    it "causes lambda to return nil if invoked with an empty expression" do
+      lambda { return (); 456 }.call.should be_nil
+    end
+
+    it "causes lambda to return the value passed to return" do
+      lambda { return 123; 456 }.call.should == 123
+    end
+
+    pending "causes the method that lexically encloses the block to return" do
+      ReturnSpecs::Blocks.new.enclosing_method.should == :return_value
+      ScratchPad.recorded.should == :before_return
+    end
+
+    pending "returns from the lexically enclosing method even in case of chained calls" do
+      ReturnSpecs::NestedCalls.new.enclosing_method.should == :return_value
+      ScratchPad.recorded.should == :before_return
+    end
+
+    pending "returns from the lexically enclosing method even in case of chained calls(in yield)" do
+      ReturnSpecs::NestedBlocks.new.enclosing_method.should == :return_value
+      ScratchPad.recorded.should == :before_return
+    end
+
+    pending "causes the method to return even when the immediate parent has already returned" do
+      ReturnSpecs::SavedInnerBlock.new.start.should == :return_value
+      ScratchPad.recorded.should == :before_return
+    end
+
+  end
+
+  describe "within two blocks" do
+    pending "causes the method that lexically encloses the block to return" do
+      def f
+        1.times { 1.times {return true}; false}; false
+      end
+      f.should be_true
+    end
+  end
+
+  describe "within define_method" do
+    pending "goes through the method via a closure" do
+      ReturnSpecs::ThroughDefineMethod.new.outer.should == :good
+    end
+
+    it "stops at the method when the return is used directly" do
+      ReturnSpecs::DefineMethod.new.outer.should == :good
+    end
+  end
+end

data/spec/language/send_spec.rb

@@ -1,39 +1,16 @@
-module LangSendSpecs
-
-  def self.fooM0; 100; end
-  def self.fooM1(a); [a]; end
-  def self.fooM2(a,b); [a,b]; end
-  def self.fooM3(a,b,c); [a,b,c]; end
-  def self.fooM4(a,b,c,d); [a,b,c,d]; end
-  def self.fooM5(a,b,c,d,e); [a,b,c,d,e]; end
-  def self.fooM0O1(a=1); [a]; end
-  def self.fooM1O1(a,b=1); [a,b]; end
-  def self.fooM2O1(a,b,c=1); [a,b,c]; end
-  def self.fooM3O1(a,b,c,d=1); [a,b,c,d]; end
-  def self.fooM4O1(a,b,c,d,e=1); [a,b,c,d,e]; end
-  def self.fooM0O2(a=1,b=2); [a,b]; end
-  def self.fooM0R(*r); r; end
-  def self.fooM1R(a, *r); [a, r]; end
-  def self.fooM0O1R(a=1, *r); [a, r]; end
-  def self.fooM1O1R(a, b=1, *r); [a, b, r]; end
-
-  def self.one(a); a; end
-  def self.oneb(a,&b); [a,yield(b)]; end
-
-  def self.makeproc(&b) b end
-
-  def self.yield_now; yield; end
-
-  class ToProc
-    def initialize(val)
-      @val = val
-    end
-
-    def to_proc
-      Proc.new { @val }
-    end
-  end
-end
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/send', __FILE__)
+require 'language/fixtures/send'
+
+# 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
 
@@ -43,16 +20,27 @@ describe "Invoking a method" 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 thr same number of passed values" 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
@@ -63,11 +51,29 @@ describe "Invoking a method" do
     it "uses the passed argument if available" do
       specs.fooM0O1(2).should == [2]
     end
+
+    pending "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]
+      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
+
+    pending "raises an ArgumentError if too many values are passed" do
+      lambda {
+        specs.fooM1O1(1,2,3)
+      }.should raise_error(ArgumentError)
     end
   end
 
@@ -83,7 +89,7 @@ describe "Invoking a method" do
     end
   end
 
-  it "with a block makes it available to yield" do
+  pending "with a block makes it available to yield" do
     specs.oneb(10) { 200 }.should == [10,200]
   end
 
@@ -93,7 +99,7 @@ describe "Invoking a method" do
     prc.call.should == "hello"
   end
 
-  it "with an object as a block used 'to_proc' for coercion" do
+  pending "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
@@ -101,6 +107,12 @@ describe "Invoking a method" do
     specs.yield_now(&o).should == :from_to_proc
   end
 
+  pending "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
 
@@ -115,20 +127,101 @@ describe "Invoking a method" do
     specs.fooM3(*a).should == [1,2,3]
   end
 
-  it "without parantheses works" do
+  it "without parentheses works" do
     (specs.fooM3 1,2,3).should == [1,2,3]
   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'}]
+  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
+    specs.weird_parens().should == "55"
   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'}]
+  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
+
+  pending "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
+
+  pending "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 }]
+    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
-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
+
+    pending "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
+  pending "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"