opal 1.0.1 → 1.1.0.rc1

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

@@ -0,0 +1,16 @@
+module RuntimeFixtures
+  class A
+  end
+
+  class A::B
+    module C
+
+    end
+  end
+end
+
+describe "Constants access via .$$ with dots (regression for #1418)" do
+  it "allows to acces scopes on `Opal`" do
+    `Opal.Object.$$.RuntimeFixtures.$$.A.$$.B.$$.C`.should == RuntimeFixtures::A::B::C
+  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/exit_spec.rb

@@ -0,0 +1,29 @@
+describe "Exit (Kernel#exit / Opal.exit())" do
+  it "forwards the status code to Opal.exit(status)" do
+    received_status { Kernel.exit }.should == 0
+
+    received_status { Kernel.exit(0) }.should == 0
+    received_status { Kernel.exit(1) }.should == 1
+    received_status { Kernel.exit(2) }.should == 2
+    received_status { Kernel.exit(123) }.should == 123
+
+    received_status { Kernel.exit(true) }.should == 0
+    received_status { Kernel.exit(false) }.should == 1
+
+    lambda { received_status { Kernel.exit(Object.new) } }.should raise_error(TypeError)
+    lambda { received_status { Kernel.exit([]) } }.should raise_error(TypeError)
+    lambda { received_status { Kernel.exit(/123/) } }.should raise_error(TypeError)
+  end
+
+  def received_status
+    received_status = nil
+    original_exit = `Opal.exit`
+    begin
+      `Opal.exit = function(status) { #{received_status = `status`} }`
+      yield
+    ensure
+      `Opal.exit = #{original_exit}`
+    end
+    received_status
+  end
+end

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

@@ -0,0 +1,48 @@
+describe 'Opal.is_a' do
+  describe 'Numeric/Number special cases' do
+    [
+      [1, :Numeric, true],
+      [1, :Number, true],
+      [1, :Fixnum, true],
+      [1, :Integer, true],
+      [1, :Float, true],
+
+      [1.2, :Numeric, true],
+      [1.2, :Number, true],
+      [1.2, :Fixnum, true],
+      [1.2, :Integer, false],
+      [1.2, :Float, true],
+
+      [Numeric.new, :Numeric, true],
+      [Numeric.new, :Number, false],
+      [Numeric.new, :Fixnum, false],
+      [Numeric.new, :Integer, false],
+      [Numeric.new, :Float, false],
+    ].each do |(value, klass_name, result)|
+      klass = Object.const_get(klass_name)
+      it "returns #{result} for Opal.is_a(#{value}, #{klass_name})" do
+        `Opal.is_a(#{value}, #{klass})`.should == result
+      end
+    end
+
+    it 'can rely on Number subclasses having $$is_number_class on their prototype' do
+      `!!#{Numeric}.$$is_number_class`.should == false
+      `!!#{Number}.$$is_number_class`.should == true
+      `!!#{Fixnum}.$$is_number_class`.should == true
+      `!!#{Integer}.$$is_number_class`.should == true
+      `!!#{Float}.$$is_number_class`.should == true
+    end
+
+    it 'can rely on Number subclasses having $$is_integer_class on their prototype' do
+      `!!#{Numeric}.$$is_integer_class`.should == false
+      `!!#{Number}.$$is_integer_class`.should == false
+      `!!#{Fixnum}.$$is_integer_class`.should == false
+      `!!#{Integer}.$$is_integer_class`.should == true
+      `!!#{Float}.$$is_integer_class`.should == false
+    end
+
+    it 'works for non-Opal objects' do
+      `Opal.is_a({}, Opal.Array)`.should == false
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+describe 'Opal.loaded' do
+  before do
+    %w[foo bar baz].each do |module_name|
+      `delete Opal.require_table[#{module_name}]`
+      `Opal.loaded_features.splice(Opal.loaded_features.indexOf(#{module_name}))`
+    end
+  end
+
+  it 'it works with multiple paths' do
+    `Opal.loaded(['bar'])`
+    `(Opal.require_table.foo == null)`.should == true
+    `(Opal.require_table.bar === true)`.should == true
+    `(Opal.require_table.baz == null)`.should == true
+
+    `Opal.loaded(['foo', 'bar', 'baz'])`
+    `(Opal.require_table.foo === true)`.should == true
+    `(Opal.require_table.bar === true)`.should == true
+    `(Opal.require_table.baz === true)`.should == true
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+
+define_method :some_other_main_method do
+  0.1618
+end
+
+describe "Defining normal methods at the top level" do
+  it "should define them on Object, not main" do
+    $OPAL_TOP_LEVEL_OBJECT.some_top_level_method_is_defined.should == 42
+    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
+
+describe "Defining methods on main with define_method" do
+  it "should define it on main directly" do
+    $OPAL_TOP_LEVEL_OBJECT.some_other_main_method.should == 0.1618
+    Object.new.some_other_main_method.should == 0.1618
+  end
+end

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

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

@@ -0,0 +1,37 @@
+describe "The rescue keyword" do
+  context 'JS::Error' do
+    it 'handles raw js throws' do
+      begin
+        `throw { message: 'foo' }`
+        nil
+      rescue JS::Error => e
+        e.JS[:message]
+      end.should == 'foo'
+    end
+
+    it 'handles other Opal error' do
+      begin
+        raise 'bar'
+      rescue JS::Error => e
+        e.message
+      end.should == 'bar'
+    end
+
+    it 'can be combined with other classes to catch js errors' do
+      begin
+        `throw { message: 'baz' }`
+        nil
+      rescue JS::Error, RuntimeError => e
+        e.JS[:message]
+      end.should == 'baz'
+    end
+
+    it 'can be combined with other classes to catch Opal errors' do
+      begin
+        raise 'quux'
+      rescue JS::Error, RuntimeError => e
+        e.message
+      end.should == 'quux'
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Runtime String helpers" do
+  context 'Opal.enc' do
+    it 'sets the encoding boxing literal strings' do
+      -> {
+        `Opal.enc("foo", 'UTF-8')`
+      }.should_not raise_error
+    end
+  end
+
+  context 'Opal.set_encoding' do
+    it 'sets the encoding for boxed strings' do
+      expect(`Opal.set_encoding(new String("foo"), 'UTF-8')`.encoding).to eq(Encoding::UTF_8)
+      expect(`Opal.set_encoding("foo".$dup(), 'UTF-8')`.encoding).to eq(Encoding::UTF_8)
+      expect(`Opal.set_encoding("foo".$clone(), 'UTF-8')`.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it 'raises FrozenError when provided a literal' do
+      -> {
+        `Opal.set_encoding("foo", 'UTF-8')`
+      }.should raise_error(FrozenError)
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+class Boolean
+  def self_as_an_object
+    self
+  end
+end
+
+class JsNil
+  def <(other)
+    `nil`
+  end
+end
+
+describe "Opal truthyness" do
+  it "should evaluate to true using js `true` as an object" do
+    if true.self_as_an_object
+      called = true
+    end
+
+    called.should be_true
+  end
+
+  it "should evaluate to false using js `false` as an object" do
+    if false.self_as_an_object
+      called = true
+    end
+
+    called.should be_nil
+  end
+
+  it "should evaluate to false if js `nil` is used with an operator" do
+    is_falsey = JsNil.new < 2 ? false : true
+
+    is_falsey.should be_true
+  end
+
+  it "should consider false, nil, null, and undefined as not truthy" do
+    called = nil
+    [`false`, `nil`, `null`, `undefined`].each do |v|
+      if v
+        called = true
+      end
+    end
+
+    called.should be_nil
+  end
+
+  it "should true as truthy" do
+    if `true`
+      called = true
+    end
+
+    called.should be_true
+  end
+
+  it "should handle logic operators correctly for false, nil, null, and undefined" do
+    (`false` || `nil` || `null` || `undefined` || 1).should == 1
+    [`false`, `nil`, `null`, `undefined`].each do |v|
+      `#{1 && v} === #{v}`.should == true
+    end
+  end
+end

data/spec/opal/core/runtime_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe '`Opal.hash`' do
+  it 'converts object literals to hashes' do
+    `Opal.hash({a: 1, b: 2})`.should == {a: 1, b: 2}
+  end
+end
+
+describe 'javascript access using .JS' do
+  it 'should call javascript methods via .JS.method()' do
+    "a1234b5678c".JS.indexOf('c').should == 10
+    "a1234b5678c".JS.replace(`/[0-9]/g`, '').should == 'abc'
+  end
+
+  it 'should call javascript methods via .JS.method arg' do
+    ("a1234b5678c".JS.indexOf 'c').should == 10
+    ("a1234b5678c".JS.replace `/[0-9]/g`, '').should == 'abc'
+  end
+
+  it 'should call javascript methods with blocks via .JS.method' do
+    f = `{a:function(f){return f(1) + f(2)}}`
+    f.JS.a{|v| v*2}.should == 6
+    v = f.JS.a do |v| v*2 end
+    v.should == 6
+  end
+
+  it 'should call javascript methods with args and blocks via .JS.method' do
+    f = `{a:function(a, f){return f(a, 1) + f(a, 2)}}`
+    f.JS.a(3){|b, v| b+v*2}.should == 12
+    v = f.JS.a 3 do |b, v| b+v*2 end
+    v.should == 12
+  end
+
+  it 'should support javascript properties via .JS[]' do
+    "a1234b5678c".JS['length'].should == 11
+    `{a:1}`.JS['a'].should == 1
+    `{a:1}`.JS['a'].should == 1
+    [2, 4].JS[0].should == 2
+    [2, 4].JS[1].should == 4
+    [2, 4].JS[:length].should == 2
+  end
+
+  it 'should be chainable' do
+    "a1234b5678c".JS.replace(`/[0-9]/g`, '').JS.toUpperCase.should == 'ABC'
+    "a1234b5678c".JS.replace(`/[0-9]/g`, '').JS[:length].should == 3
+    "a1234b5678c".JS[:length].JS.toString.should == "11"
+    `{a:{b:1}}`.JS[:a].JS[:b].JS.toString.should == '1'
+    f = `{a:function(f){return {b: function(f2){return f(f2(1)) + f(f2(2))}}}}`
+    f.JS.a{|v| v*2}.JS.b{|v| v*3}.should == 18
+  end
+
+  it 'should set javascript properties via .JS[arg] = rhs' do
+    a = `{}`
+    a.JS[:foo] = 1
+    a.JS[:foo].should == 1
+    `a["foo"]`.should == 1
+  end
+end

data/spec/opal/core/string/each_byte_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "String#each_byte" do
+  it "get bytes from UTF-8 character (2 bytes)" do
+    a = []
+    "ʆ".each_byte { |c| a << c }
+    a.should == [202, 134]
+  end
+  it "get bytes from UTF-8 character (3 bytes)" do
+    a = []
+    "ቜ".each_byte { |c| a << c }
+    a.should == [225, 137, 156]
+  end
+  it "get bytes from UTF-8 emoji (4 bytes)" do
+    a = []
+    "👋".each_byte { |c| a << c }
+    a.should == [240, 159, 145, 139]
+  end
+end

data/spec/opal/core/string/gsub_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'String' do
+  describe '#gsub' do
+    it 'handles recursive gsub' do
+      pass_slot_rx = /{(\d+)}/
+      recurse_gsub = -> text {
+        text.gsub(pass_slot_rx) {
+          index = $1.to_i
+          if index == 0
+            recurse_gsub.call '{1}'
+          else
+            'value'
+          end
+        }
+      }
+      result = recurse_gsub.call '<code>{0}</code>'
+      result.should == '<code>value</code>'
+    end
+
+    it 'works well with zero-length matches' do
+      expect("test".gsub(/^/, '2')).to eq "2test"
+      expect("test".gsub(/$/, '2')).to eq "test2"
+      expect("test".gsub(/\b/, '2')).to eq "2test2"
+    end
+  end
+
+  describe '#sub' do
+    it 'works well with zero-length matches' do
+      expect("test".sub(/^/, '2')).to eq "2test"
+      expect("test".sub(/$/, '2')).to eq "test2"
+      expect("test".sub(/\b/, '2')).to eq "2test"
+    end
+  end
+end