opal 0.3.41 → 0.3.42

data/spec/language/module_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/module', __FILE__)
+
+describe "The module keyword" do
+  pending "creates a new module with a non-qualified constant name" do
+    module ModuleSpecsToplevel; end
+    ModuleSpecsToplevel.should be_an_instance_of(Module)
+  end
+
+  pending "creates a new module with a qualified constant name" do
+    module ModuleSpecs::Nested; end
+    ModuleSpecs::Nested.should be_an_instance_of(Module)
+  end
+
+  pending "creates a new module with a variable qualified constant name" do
+    m = Module.new
+    module m::N; end
+    m::N.should be_an_instance_of(Module)
+  end
+
+  pending "reopens an existing module" do
+    module ModuleSpecs; Reopened = true; end
+    ModuleSpecs::Reopened.should be_true
+  end
+
+  pending "reopens a module included in Object" do
+    module IncludedModuleSpecs; Reopened = true; end
+    ModuleSpecs::IncludedInObject::IncludedModuleSpecs::Reopened.should be_true
+  end
+
+  pending "raises a TypeError if the constant is a Class" do
+    lambda do
+      module ModuleSpecs::Modules::Klass; end
+    end.should raise_error(TypeError)
+  end
+
+  pending "raises a TypeError if the constant is a String" do
+    lambda { module ModuleSpecs::Modules::A; end }.should raise_error(TypeError)
+  end
+
+  pending "raises a TypeError if the constant is a Fixnum" do
+    lambda { module ModuleSpecs::Modules::B; end }.should raise_error(TypeError)
+  end
+
+  pending "raises a TypeError if the constant is nil" do
+    lambda { module ModuleSpecs::Modules::C; end }.should raise_error(TypeError)
+  end
+
+  pending "raises a TypeError if the constant is true" do
+    lambda { module ModuleSpecs::Modules::D; end }.should raise_error(TypeError)
+  end
+
+  pending "raises a TypeError if the constant is false" do
+    lambda { module ModuleSpecs::Modules::D; end }.should raise_error(TypeError)
+  end
+end

data/spec/language/next_spec.rb

@@ -1,3 +1,4 @@
+require File.expand_path('../../spec_helper', __FILE__)
 require File.expand_path('../fixtures/next', __FILE__)
 
 describe "The next statement from within the block" do
@@ -38,17 +39,33 @@ describe "The next statement from within the block" do
     }.should == :method_return_value
 
     NextSpecs.yielding_method(1) {
-      next 1;
+      next 1
       fail("next didn't end the block execution")
     }.should == :method_return_value
 
     NextSpecs.yielding_method([1, 2, 3]) {
-      next 1, 2, 3;
+      next 1, 2, 3
       fail("next didn't end the block execution")
     }.should == :method_return_value
   end
 
-  it "returns to the currently yielding method in case of chained calls" do
+  pending "returns to the currently yielding method in case of chained calls" do
+    class ChainedNextTest
+      def self.meth_with_yield(&b)
+        yield.should == :next_return_value
+        :method_return_value
+      end
+      def self.invoking_method(&b)
+        meth_with_yield(&b)
+      end
+      def self.enclosing_method
+        invoking_method do
+          next :next_return_value
+          :wrong_return_value
+        end
+      end
+    end
+
     ChainedNextTest.enclosing_method.should == :method_return_value
   end
 
@@ -64,6 +81,24 @@ describe "The next statement from within the block" do
 
     ScratchPad.recorded.should == [:begin, :ensure]
   end
+
+  it "skips following code outside an exception block" do
+    3.times do |i|
+      begin
+        ScratchPad << :begin
+        next if i == 0
+        break if i == 2
+        ScratchPad << :begin_end
+      ensure
+        ScratchPad << :ensure
+      end
+
+      ScratchPad << :after
+    end
+
+    ScratchPad.recorded.should == [
+      :begin, :ensure, :begin, :begin_end, :ensure, :after, :begin, :ensure]
+  end
 end
 
 describe "The next statement" do
@@ -73,10 +108,6 @@ describe "The next statement" do
 
   describe "in a while loop" do
     describe "when not passed an argument" do
-      before :each do
-        ScratchPad.record []
-      end
-
       it "causes ensure blocks to run" do
         NextSpecs.while_next(false)
 
@@ -91,10 +122,6 @@ describe "The next statement" do
     end
 
     describe "when passed an argument" do
-      before :each do
-        ScratchPad.record []
-      end
-
       it "causes ensure blocks to run" do
         NextSpecs.while_next(true)
 
@@ -107,5 +134,336 @@ describe "The next statement" do
         ScratchPad.recorded.should == [:begin, :ensure]
       end
     end
+
+    it "causes nested ensure blocks to run" do
+      x = true
+      while x
+        begin
+          ScratchPad << :outer_begin
+          x = false
+          begin
+            ScratchPad << :inner_begin
+            next
+          ensure
+            ScratchPad << :inner_ensure
+          end
+        ensure
+          ScratchPad << :outer_ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:outer_begin, :inner_begin, :inner_ensure, :outer_ensure]
+    end
+
+    it "causes ensure blocks to run when mixed with break" do
+      x = 1
+      while true
+        begin
+          ScratchPad << :begin
+          break if x > 1
+          x += 1
+          next
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:begin, :ensure, :begin, :ensure]
+    end
+  end
+
+  describe "in an until loop" do
+    describe "when not passed an argument" do
+      it "causes ensure blocks to run" do
+        NextSpecs.until_next(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.until_within_iter(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+
+    describe "when passed an argument" do
+      it "causes ensure blocks to run" do
+        NextSpecs.until_next(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.until_within_iter(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+
+    it "causes nested ensure blocks to run" do
+      x = false
+      until x
+        begin
+          ScratchPad << :outer_begin
+          x = true
+          begin
+            ScratchPad << :inner_begin
+            next
+          ensure
+            ScratchPad << :inner_ensure
+          end
+        ensure
+          ScratchPad << :outer_ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:outer_begin, :inner_begin, :inner_ensure, :outer_ensure]
+    end
+
+    it "causes ensure blocks to run when mixed with break" do
+      x = 1
+      until false
+        begin
+          ScratchPad << :begin
+          break if x > 1
+          x += 1
+          next
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:begin, :ensure, :begin, :ensure]
+    end
+  end
+
+  describe "in a loop" do
+    describe "when not passed an argument" do
+      it "causes ensure blocks to run" do
+        NextSpecs.loop_next(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.loop_within_iter(false)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+
+    describe "when passed an argument" do
+      it "causes ensure blocks to run" do
+        NextSpecs.loop_next(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+
+      it "causes ensure blocks to run when nested in an block" do
+        NextSpecs.loop_within_iter(true)
+
+        ScratchPad.recorded.should == [:begin, :ensure]
+      end
+    end
+
+    it "causes nested ensure blocks to run" do
+      x = 1
+      loop do
+        break if x == 2
+
+        begin
+          ScratchPad << :outer_begin
+          begin
+            ScratchPad << :inner_begin
+            x += 1
+            next
+          ensure
+            ScratchPad << :inner_ensure
+          end
+        ensure
+          ScratchPad << :outer_ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:outer_begin, :inner_begin, :inner_ensure, :outer_ensure]
+    end
+
+    it "causes ensure blocks to run when mixed with break" do
+      x = 1
+      loop do
+        begin
+          ScratchPad << :begin
+          break if x > 1
+          x += 1
+          next
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:begin, :ensure, :begin, :ensure]
+    end
+ end
+end
+
+describe "Assignment via next" do
+  it "assigns objects" do
+    def r(val); a = yield(); val.should == a; end
+    r(nil){next}
+    r(nil){next nil}
+    r(1){next 1}
+    r([]){next []}
+    r([1]){next [1]}
+    r([nil]){next [nil]}
+    r([[]]){next [[]]}
+    r([]){next [*[]]}
+    r([1]){next [*[1]]}
+    r([1,2]){next [*[1,2]]}
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "assigns splatted objects" do
+      def r(val); a = yield(); val.should == a; end
+      r(nil){next *nil}
+      r(1){next *1}
+      r(nil){next *[]}
+      r(1){next *[1]}
+      r(nil){next *[nil]}
+      r([]){next *[[]]}
+      r(nil){next *[*[]]}
+      r(1){next *[*[1]]}
+      r([1,2]){next *[*[1,2]]}
+    end
+  end
+
+  ruby_version_is "1.9" do
+    pending "assigns splatted objects" do
+      def r(val); a = yield(); val.should == a; end
+      r([]){next *nil}
+      r([1]){next *1}
+      r([]){next *[]}
+      r([1]){next *[1]}
+      r([nil]){next *[nil]}
+      r([[]]){next *[[]]}
+      r([]){next *[*[]]}
+      r([1]){next *[*[1]]}
+      r([1,2]){next *[*[1,2]]}
+    end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "assigns objects to a splatted reference" do
+      def r(val); *a = yield(); val.should == a; end
+      r([nil]){next}
+      r([nil]){next nil}
+      r([1]){next 1}
+      r([[]]){next []}
+      r([[1]]){next [1]}
+      r([[nil]]){next [nil]}
+      r([[[]]]){next [[]]}
+      r([[1,2]]){next [1,2]}
+      r([[]]){next [*[]]}
+      r([[1]]){next [*[1]]}
+      r([[1,2]]){next [*[1,2]]}
+    end
   end
-end
+
+  ruby_version_is "1.9" do
+    pending "assigns objects to a splatted reference" do
+      def r(val); *a = yield(); val.should == a; end
+      r([nil]){next}
+      r([nil]){next nil}
+      r([1]){next 1}
+      r([]){next []}
+      r([1]){next [1]}
+      r([nil]){next [nil]}
+      r([[]]){next [[]]}
+      r([1,2]){next [1,2]}
+      r([]){next [*[]]}
+      r([1]){next [*[1]]}
+      r([1,2]){next [*[1,2]]}
+    end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "assigns splatted objects to a splatted reference via a splatted yield" do
+      def r(val); *a = *yield(); val.should == a; end
+      r([nil]){next *nil}
+      r([1]){next *1}
+      r([nil]){next *[]}
+      r([1]){next *[1]}
+      r([nil]){next *[nil]}
+      r([]){next *[[]]}
+      r([1,2]){next *[1,2]}
+      r([nil]){next *[*[]]}
+      r([1]){next *[*[1]]}
+      r([1,2]){next *[*[1,2]]}
+    end
+  end
+
+  ruby_version_is "1.9" do
+    pending "assigns splatted objects to a splatted reference via a splatted yield" do
+      def r(val); *a = *yield(); val.should == a; end
+      r([]){next *nil}
+      r([1]){next *1}
+      r([]){next *[]}
+      r([1]){next *[1]}
+      r([nil]){next *[nil]}
+      r([[]]){next *[[]]}
+      r([1,2]){next *[1,2]}
+      r([]){next *[*[]]}
+      r([1]){next *[*[1]]}
+      r([1,2]){next *[*[1,2]]}
+    end
+  end
+
+  it "assigns objects to multiple variables" do
+    def r(val); a,b,*c = yield(); val.should == [a,b,c]; end
+    r([nil,nil,[]]){next}
+    r([nil,nil,[]]){next nil}
+    r([1,nil,[]]){next 1}
+    r([nil,nil,[]]){next []}
+    r([1,nil,[]]){next [1]}
+    r([nil,nil,[]]){next [nil]}
+    r([[],nil,[]]){next [[]]}
+    r([1,2,[]]){next [1,2]}
+    r([nil,nil,[]]){next [*[]]}
+    r([1,nil,[]]){next [*[1]]}
+    r([1,2,[]]){next [*[1,2]]}
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "assigns splatted objects to multiple variables" do
+      def r(val); a,b,*c = *yield(); val.should == [a,b,c]; end
+      r([nil,nil,[]]){next *nil}
+      r([1,nil,[]]){next *1}
+      r([nil,nil,[]]){next *[]}
+      r([1,nil,[]]){next *[1]}
+      r([nil,nil,[]]){next *[nil]}
+      r([nil,nil,[]]){next *[[]]}
+      r([1,2,[]]){next *[1,2]}
+      r([nil,nil,[]]){next *[*[]]}
+      r([1,nil,[]]){next *[*[1]]}
+      r([1,2,[]]){next *[*[1,2]]}
+    end
+  end
+
+  ruby_version_is "1.9" do
+    pending "assigns splatted objects to multiple variables" do
+      def r(val); a,b,*c = *yield(); val.should == [a,b,c]; end
+      r([nil,nil,[]]){next *nil}
+      r([1,nil,[]]){next *1}
+      r([nil,nil,[]]){next *[]}
+      r([1,nil,[]]){next *[1]}
+      r([nil,nil,[]]){next *[nil]}
+      r([[],nil,[]]){next *[[]]}
+      r([1,2,[]]){next *[1,2]}
+      r([nil,nil,[]]){next *[*[]]}
+      r([1,nil,[]]){next *[*[1]]}
+      r([1,2,[]]){next *[*[1,2]]}
+    end
+  end
+end
+
+# language_version __FILE__, "next"