opal-cj 0.7.0.beta1

data/spec/opal/core/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/opal/core/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/opal/core/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

data/spec/opal/core/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/opal/core/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/opal/core/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/opal/core/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