opal 1.0.3 → 1.1.1.rc1

data/spec/opal/core/language/while_spec.rb

@@ -0,0 +1,31 @@
+describe "The while expression" do
+  it "restarts the current iteration without reevaluating condition with redo" do
+    a = []
+    i = 0
+    j = 0
+    while (i+=1)<3
+      a << i
+      j+=1
+      redo if j<3
+      a << 5
+    end
+    a.should == [1, 1, 1, 5, 2, 5]
+  end
+
+  it "restarts the current iteration without evaluation the code below redo" do
+    a = []
+    i = 0
+    while true
+      i += 1
+      a << i
+      if i < 3
+        redo
+      else
+        break
+      end
+      a << 5 # should never get here
+    end
+    a.should == [1, 2, 3]
+  end
+
+end

data/spec/opal/core/language_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "generated method names" do
+  it "does not conflict with local Ruby variables" do
+    Class.new {
+      value = 123
+      def value
+        456
+      end
+      value.should == 123
+    }
+  end
+
+  it "does not conflict with local JS variables" do
+    Class.new {
+      `var value = 123;`
+      def value
+        456
+      end
+      `value`.should == 123
+    }
+  end
+end
+
+describe "Bridging" do
+  it "does not remove singleton methods of bridged classes" do
+    `typeof(String.call)`.should == "function"
+  end
+end

data/spec/opal/core/marshal/dump_spec.rb

@@ -0,0 +1,81 @@
+# encoding: binary
+
+require 'spec_helper'
+
+module MarshalExtension
+end
+
+class MarshalUserRegexp < Regexp
+end
+
+class UserMarshal
+  attr_reader :data
+
+  def initialize
+    @data = 'stuff'
+  end
+  def marshal_dump() 'data' end
+  def marshal_load(data) @data = data end
+  def ==(other) self.class === other and @data == other.data end
+end
+
+describe 'Marshal.dump' do
+  it 'dumps non-empty Array' do
+    expect(Marshal.dump(['a', 1, 2])).to eq("\u0004\b[\b\"\u0006ai\u0006i\a")
+  end
+
+  it 'dumps case-sensitive regexp' do
+    expect(Marshal.dump(/\w+/)).to eq("\u0004\b/\b\\w+\u0000")
+  end
+
+  it 'dumps case-insensitive regexp' do
+    expect(Marshal.dump(/\w+/i)).to eq("\u0004\b/\b\\w+\u0001")
+  end
+
+  it "dumps a Float" do
+    Marshal.dump(123.4567).should == "\004\bf\r123.4567"
+    Marshal.dump(-0.841).should == "\x04\bf\v-0.841"
+    Marshal.dump(9876.345).should == "\004\bf\r9876.345"
+    Marshal.dump(Float::INFINITY).should == "\004\bf\binf"
+    Marshal.dump(-Float::INFINITY).should == "\004\bf\t-inf"
+    Marshal.dump(Float::NAN).should == "\004\bf\bnan"
+  end
+
+  it "dumps a Integer" do
+    Marshal.dump(0).should == "\x04\bi\x00"
+    Marshal.dump(123).should == "\x04\bi\x01{"
+    Marshal.dump(-123).should == "\x04\bi\x80"
+    Marshal.dump(1234567890).should == "\x04\bl+\a\xD2\x02\x96I"
+    Marshal.dump(-1234567890).should == "\x04\bl-\a\xD2\x02\x96I"
+  end
+
+  it "dumps a Regexp with flags" do
+    Marshal.dump(/\w/im).should == "\x04\b/\a\\w\u0005"
+  end
+
+  it 'dumps an extended Regexp' do
+    Marshal.dump(/\w/.extend(MarshalExtension)).should == "\x04\be:\u0015MarshalExtension/\a\\w\u0000"
+  end
+
+  it 'dumps object#marshal_dump when object responds to #marshal_dump' do
+    Marshal.dump(UserMarshal.new).should == "\u0004\bU:\u0010UserMarshal\"\tdata"
+  end
+
+  it 'saves a link to an object before processing its instance variables' do
+    top = Object.new
+    ref = Object.new
+    a = Object.new
+    b = Object.new
+    c = Object.new
+
+    top.instance_variable_set(:@a, a)
+    top.instance_variable_set(:@b, b)
+    top.instance_variable_set(:@a, c)
+    top.instance_variable_set(:@ref, ref)
+
+    expected = "\u0004\b[\ao:\vObject\b:\a@ao:\vObject\u0000:\a@bo:\vObject\u0000:\t@refo:\vObject\u0000@\t"
+    Marshal.dump([top, ref]).should == expected
+    loaded = Marshal.load(expected)
+    loaded[0].instance_variable_get(:@ref).object_id.should == loaded[1].object_id
+  end
+end

data/spec/opal/core/marshal/load_spec.rb

@@ -0,0 +1,13 @@
+describe "Marshal.load" do
+  it 'loads array with instance variable' do
+    a = Marshal.load("\x04\bI[\bi\x06i\ai\b\x06:\n@ivari\x01{")
+    a.should == [1, 2, 3]
+    a.instance_variable_get(:@ivar).should == 123
+  end
+
+  it 'loads a hash with a default value (hash_def)' do
+    hash = Marshal.load("\x04\b}\x06i\x06i\a:\bdef")
+    hash.should == { 1 => 2 }
+    hash.default.should == :def
+  end
+end

data/spec/opal/core/module_spec.rb

@@ -0,0 +1,27 @@
+module ModuleSubclassIncludedSpec
+  class Module1 < ::Module
+    def included(_descendant)
+      $ScratchPad << 'A included'
+    end
+  end
+
+  class Module2 < Module1
+    def included(_descendant)
+      $ScratchPad << 'B included'
+    end
+  end
+  M0 = Module.new
+  M1 = Module1.new
+  M2 = Module2.new
+end
+
+describe 'Module#included' do
+  it 'gets called in subclasses (regression for https://github.com/opal/opal/issues/1900)' do
+    $ScratchPad = []
+    klass = Class.new
+    klass.include ::ModuleSubclassIncludedSpec::M0
+    klass.include ::ModuleSubclassIncludedSpec::M1
+    klass.include ::ModuleSubclassIncludedSpec::M2
+    $ScratchPad.should == ['A included', 'B included']
+  end
+end

data/spec/opal/core/object_id_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Opal.uid()" do
+  it "returns even sequential numbers in increments of 2" do
+    %x{
+      var id0 = Opal.uid(),
+          id1 = Opal.uid(),
+          id2 = Opal.uid(),
+          id3 = Opal.uid(),
+          id4 = Opal.uid();
+    }
+
+    modulo = `id0` % 2
+    modulo.should == 0
+
+    `id1`.should == `id0` + 2
+    `id2`.should == `id0` + 4
+    `id3`.should == `id0` + 6
+    `id4`.should == `id0` + 8
+  end
+end
+
+describe "FalseClass#object_id" do
+  it "returns 0" do
+    false.object_id.should == 0
+  end
+end
+
+describe "TrueClass#object_id" do
+  it "returns 2" do
+    true.object_id.should == 2
+  end
+end
+
+describe "NilClass#object_id" do
+  it "returns 4" do
+    nil.object_id.should == 4
+  end
+end
+
+describe "Numeric#object_id" do
+  it "returns (self * 2) + 1" do
+    0.object_id.should == 1
+    1.object_id.should == 3
+    2.object_id.should == 5
+    420.object_id.should == 841
+    -2.object_id.should == -3
+    -1.object_id.should == -1
+  end
+end
+
+describe "String#object_id" do
+  it "returns the primitive string version of self" do
+    `#{"hello".object_id} === "hello".toString()`.should be_true
+  end
+end

data/spec/opal/core/regexp/interpolation_spec.rb

@@ -0,0 +1,40 @@
+describe 'Regexp interpolation' do
+  it 'can interpolate other regexps' do
+    a = /a/
+
+    /#{a}/.should =~ 'aaa'
+    /a+/.should =~ 'aaa'
+    /#{a}+/.should =~ 'aaa'
+    /aa/.should =~ 'aaa'
+    /#{a}a/.should =~ 'aaa'
+  end
+
+  it 'can interpolate objects' do
+    a = Object.new
+    def a.to_s; 'a'; end
+
+    /#{a}/.should =~ 'aaa'
+    /a+/.should =~ 'aaa'
+    /#{a}+/.should =~ 'aaa'
+    /aa/.should =~ 'aaa'
+    /#{a}a/.should =~ 'aaa'
+  end
+
+  it 'can interpolate strings' do
+    a = 'a'
+
+    /#{a}/.should =~ 'aaa'
+    /a+/.should =~ 'aaa'
+    /#{a}+/.should =~ 'aaa'
+    /aa/.should =~ 'aaa'
+    /#{a}a/.should =~ 'aaa'
+  end
+
+  it 'can interpolate string literals' do
+    /#{'a'}/.should =~ 'aaa'
+    /a+/.should =~ 'aaa'
+    /#{'a'}+/.should =~ 'aaa'
+    /aa/.should =~ 'aaa'
+    /#{'a'}a/.should =~ 'aaa'
+  end
+end

data/spec/opal/core/regexp/match_spec.rb

@@ -0,0 +1,78 @@
+describe 'Regexp#match' do
+  describe 'when pos is not specified' do
+    it 'calls .exec only once on the current object' do
+      regexp = /test/
+      calls = 0
+      %x(
+        regexp._exec = regexp.exec;
+        regexp.exec = function(str) {
+          var match = this._exec(str);
+          calls++;
+          return match;
+        }
+      )
+      result = regexp.match('test test')
+      calls.should == 1
+      result.begin(0).should == 0
+      result[0].should == 'test'
+    end
+  end
+
+  describe 'when pos is specified' do
+    it 'does not call .exec on the current object' do
+      regexp = /test/
+      calls = 0
+      %x(
+        regexp._exec = regexp.exec;
+        regexp.exec = function(str) {
+          var match = this._exec(str);
+          calls++;
+          return match;
+        }
+      )
+      result = regexp.match('test test', 1)
+      calls.should == 0
+      result[0].should == 'test'
+      result.begin(0).should == 5
+    end
+  end
+end
+
+describe 'Regexp#match?' do
+  describe 'when pos is not specified' do
+    it 'calls .test on the current object' do
+      regexp = /test/
+      calls = 0
+      %x(
+        regexp._test = regexp.test;
+        regexp.test = function(str) {
+          var verdict = this._test(str);
+          calls++;
+          return verdict;
+        }
+      )
+      result = regexp.match?('test test')
+      calls.should == 1
+      result.should == true
+    end
+  end
+
+  describe 'when pos is specified' do
+    it 'does not call .test on the current object' do
+      regexp = /test/
+      calls = 0
+      %x(
+        regexp._test = regexp.test;
+        regexp.test = function(str) {
+          var verdict = this._test(str);
+          calls++;
+          return verdict;
+        }
+      )
+      result = regexp.match?('test test', 1)
+      calls.should == 0
+      # FIXME pos is not yet supported by Opal's Regexp#match?
+      #result.should == true
+    end
+  end
+end

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

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