opal 0.3.41 → 0.3.42

data/spec/language/proc_spec.rb

@@ -1,37 +1,265 @@
-class ProcSpec
-  define_method :defined_method do
-    self
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "A Proc" do
+  it "captures locals from the surrounding scope" do
+    var = 1
+    lambda { var }.call.should == 1
   end
 
-  def call_proc
-    get_proc.call
+  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
 
-  def get_proc
-    proc { self }
+  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
-end
 
-describe "Procs" do
-  before do
-    @obj = ProcSpec.new
+  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
+      pending "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
+
+    pending "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
+
+    pending "assigns the value passed to the argument" do
+      @l.call(2).should == 2
+    end
+
+    pending "does not destructure a single Array value" do
+      @l.call([1, 2]).should == [1, 2]
+    end
+
+    pending "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
+      pending "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
+
+    pending "raises an ArgumentError if passed no values" do
+      lambda { @l.call }.should raise_error(ArgumentError)
+    end
+
+    pending "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
+
+    pending "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
+
+    pending "raises an ArgumentError if passed no values" do
+      lambda { @l.call }.should raise_error(ArgumentError)
+    end
+
+    pending "does not destructure a single Array value yielded" do
+      @l.call([1, 2, 3]).should == [[1, 2, 3], []]
+    end
+
+    pending "assigns all passed values after the first to the rest argument" do
+        @l.call(1, 2, 3).should == [1, [2, 3]]
+    end
+
+    pending "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
 
-  it "should use the 'self' value of wrapping scope" do
-    @obj.call_proc.should eq(@obj)
+  describe "taking |*| arguments" do
+    before :each do
+      # @l = lambda { |*| 1 }
+    end
+
+    pending "does not raise an exception when passed no values" do
+      @l.call.should == 1
+    end
+
+    pending "does not raise an exception when passed multiple values" do
+      @l.call(2, 3, 4).should == 1
+    end
+
+    pending "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
 
-  it "instance_eval correctly sets proc self value" do
-    arr = []
-    arr.instance_eval(&@obj.get_proc).should eq(arr)
+  describe "taking |*a| arguments" do
+    before :each do
+      @l = lambda { |*a| a }
+    end
+
+    pending "assigns [] to the argument when passed no values" do
+      @l.call.should == []
+    end
+
+    pending "assigns the argument an Array wrapping one passed value" do
+      @l.call(1).should == [1]
+    end
+
+    pending "assigns the argument an Array wrapping all values passed" do
+      @l.call(1, 2, 3).should == [1, 2, 3]
+    end
+
+    pending "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
 
-  it "procs used by define_method use correct self value" do
-    @obj.defined_method.should eq(@obj)
+  describe "taking |a, | arguments" do
+    before :each do
+      # @l = lambda { |a, | a }
+    end
+
+    pending "raises an ArgumentError when passed no values" do
+      lambda { @l.call }.should raise_error(ArgumentError)
+    end
+
+    pending "raises an ArgumentError when passed more than one value" do
+      lambda { @l.call(1, 2) }.should raise_error(ArgumentError)
+    end
+
+    pending "assigns the argument the value passed" do
+      @l.call(1).should == 1
+    end
+
+    pending "does not destructure when passed a single Array" do
+      @l.call([1,2]).should == [1, 2]
+    end
+
+    pending "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
 
-  it "procs used by define_singleton_method use correct self value" do
-    @obj.define_singleton_method(:bar) { self }
-    @obj.bar.should eq(@obj)
+  describe "taking |(a, b)| arguments" do
+    before :each do
+      # @l = lambda { |(a, b)| [a, b] }
+    end
+
+    pending "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
+      pending "destructures a single Array value yielded" do
+        @l.call([1, 2]).should == [1, 2]
+      end
+
+      pending "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
+
+      pending "raises an TypeError if #to_ary does not return an Array" do
+        obj = mock("block yield to_ary invalid")
+        obj.should_receive(:to_ary).and_return(1)
+
+        lambda { @l.call(obj) }.should raise_error(TypeError)
+      end
+    end
   end
 end

data/spec/language/redo_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The redo statement" do
+  pending "restarts block execution if used within block" do
+    a = []
+    lambda {
+      a << 1
+      redo if a.size < 2
+      a << 2
+    }.call
+    a.should == [1, 1, 2]
+  end
+
+  pending "re-executes the closest loop" do
+    exist = [2,3]
+    processed = []
+    order = []
+    [1,2,3,4].each do |x|
+      order << x
+      begin
+        processed << x
+        if(exist.include?(x))
+          raise StandardError, "included"
+        end
+      rescue StandardError => e
+        exist.delete(x)
+        redo
+      end
+    end
+    processed.should == [1,2,2,3,3,4]
+    exist.should == []
+    order.should == [1,2,2,3,3,4]
+  end
+
+  pending "re-executes the last step in enumeration" do
+    list = []
+    [1,2,3].each do |x|
+      list << x
+      break if list.size == 6
+      redo if x == 3
+    end
+    list.should == [1,2,3,3,3,3]
+  end
+
+  # The #count method is on 1.9, but this causes SyntaxError,
+  # Invalid redo in 1.9
+  pending do
+  quarantine! do
+    it "triggers ensure block when re-executing a block" do
+      list = []
+      [1,2,3].each do |x|
+        list << x
+        begin
+          list << 10*x
+          # causes SyntaxError in 1.9
+          # redo if list.count(1) == 1
+        ensure
+          list << 100*x
+        end
+      end
+      list.should == [1,10,100,1,10,100,2,20,200,3,30,300]
+    end
+  end
+  end
+end
+
+# language_version __FILE__, "redo"

data/spec/language/rescue_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../../spec_helper', __FILE__)
+class SpecificExampleException < StandardError
+end
+class OtherCustomException < StandardError
+end
+
+def exception_list
+  [SpecificExampleException, ZeroDivisionError]
+end
+describe "The rescue keyword" do
+  before :each do
+    ScratchPad.record []
+  end
+
+  it "can be used to handle a specific exception" do
+    lambda do
+      begin
+        raise SpecificExampleException, "Raising this to be handled below"
+      rescue SpecificExampleException
+      end
+    end.should_not raise_error
+  end
+
+  it "can capture the raised exception in a local variable" do
+    begin
+      raise SpecificExampleException, "some text"
+    rescue SpecificExampleException => e
+      e.message.should == "some text"
+    end
+  end
+
+  pending "can rescue multiple raised exceptions with a single rescue block" do
+    lambda do
+      [lambda{1/0}, lambda{raise SpecificExampleException}].each do |block|
+        begin
+          block.call
+        rescue SpecificExampleException, ZeroDivisionError
+        end
+      end
+    end.should_not raise_error
+  end
+
+  pending "can rescue a splatted list of exceptions" do
+    caught_it = false
+    begin
+      raise SpecificExampleException, "not important"
+    rescue *exception_list
+      caught_it = true
+    end
+    caught_it.should be_true
+    caught = []
+    lambda do
+      [lambda{1/0}, lambda{raise SpecificExampleException}].each do |block|
+        begin
+          block.call
+        rescue *exception_list
+          caught << $!
+        end
+      end
+    end.should_not raise_error
+    caught.size.should == 2
+    exception_list.each do |exception_class|
+      caught.map{|e| e.class}.include?(exception_class).should be_true
+    end
+  end
+
+  pending "will only rescue the specified exceptions when doing a splat rescue" do
+    lambda do
+      begin
+        raise OtherCustomException, "not rescued!"
+      rescue *exception_list
+      end
+    end.should raise_error(OtherCustomException)
+  end
+
+  pending "will execute an else block only if no exceptions were raised" do
+    # begin
+    #   ScratchPad << :one
+    # rescue
+    #   ScratchPad << :does_not_run
+    # else
+    #   ScratchPad << :two
+    # end
+    # ScratchPad.recorded.should == [:one, :two]
+  end
+
+  pending "will not execute an else block if an exception was raised" do
+    # begin
+    #   ScratchPad << :one
+    #   raise "an error occurred"
+    # rescue
+    #   ScratchPad << :two
+    # else
+    #   ScratchPad << :does_not_run
+    # end
+    # ScratchPad.recorded.should == [:one, :two]
+  end
+
+  pending "will not rescue errors raised in an else block in the rescue block above it" do
+    # lambda do
+    #   begin
+    #     ScratchPad << :one
+    #   rescue Exception => e
+    #     ScratchPad << :does_not_run
+    #   else
+    #     ScratchPad << :two
+    #     raise SpecificExampleException, "an error from else"
+    #   end
+    # end.should raise_error(SpecificExampleException)
+    # ScratchPad.recorded.should == [:one, :two]
+  end
+
+  ruby_version_is "1.9" do
+    pending "parses  'a += b rescue c' as 'a += (b rescue c)'" do
+      a = 'a'
+      c = 'c'
+      # a += b rescue c
+      a.should == 'ac'
+    end
+  end
+end