opal 0.10.0 → 0.11.0

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

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-%x{
-  var bridge_class_demo = function(){};
-  bridge_class_demo.prototype.$foo = function() { return "bar" };
-}
-class TopBridgedClassDemo < `bridge_class_demo`
-  def some_bridged_method
-    [1, 2, 3]
-  end
-
-  def method_missing(name, *args, &block)
-    return :catched if name == :catched_by_method_missing
-    super
-  end
-end
-
-describe "Bridged Classes" do
-  describe "Passing native constructor to class keyword" do
-    before do
-      @bridged = ::TopBridgedClassDemo
-      @instance = `new bridge_class_demo()`
-    end
-
-    it "should expose the given class at the top level scope" do
-      @bridged.should be_kind_of(Class)
-    end
-
-    it "gives the class the correct name" do
-      @bridged.name.should == "TopBridgedClassDemo"
-    end
-
-    it "should have all BasicObject methods defined" do
-      @instance.should respond_to(:instance_eval)
-      @bridged.new.should respond_to(:==)
-    end
-
-    it "should have all Object methods defined" do
-      @instance.should respond_to(:class)
-      @bridged.new.should respond_to(:singleton_class)
-    end
-
-    it "instances of class should be able to call native ruby methods" do
-      @instance.foo.should == "bar"
-      @bridged.new.foo.should == "bar"
-    end
-
-    it "allows new methods to be defined on the bridged prototype" do
-      @instance.some_bridged_method.should == [1, 2, 3]
-      @bridged.new.some_bridged_method.should == [1, 2, 3]
-    end
-  end
-
-  describe ".instance_methdods" do
-    it "should report methods for class" do
-      Array.instance_methods(false).should include(:shift)
-    end
-
-    it "should not include methods donated from Object/Kernel" do
-      Array.instance_methods(false).should_not include(:class)
-    end
-
-    it "should not include methods donated from BasicObject" do
-      Array.instance_methods(false).should_not include(:__send__)
-      Array.instance_methods(false).should_not include(:send)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'works' do
-      lambda { @instance.not_catched_by_method_missing }.should raise_error(NoMethodError)
-      @instance.catched_by_method_missing.should == :catched
-    end
-  end
-end
-
-class ModularizedBridgeClass
-  def something
-    'different module'
-  end
-end
-
-%x{
-  var bridge_class_demo_module = function(){};
-  bridge_class_demo_module.prototype.$foo = function() { return "foobar" };
-}
-
-module BridgeModule
-  class ModularizedBridgeClass < `bridge_class_demo_module`
-    def some_bridged_method
-      [4, 5, 6]
-    end
-  end
-end
-
-describe 'Bridged classes in different modules' do
-  before do
-    @bridged = BridgeModule::ModularizedBridgeClass
-    @instance = `new bridge_class_demo_module()`
-  end
-
-  it "should expose the given class not at the top level scope" do
-    @bridged.should be_kind_of(Class)
-  end
-
-  it 'should not disturb an existing class at the top level scope' do
-    ModularizedBridgeClass.new.something.should == 'different module'
-  end
-
-  it "gives the class the correct name" do
-    @bridged.name.should == "BridgeModule::ModularizedBridgeClass"
-  end
-
-  it "instances of class should be able to call native ruby methods" do
-    @instance.foo.should == "foobar"
-    @bridged.new.foo.should == "foobar"
-  end
-
-  it "allows new methods to be defined on the bridged prototype" do
-    @instance.some_bridged_method.should == [4, 5, 6]
-    @bridged.new.some_bridged_method.should == [4, 5, 6]
-  end
-end

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

@@ -1,13 +0,0 @@
-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/donate_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module RuntimeDonatingMethods
-  module A
-    def baz
-      'a'
-    end
-
-    def woosh
-      :kapow
-    end
-  end
-
-  module B
-  end
-
-  class C
-    include A
-    include B
-
-    def foo; 'c'; end
-  end
-
-  module B
-    def foo; 'b'; end
-    def bar; 'b'; end
-    def baz; 'b'; end
-  end
-
-  module A
-    def bar; 'a'; end
-    def woosh; :kaplunk; end
-  end
-end
-
-describe 'Donating methods in the runtime' do
-  before do
-    @c = RuntimeDonatingMethods::C.new
-  end
-
-  it 'class methods should not get overwritten by methods from modules' do
-    @c.foo.should == 'c'
-  end
-
-  it 'methods defined in modules should respect the include order in a class' do
-    @c.bar.should == 'b'
-    @c.baz.should == 'b'
-  end
-
-  it 'allows a module to override a method it previously defined' do
-    @c.woosh.should == :kaplunk
-  end
-end

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

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

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

@@ -1,68 +0,0 @@
-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 "calls method missing for operators" do
-    obj = Object.new
-    obj.should_receive(:method_missing).with(:+, 123).and_return(42)
-    (obj + 123).should == 42
-  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

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

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

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

@@ -1,71 +0,0 @@
-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
-
-  it "by default, catch StandardError, not all Exception" do
-    lambda { begin;raise Exception.new;rescue;end }.should raise_error
-    lambda { begin;raise "err";rescue;end }.should_not raise_error
-
-    # one line rescue
-    lambda { raise Exception rescue nil }.should raise_error(Exception)
-    lambda { raise "err" rescue nil }.should_not raise_error
-    (raise "err" rescue "foo").should == "foo"
-    ("err" rescue "foo").should == "err"
-  end
-
-  it 'Fix using more than two "rescue" in sequence #1269' do
-    $ScratchPad = []
-    # As a statement
-    begin
-      raise IOError, 'foo'
-    rescue RangeError              # this one is correct
-    rescue TypeError               # miss a return
-    rescue IOError                 # following two lines disappear in js
-      $ScratchPad << "I got #{$!.message}"
-    end
-    $ScratchPad.last.should == "I got foo"
-
-    # As an expression
-    a = begin
-      raise IOError, 'foo'
-    rescue RangeError              # this one is correct
-    rescue TypeError               # miss a return
-    rescue IOError                 # following two lines disappear in js
-      "I got #{$!.message}"
-    end
-    a.should == "I got foo"
-  end
-
-end

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

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

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

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