opal 0.10.0 → 0.11.0

data/spec/opal/core/language/fixtures/block.rb

@@ -1,57 +0,0 @@
-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/opal/core/language/fixtures/break.rb

@@ -1,240 +0,0 @@
-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

data/spec/opal/core/language/fixtures/ensure.rb

@@ -1,72 +0,0 @@
-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/opal/core/language/fixtures/literal_lambda.rb

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

data/spec/opal/core/language/fixtures/metaclass.rb

@@ -1,33 +0,0 @@
-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/opal/core/language/fixtures/module.rb

@@ -1,24 +0,0 @@
-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/opal/core/language/fixtures/next.rb

@@ -1,128 +0,0 @@
-class NextSpecs
-  def self.yielding_method(expected)
-    yield.should == expected
-    :method_return_value
-  end
-
-  def self.yielding
-    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
-      begin
-        ScratchPad << :begin
-        x = false
-        if arg
-          next 42
-        else
-          next
-        end
-      ensure
-        ScratchPad << :ensure
-      end
-    end
-  end
-
-  def self.while_within_iter(arg)
-    yielding do
-      x = true
-      while x
-        begin
-          ScratchPad << :begin
-          x = false
-          if arg
-            next 42
-          else
-            next
-          end
-        ensure
-          ScratchPad << :ensure
-        end
-      end
-    end
-  end
-
-  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.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.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

data/spec/opal/core/language/fixtures/return.rb

@@ -1,118 +0,0 @@
-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