opal 0.3.41 → 0.3.42

data/spec/language/fixtures/ensure.rb

@@ -0,0 +1,72 @@
+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
+      @executed << :rescue
+    ensure
+      @executed << :ensure
+    end
+
+    def throw_in_method_with_ensure
+      @executed << :method
+      throw(:symbol)
+    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
+
+module EnsureSpec
+
+  class Test
+
+    def initialize
+      @values = []
+    end
+
+    attr_reader :values
+
+    def call_block
+      begin
+        @values << :start
+        yield
+      ensure
+        @values << :end
+      end
+    end
+
+    def do_test
+      call_block do
+        @values << :in_block
+        return :did_test
+      end
+    end
+  end
+end

data/spec/language/fixtures/literal_lambda.rb

@@ -0,0 +1,7 @@
+module LiteralLambdaMethods
+  SOME_CONSTANT = "some value"
+  def self.literal_lambda_with_constant
+    ->{SOME_CONSTANT}
+  end
+  # module_function :literal_lambda_with_constant
+end

data/spec/language/fixtures/metaclass.rb

@@ -0,0 +1,33 @@
+module MetaClassSpecs
+
+  def self.metaclass_of obj
+    class << obj
+      self
+    end
+  end
+
+  class A
+    def self.cheese
+      'edam'
+    end
+  end
+
+  class B < A
+    def self.cheese
+      'stilton'
+    end
+  end
+
+  class C
+    class << self
+      class << self
+        def ham
+          'iberico'
+        end
+      end
+    end
+  end
+
+  class D < C; end
+
+end

data/spec/language/fixtures/module.rb

@@ -0,0 +1,24 @@
+module ModuleSpecs
+  module Modules
+    class Klass
+    end
+
+    A = "Module"
+    B = 1
+    C = nil
+    D = true
+    E = false
+  end
+
+  module Anonymous
+  end
+
+  module IncludedInObject
+    module IncludedModuleSpecs
+    end
+  end
+end
+
+class Object
+  include ModuleSpecs::IncludedInObject
+end

data/spec/language/fixtures/next.rb

@@ -8,6 +8,12 @@ class NextSpecs
     yield
   end
 
+  # The methods below are defined to spec the behavior of the next statement
+  # while specifically isolating whether the statement is in an Iter block or
+  # not. In a normal spec example, the code is always nested inside a block.
+  # Rather than rely on that implicit context in this case, the context is
+  # made explicit because of the interaction of next in a loop nested inside
+  # an Iter block.
   def self.while_next(arg)
     x = true
     while x
@@ -43,20 +49,80 @@ class NextSpecs
       end
     end
   end
-end
 
-class ChainedNextTest
-  def self.meth_with_yield(&b)
-    yield.should == :next_return_value
-    :method_return_value
+  def self.until_next(arg)
+    x = false
+    until x
+      begin
+        ScratchPad << :begin
+        x = true
+        if arg
+          next 42
+        else
+          next
+        end
+      ensure
+        ScratchPad << :ensure
+      end
+    end
+  end
+
+  def self.until_within_iter(arg)
+    yielding do
+      x = false
+      until x
+        begin
+          ScratchPad << :begin
+          x = true
+          if arg
+            next 42
+          else
+            next
+          end
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+    end
   end
-  def self.invoking_method(&b)
-    meth_with_yield(&b)
+
+  def self.loop_next(arg)
+    x = 1
+    loop do
+      break if x == 2
+
+      begin
+        ScratchPad << :begin
+        x += 1
+        if arg
+          next 42
+        else
+          next
+        end
+      ensure
+        ScratchPad << :ensure
+      end
+    end
   end
-  def self.enclosing_method
-    invoking_method do
-      next :next_return_value
-      :wrong_return_value
+
+  def self.loop_within_iter(arg)
+    yielding do
+      x = 1
+      loop do
+        break if x == 2
+
+        begin
+          ScratchPad << :begin
+          x += 1
+          if arg
+            next 42
+          else
+            next
+          end
+        ensure
+          ScratchPad << :ensure
+        end
+      end
     end
   end
-end
+end

data/spec/language/fixtures/return.rb

@@ -0,0 +1,118 @@
+module ReturnSpecs
+  class Blocks
+    def yielding_method
+      yield
+      ScratchPad.record :after_yield
+    end
+
+    def enclosing_method
+      yielding_method do
+        ScratchPad.record :before_return
+        return :return_value
+        ScratchPad.record :after_return
+      end
+
+      ScratchPad.record :after_call
+    end
+  end
+
+  class NestedCalls < Blocks
+    def invoking_method(&b)
+      yielding_method(&b)
+      ScratchPad.record :after_invoke
+    end
+
+    def enclosing_method
+      invoking_method do
+        ScratchPad.record :before_return
+        return :return_value
+        ScratchPad.record :after_return
+      end
+      ScratchPad.record :after_invoke
+    end
+  end
+
+  class NestedBlocks < Blocks
+    def enclosing_method
+      yielding_method do
+        yielding_method do
+          ScratchPad.record :before_return
+          return :return_value
+          ScratchPad.record :after_return
+        end
+        ScratchPad.record :after_invoke1
+      end
+      ScratchPad.record :after_invoke2
+    end
+  end
+
+  class SavedInnerBlock
+    def add(&b)
+      @block = b
+    end
+
+    def outer
+      yield
+      @block.call
+    end
+
+    def inner
+      yield
+    end
+
+    def start
+      outer do
+        inner do
+          add do
+            ScratchPad.record :before_return
+            return :return_value
+          end
+        end
+      end
+
+      ScratchPad.record :bottom_of_start
+
+      return false
+    end
+  end
+
+  class ThroughDefineMethod
+    lamb = proc { |x| x.call }
+    define_method :foo, lamb
+
+    def mp(&b); b; end
+
+    def outer
+      pr = mp { return :good }
+
+      foo(pr)
+      return :bad
+    end
+  end
+
+  class DefineMethod
+    lamb = proc { return :good }
+    define_method :foo, lamb
+
+    def outer
+      val = :bad
+
+      # This is tricky, but works. If lamb properly returns, then the
+      # return value will go into val before we run the ensure.
+      #
+      # If lamb's return keeps unwinding incorrectly, val will still
+      # have it's old value.
+      #
+      # We can therefore use val to figure out what happened.
+      begin
+        val = foo()
+      ensure
+        if val != :good
+          return :bad
+        end
+      end
+
+      return val
+    end
+  end
+end

data/spec/language/fixtures/send.rb

@@ -0,0 +1,110 @@
+module LangSendSpecs
+  # module_function
+
+  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 oneb(a,&b); [a,yield(b)]; end
+  # def twob(a,b,&c); [a,b,yield(c)]; end
+  def self.makeproc(&b) b end
+
+  # def yield_now; yield; end
+
+  def self.double(x); x * 2 end
+  def self.weird_parens
+    # means double((5).to_s)
+    # NOT   (double(5)).to_s
+    double (5).to_s
+  end
+
+  def self.rest_len(*a); a.size; end
+
+  def self.twos(a,b,*c)
+    [c.size, c.last]
+  end
+
+  class PrivateSetter
+    attr_reader :foo
+    attr_writer :foo
+    private :foo=
+
+      def call_self_foo_equals(value)
+        self.foo = value
+      end
+
+    def call_self_foo_equals_masgn(value)
+      a, self.foo = 1, value
+    end
+  end
+  
+  class PrivateGetter
+    attr_reader :foo
+    private :foo
+
+    def call_self_foo
+      self.foo
+    end
+
+    def call_self_foo_or_equals(value)
+      # self.foo ||= 6
+    end
+  end
+
+  class AttrSet
+    attr_reader :result
+    def []=(a, b, c, d); @result = [a,b,c,d]; end
+  end
+
+  class ToProc
+    def initialize(val)
+      @val = val
+    end
+
+    def to_proc
+      Proc.new { @val }
+    end
+  end
+
+  class ToAry
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def to_ary
+      @obj
+    end
+  end
+
+  class MethodMissing
+    def initialize
+      @message = nil
+      @args = nil
+    end
+
+    attr_reader :message, :args
+
+    def method_missing(m, *a)
+      @message = m
+      @args = a
+    end
+  end
+end
+
+def lang_send_rest_len(*a)
+  a.size
+end