opal-cj 0.7.0.beta1

data/spec/opal/core/runtime/constants_spec.rb

@@ -0,0 +1,13 @@
+describe "Missing constants" do
+  it "should raise a NameError when trying to access an undefined constant" do
+    lambda { ThisConstantDoesNotExist }.should raise_error(NameError)
+  end
+
+  it "raises an error for missing constants on base constant scope" do
+    lambda { Object::SomeRandomObjectName }.should raise_error(NameError)
+  end
+
+  it "raises an error for missing constants on root constant scope" do
+    lambda { ::YetAnotherMissingConstant }.should raise_error(NameError)
+  end
+end

data/spec/opal/core/runtime/eval_spec.rb

@@ -0,0 +1,5 @@
+describe "Opal.eval()" do
+  it "evaluates ruby code by compiling it to javascript and running" do
+    `Opal.eval("'foo'.class")`.should == String
+  end
+end

data/spec/opal/core/runtime/main_methods_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+$OPAL_TOP_LEVEL_OBJECT = self
+
+def self.some_main_method
+  3.142
+end
+
+def some_top_level_method_is_defined
+  42
+end
+
+describe "Defining normal methods at the top level" do
+  it "should define them on Object, not main" do
+    Object.new.some_top_level_method_is_defined.should == 42
+  end
+end
+
+describe "Defining singleton methods on main" do
+  it "should define it on main directly" do
+    $OPAL_TOP_LEVEL_OBJECT.some_main_method.should == 3.142
+  end
+
+  it "should not define the method for all Objects" do
+    lambda { Object.new.some_main_method }.should raise_error(NoMethodError)
+  end
+end

data/spec/opal/core/runtime/method_missing_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module MethodMissingSpecs
+  class A
+    def method_missing(mid, *args)
+      [mid, args]
+    end
+  end
+
+  class B
+    def method_missing(mid, *args, &block)
+      [mid, block]
+    end
+  end
+end
+
+class BridgedClass < `(function NativeConstructor(){})`
+end
+
+describe "method_missing" do
+  before do
+    @obj = MethodMissingSpecs::A.new
+  end
+
+  it "should pass the missing method name as first argument" do
+    @obj.foo.should == [:foo, []]
+  end
+
+  it "should correctly pass arguments to method_missing" do
+    @obj.bar(1, 2, 3).should == [:bar, [1, 2, 3]]
+  end
+
+  it "should pass blocks to method_missing" do
+    obj = MethodMissingSpecs::B.new
+    proc = proc { 1 }
+    obj.baz(1, 2, &proc).should == [:baz, proc]
+  end
+end
+
+describe "BasicObject#method_missing" do
+  it "raises an error for the missing method" do
+    lambda {
+      BasicObject.new.foo_bar_baz
+    }.should raise_error(Exception)
+  end
+end
+
+describe "Array#method_missing" do
+  it "raises an error for the missing method" do
+    lambda {
+      BasicObject.new.foo_bar_baz
+    }.should raise_error(Exception)
+  end
+end
+
+describe "<BridgedClass>#method_missing" do
+  it "raises an error for the missing method" do
+    lambda {
+      BridgedClass.new.foo_bar_baz
+    }.should raise_error(Exception)
+  end
+end

data/spec/opal/core/runtime/method_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module OpalMethodSpec
+  class C
+    def foo; :C; end
+  end
+
+  module M
+    def foo; :M; end
+    def bar; :M; end
+  end
+
+  module N
+    def bar; :N; end
+  end
+
+  class C
+    include M
+    include N
+  end
+end
+
+describe "Including modules in a class with methods already defined in class" do
+  it "should always call the method defined in a class first" do
+    OpalMethodSpec::C.new.foo.should == :C
+  end
+
+  it "should call the method from the last module included unless class defines method" do
+    OpalMethodSpec::C.new.bar.should == :N
+  end
+end

data/spec/opal/core/runtime/operator_call_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Operator calls" do
+  before { @obj = {:value => 10} }
+
+  it "compiles as a normal send method call" do
+    @obj[:value] += 15
+    @obj[:value].should == 25
+
+    @obj[:value] -= 23
+    @obj[:value].should == 2
+  end
+end

data/spec/opal/core/runtime/paren_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Parens" do
+  it "can be used to group expressions" do
+    (self.class; self.to_s; 42).should == 42
+    (3.142).should == 3.142
+    ().should == nil
+  end
+
+  it "generates code that contains the expression in precedence" do
+    foo = 100
+    ((foo += 42) == 142).should == true
+  end
+end

data/spec/opal/core/runtime/rescue_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class RescueReturningSpec
+  def single
+    begin
+      raise "ERROR"
+    rescue
+      :foo
+    end
+  end
+
+  def multiple
+    begin
+      raise "ERROR"
+    rescue
+      to_s
+      :bar
+    end
+  end
+
+  def empty_rescue
+    begin
+      raise "ERROR"
+    rescue
+    end
+  end
+end
+
+describe "The rescue keyword" do
+  it "returns last value of expression evaluated" do
+    RescueReturningSpec.new.single.should == :foo
+    RescueReturningSpec.new.multiple.should == :bar
+  end
+
+  it "returns nil if no expr given in rescue body" do
+    RescueReturningSpec.new.empty_rescue.should be_nil
+  end
+end

data/spec/opal/core/runtime/return_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class OpalReturnSpec
+  def returning_expression
+    (false || return)
+  end
+
+  def returning_block
+    @values = []
+
+    [1, 2, 3, 4, 5].each do |n|
+      return if n == 3
+      @values << n
+    end
+  end
+
+  attr_reader :values
+
+  def returning_block_value
+    [1, 2, 3, 4, 5].each { return :foo }
+  end
+end
+
+describe "The return statement" do
+  it "can be used as an expression" do
+    OpalReturnSpec.new.returning_expression.should be_nil
+  end
+
+  it "can return from a method when inside a block" do
+    spec = OpalReturnSpec.new
+    spec.returning_block
+    spec.values.size.should == 2
+  end
+
+  it "returns the return value from a method returning by block" do
+    OpalReturnSpec.new.returning_block_value.should == :foo
+  end
+end

data/spec/opal/core/runtime/send_spec.rb

@@ -0,0 +1,34 @@
+class RuntimeOpalSendSpec
+  def simple
+    42
+  end
+
+  def args *a
+    a
+  end
+
+  def method_missing sym, *args
+    [sym, args]
+  end
+end
+
+
+describe "Opal.send()" do
+  before do
+    @obj = RuntimeOpalSendSpec.new
+  end
+
+  it "calls receiver with given method" do
+    `Opal.send(#{@obj}, "simple")`.should == 42
+  end
+
+  it "sends any arguments to the method" do
+    `Opal.send(#{@obj}, "args", 1, 2, 3)`.should == [1, 2, 3]
+  end
+
+  it "calls method_missing on the object if method doesnt exist" do
+    `Opal.send(#{@obj}, "blah")`.should == [:blah, []]
+    `Opal.send(#{@obj}, "bleh", 1)`.should == [:bleh, [1]]
+    `Opal.send(#{@obj}, "blih", 1, 2)`.should == [:blih, [1, 2]]
+  end
+end

data/spec/opal/core/runtime/singleton_class_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class SingletonClassConstantsSpec
+  class << self
+    $singleton_class_constant_spec = String
+  end
+end
+
+describe "Singleton Classes" do
+  it "looks up constants in body" do
+    $singleton_class_constant_spec.should == String
+  end
+end

data/spec/opal/core/runtime/super_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+class SingletonMethodSuperSpec
+  def meth
+    "bar"
+  end
+
+  def passing_block(*args, &block)
+    [args, block_given?]
+  end
+
+  def self.pass_block(&block)
+    block_given?
+  end
+
+  def super_args(*a)
+    block_given?
+  end
+
+  def self.super_args(*a)
+    block_given?
+  end
+
+  def with_splat_args(*a)
+    a
+  end
+
+  class A < SingletonMethodSuperSpec
+    def passing_block(*a)
+      super
+    end
+
+    def self.pass_block
+      super
+    end
+
+    def super_args(*a)
+      super(*a)
+    end
+
+    def self.super_args(*a)
+      super()
+    end
+
+    def with_splat_args
+      super 2, *[3, 4]
+    end
+  end
+end
+
+class MultipleSuperSpec
+  def to_s
+    if true
+      super
+    else
+      super()
+    end
+  end
+end
+
+# FIXME: we cant make a better test case than this??? For some reason, a single test cannot be deduced
+describe "The 'super' keyword" do
+  it "passes the right arguments when a variable rewrites special `arguments` js object" do
+    Struct.new(:a, :b, :c).new(1, 2, 3).b.should == 2
+  end
+
+  it "calls super method on object that defines singleton method calling super" do
+    obj = SingletonMethodSuperSpec.new
+    def obj.meth; "foo " + super; end
+    obj.meth.should == "foo bar"
+  end
+
+  describe "with no arguments or parens" do
+    before do
+      @obj = SingletonMethodSuperSpec::A.new
+      @kls = SingletonMethodSuperSpec::A
+    end
+
+    it "passes the block to super" do
+      @obj.passing_block(1, 2, 3).should == [[1, 2, 3], false]
+      @obj.passing_block(1, 2, 3) { }.should == [[1, 2, 3], true]
+    end
+
+    it "passes the block to super on singleton methods" do
+      @kls.pass_block.should be_false
+      @kls.pass_block { }.should be_true
+    end
+  end
+
+  describe "with arguments or empty parens" do
+    before do
+      @obj = SingletonMethodSuperSpec::A.new
+      @kls = SingletonMethodSuperSpec::A
+    end
+
+    it "does not pass the block to super" do
+      @obj.super_args(1, 2, 3) { }.should be_false
+      @kls.super_args() { }.should be_false
+    end
+  end
+
+  it "handles splat args" do
+    SingletonMethodSuperSpec::A.new.with_splat_args.should == [2, 3, 4]
+  end
+
+  describe "inside a class body" do
+    it "does not break when multiple super statements are in body" do
+      lambda { MultipleSuperSpec.new.to_s }.should_not raise_error
+    end
+  end
+end
+
+
+module OpalSuperSpecs
+  class A
+    def foo
+      'a'
+    end
+
+    def self.bar
+      'x'
+    end
+  end
+
+  class B < A
+    def foo
+      super + 'b'
+    end
+
+    def self.bar
+      super + 'y'
+    end
+  end
+
+  class C < B
+    def foo
+      super + 'c'
+    end
+
+    def self.bar
+      super + 'z'
+    end
+  end
+
+  module M1
+    def chain(out)
+      out << 'M1'
+    end
+  end
+
+  module M2
+    def chain(out)
+      out << 'M2'
+      super out
+    end
+  end
+
+  module M3
+    def chain(out)
+      out << 'M3'
+      super out
+    end
+  end
+
+  class C1
+    include M1
+    include M2
+    include M3
+  end
+
+  class C2
+    include M1
+    include M2
+
+    def chain(out)
+      out << 'C2'
+      super out
+    end
+  end
+
+  class C3
+    def chain(out)
+      out << 'C3'
+    end
+  end
+
+  class C4 < C3
+    include M2
+  end
+end
+
+describe "Super chains" do
+  it "searches entire class hierarchys for instance methods" do
+    OpalSuperSpecs::C.new.foo.should == 'abc'
+  end
+
+  it "searches entire class hierarchys for class methods" do
+    OpalSuperSpecs::C.bar.should == 'xyz'
+  end
+
+  it "calls methods for every module included in a class" do
+    OpalSuperSpecs::C1.new.chain([]).should == ['M3', 'M2', 'M1']
+  end
+
+  it "calls method defined in class before modules" do
+    OpalSuperSpecs::C2.new.chain([]).should == ['C2', 'M2', 'M1']
+  end
+
+  it "calls method defined on superclass after modules included by child" do
+    OpalSuperSpecs::C4.new.chain([]).should == ['M2', 'C3']
+  end
+end