opal 0.3.41 → 0.3.42

data/spec/language/defined_spec.rb

@@ -45,14 +45,12 @@ describe "The defined? keyword when called with a method name" do
       defined?(Kernel.puts).should == "method"
     end
 
-    it "returns nil if the method is private" do
-      # FIXME: should opal-spec have some special not_opal_compatible error that is similar to skip?
-      #defined?(Object.print).should be_nil
+    pending "returns nil if the method is private" do
+      defined?(Object.print).should be_nil
     end
 
-    it "returns nil if the method is protected" do
-      # FIXME: see above
-      # defined?(DefinedSpecs::Basic.new.protected_method).should be_nil
+    pending "returns nil if the method is protected" do
+      defined?(DefinedSpecs::Basic.new.protected_method).should be_nil
     end
 
     it "returns nil if the method is not defined" do
@@ -83,4 +81,18 @@ describe "The defined? keyword when called with a method name" do
       defined?(@defined_specs_obj.an_undefined_method).should be_nil
     end
   end
-end
+end
+
+describe "The defined? keyword for ivars" do
+  it "returns 'instace-variable' if assigned" do
+    @assigned_ivar = "some value"
+    ret = defined?(@assigned_ivar)
+    ret.should == "instance-variable"
+  end
+
+  it "returns 'instace-variable' if not assigned" do
+    ret = defined?(@unassigned_ivar)
+    ret.should == "nil"
+  end
+end
+

data/spec/language/ensure_spec.rb

@@ -1,40 +1,5 @@
-module EnsureSpec
-  class Container
-    attr_reader :executed
-
-    def initialize
-      @executed = []
-    end
-
-    def raise_in_method_with_ensure
-      @executed << :method
-      raise "An Exception"
-    ensure
-      @executed << :ensure
-    end
-
-    def raise_and_rescue_in_method_with_ensure
-      @executed << :method
-      raise "An Exception"
-    rescue => e
-      @executed << :rescue
-    ensure
-      @executed << :ensure
-    end
-
-    def implicit_return_in_method_with_ensure
-      :method
-    ensure
-      :ensure
-    end
-
-    def explicit_return_in_method_with_ensure
-      return :method
-    ensure
-      return :ensure
-    end
-  end
-end
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/ensure', __FILE__)
 
 describe "An ensure block inside a begin block" do
   before :each do
@@ -61,7 +26,7 @@ describe "An ensure block inside a begin block" do
       begin
         ScratchPad << :begin
         raise "An exception occured!"
-      rescue => e
+      rescue
         ScratchPad << :rescue
       ensure
         ScratchPad << :ensure
@@ -71,6 +36,23 @@ describe "An ensure block inside a begin block" do
     end
   end
 
+  pending "is executed even when a symbol is thrown in it's corresponding begin block" do
+    begin
+      catch(:symbol) do
+        begin
+          ScratchPad << :begin
+          throw(:symbol)
+        rescue
+          ScratchPad << :rescue
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+
+      ScratchPad.recorded.should == [:begin, :ensure]
+    end
+  end
+
   it "is executed when nothing is raised or thrown in it's corresponding begin block" do
     begin
       ScratchPad << :begin
@@ -107,6 +89,11 @@ describe "An ensure block inside a method" do
     @obj.executed.should == [:method, :rescue, :ensure]
   end
 
+  pending "is executed even when a symbol is thrown in the method" do
+    catch(:symbol) { @obj.throw_in_method_with_ensure }
+    @obj.executed.should == [:method, :ensure]
+  end
+
   it "has no impact on the method's implicit return value" do
     @obj.implicit_return_in_method_with_ensure.should == :method
   end
@@ -114,4 +101,4 @@ describe "An ensure block inside a method" do
   it "has an impact on the method's explicit return value" do
     @obj.explicit_return_in_method_with_ensure.should == :ensure
   end
-end
+end

data/spec/language/execution_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "``" do
+  pending "returns the output of the executed sub-process" do
+    ip = 'world'
+    # `echo disc #{ip}`.should == "disc world\n"
+  end
+end
+
+describe "%x" do
+  pending "is the same as ``" do
+    ip = 'world'
+    # %x(echo disc #{ip}).should == "disc world\n"
+  end
+end

data/spec/language/fixtures/array.rb

@@ -0,0 +1,11 @@
+module ArraySpec
+  class Splat
+    def unpack_3args(a, b, c)
+      [a, b, c]
+    end
+
+    def unpack_4args(a, b, c, d)
+      [a, b, c, d]
+    end
+  end
+end

data/spec/language/fixtures/block.rb

@@ -0,0 +1,57 @@
+module BlockSpecs
+  class Yielder
+    def z
+      yield
+    end
+
+    def m(*a)
+      yield(*a)
+    end
+
+    def s(a)
+      yield(a)
+    end
+
+    def r(a)
+      yield(*a)
+    end
+  end
+
+  # TODO: rewrite all specs that use Yield to use Yielder
+
+  class Yield
+    def splat(*args)
+      yield *args
+    end
+
+    def two_args
+      yield 1, 2
+    end
+
+    def two_arg_array
+      yield [1, 2]
+    end
+
+    def yield_splat_inside_block
+      [1, 2].send(:each_with_index) {|*args| yield(*args)}
+    end
+
+    def yield_this(obj)
+      yield obj
+    end
+  end
+
+  class OverwriteBlockVariable
+    def initialize
+      @y = Yielder.new
+    end
+
+    def method_missing(method, *args, &block)
+      self.class.send :define_method, method do |*args, &block|
+        @y.send method, *args, &block
+      end
+
+      send method, *args, &block
+    end
+  end
+end

data/spec/language/fixtures/break.rb

@@ -0,0 +1,240 @@
+module BreakSpecs
+  class Driver
+    def initialize(ensures=false)
+      @ensures = ensures
+    end
+
+    def note(value)
+      ScratchPad << value
+    end
+  end
+
+  class Block < Driver
+    def break_nil
+      note :a
+      note yielding {
+        note :b
+        break
+        note :c
+      }
+      note :d
+    end
+
+    def break_value
+      note :a
+      note yielding {
+        note :b
+        break :break
+        note :c
+      }
+      note :d
+    end
+
+    def yielding
+      note :aa
+      note yield
+      note :bb
+    end
+
+    def create_block
+      note :za
+      b = capture_block do
+        note :zb
+        break :break
+        note :zc
+      end
+      note :zd
+      b
+    end
+
+    def capture_block(&b)
+      note :xa
+      b
+    end
+
+    def break_in_method_captured
+      note :a
+      create_block.call
+      note :b
+    end
+
+    def break_in_yield_captured
+      note :a
+      yielding(&create_block)
+      note :b
+    end
+
+    def break_in_method
+      note :a
+      b = capture_block {
+        note :b
+        break :break
+        note :c
+      }
+      note :d
+      note b.call
+      note :e
+    end
+
+    def call_method(b)
+      note :aa
+      note b.call
+      note :bb
+    end
+
+    def break_in_nested_method
+      note :a
+      b = capture_block {
+        note :b
+        break :break
+        note :c
+      }
+      note :c
+      note call_method(b)
+      note :d
+    end
+
+    def break_in_yielding_method
+      note :a
+      b = capture_block {
+        note :b
+        break :break
+        note :c
+      }
+      note :c
+      note yielding(&b)
+      note :d
+    end
+  end
+
+  class Lambda < Driver
+    # Cases for the invocation of the scope defining the lambda still active
+    # on the call stack when the lambda is invoked.
+    def break_in_defining_scope(value=true)
+      note :a
+      note lambda {
+        note :b
+        if value
+          break :break
+        else
+          break
+        end
+        note :c
+      }.call
+      note :d
+    end
+
+    def break_in_nested_scope
+      note :a
+      l = lambda do
+        note :b
+        break :break
+        note :c
+      end
+      note :d
+
+      invoke_lambda l
+
+      note :e
+    end
+
+    def invoke_lambda(l)
+      note :aa
+      note l.call
+      note :bb
+    end
+
+    def break_in_nested_scope_yield
+      note :a
+      l = lambda do
+        note :b
+        break :break
+        note :c
+      end
+      note :d
+
+      note invoke_yield(&l)
+
+      note :e
+    end
+
+    def note_invoke_yield
+      note :aa
+      note yield
+      note :bb
+    end
+
+    def break_in_nested_scope_block
+      note :a
+      l = lambda do
+        note :b
+        break :break
+        note :c
+      end
+      note :d
+
+      invoke_lambda_block l
+
+      note :e
+    end
+
+    def invoke_yield
+      note :aaa
+      yield
+      note :bbb
+    end
+
+    def invoke_lambda_block(b)
+      note :aa
+      invoke_yield do
+        note :bb
+
+        note b.call
+
+        note :cc
+      end
+      note :dd
+    end
+
+    # Cases for the invocation of the scope defining the lambda NOT still
+    # active on the call stack when the lambda is invoked.
+    def create_lambda
+      note :la
+      l = lambda do
+        note :lb
+        break :break
+        note :lc
+      end
+      note :ld
+      l
+    end
+
+    def break_in_method
+      note :a
+
+      note create_lambda.call
+
+      note :b
+    end
+
+    def break_in_block_in_method
+      note :a
+      invoke_yield do
+        note :b
+
+        note create_lambda.call
+
+        note :c
+      end
+      note :d
+    end
+
+    def break_in_method_yield
+      note :a
+
+      invoke_yield(&create_lambda)
+
+      note :b
+    end
+  end
+end