opal 1.0.5 → 1.1.0.rc1

data/spec/mspec-opal/runner.rb

@@ -0,0 +1,172 @@
+require 'mspec-opal/formatters'
+
+class OSpecFilter
+  def self.main
+    @main ||= self.new
+  end
+
+  def initialize
+    @filters = Set.new
+    @seen = Set.new
+  end
+
+  def register
+    if ENV['INVERT_RUNNING_MODE']
+      MSpec.register :include, self
+    else
+      MSpec.register :exclude, self
+    end
+  end
+
+  def ===(description)
+    @seen << description
+    @filters.include?(description)
+  end
+
+  def register_filters(description, block)
+    instance_eval(&block)
+  end
+
+  def fails(description)
+    @filters << description
+  end
+
+  def fails_badly(description)
+    if ENV['INVERT_RUNNING_MODE']
+      warn "WARNING: FAILS BADLY: Ignoring filter to avoid blocking the suite: #{description.inspect}"
+    else
+      @filters << description
+    end
+  end
+
+  def unused_filters_message(list: false)
+    unused = @filters - @seen
+    return if unused.size == 0
+
+    if list
+      puts
+      puts "Unused filters:"
+      unused.each {|u| puts "  fails #{u.inspect}"}
+      puts
+    else
+      warn "\nThere are #{unused.size} unused filters, re-run with ENV['LIST_UNUSED_FILTERS'] = true to list them\n\n"
+    end
+  end
+end
+
+class Object
+  def opal_filter(description, &block)
+    OSpecFilter.main.register_filters(description, block)
+  end
+
+  alias opal_unsupported_filter opal_filter
+end
+
+# MSpec relies on File.readable? to do method detection on backtraces
+class File
+  def self.readable?(path)
+    false
+  end
+end
+
+class OSpecFormatter
+  def self.main
+    @main ||= self.new
+  end
+
+  def default_formatter
+    formatters = {
+      'browser'      => BrowserFormatter,
+      'server'       => BrowserFormatter,
+      'chrome'       => DottedFormatter,
+      'node'         => NodeJSFormatter,
+      'nodejs'       => NodeJSFormatter,
+      'nodedoc'      => NodeJSDocFormatter,
+      'nodejsdoc'    => NodeJSDocFormatter,
+      'dotted'       => DottedFormatter
+    }
+
+    formatter = formatters.fetch(ENV['FORMATTER']) do
+      warn "Using the default 'dotted' formatter, set the FORMATTER env var to select a different formatter (was: #{ENV['FORMATTER'].inspect}, options: #{formatters.keys.join(", ")})"
+      DottedFormatter
+    end
+
+    if ENV['INVERT_RUNNING_MODE']
+      formatter = Class.new(formatter)
+      formatter.include InvertedFormatter
+    end
+
+    formatter
+  end
+
+  def register(formatter_class = default_formatter)
+    formatter_class.new.register
+  end
+end
+
+class OpalBM
+  def self.main
+    @main ||= self.new
+  end
+
+  def register(repeat, bm_filepath)
+    `self.bm = {}`
+    `self.bm_filepath = bm_filepath`
+    MSpec.repeat = repeat
+    MSpec.register :before, self
+    MSpec.register :after,  self
+    MSpec.register :finish, self
+  end
+
+  def before(state = nil)
+    %x{
+      if (self.bm && !self.bm.hasOwnProperty(state.description)) {
+        self.bm[state.description] = {started: Date.now()};
+      }
+    }
+  end
+
+  def after(state = nil)
+    %x{
+      if (self.bm) {
+        self.bm[state.description].stopped = Date.now();
+      }
+    }
+  end
+
+  def finish
+    %x{
+      var obj = self.bm, key, val, report = '';
+      if (obj) {
+        for (key in obj) {
+          if (obj.hasOwnProperty(key)) {
+            val = obj[key];
+            report += key.replace(/\s/g, '_') + ' ' + ((val.stopped - val.started) / 1000) + '\n';
+          }
+        }
+        require('fs').writeFileSync(self.bm_filepath, report);
+      }
+    }
+  end
+end
+
+module OutputSilencer
+  def silence_stdout
+    original_stdout = $stdout
+    new_stdout = IO.new
+    new_stdout.extend IO::Writable
+    new_stdout.write_proc = ->s{}
+
+    begin
+      $stdout = new_stdout
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+  end
+end
+
+OSpecFormatter.main.register
+OSpecFilter.main.register
+
+MSpec.enable_feature :encoding

data/spec/opal/compiler/irb_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'native'
+
+describe Opal::Compiler do
+  describe "irb parser option" do
+    it "creates Opal.irb_vars if it does not exist" do
+      $global["Opal"].irb_vars = nil
+      eval_js compile("nil", :irb => true)
+
+      ($global["Opal"].irb_vars == nil).should be_false
+    end
+
+    it "does not create Opal.irb_vars if :irb option not passed" do
+      $global["Opal"].irb_vars = nil
+      eval_js compile("nil")
+
+      ($global["Opal"].irb_vars == nil).should be_true
+    end
+
+    it "sets each s(:lasgn) in the top level onto irb_vars" do
+      eval_js compile("foo = 42", :irb => true)
+      $global["Opal"].irb_vars.foo.should == 42
+    end
+
+    it "gets each s(:lvar) in the top level from irb_vars" do
+      eval_js compile("foo = 3.142; bar = foo", :irb => true)
+      $global["Opal"].irb_vars.bar.should == 3.142
+    end
+
+    it "persists local vars between parses" do
+      eval_js compile("foo = 'hello world'", :irb => true)
+      eval_js compile("bar = foo.upcase", :irb => true)
+      $global["Opal"].irb_vars.bar.should == "HELLO WORLD"
+    end
+
+    it "can still call top level methods" do
+      eval_js(compile("to_s", :irb => true)).should == "main"
+    end
+
+    def compile *args
+      Opal::Compiler.new(*args).compile
+    end
+  end
+end

data/spec/opal/compiler/unicode_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'opal-parser'
+
+describe Opal::Compiler do
+  describe "unicode support" do
+    it 'can compile code containing Unicode characters' do
+      -> { Opal::Compiler.new("'こんにちは'; p 1").compile }.should_not raise_error
+    end
+  end
+end

data/spec/opal/core/array/dup_spec.rb

@@ -0,0 +1,23 @@
+describe "Array#dup" do
+  it "should use slice optimization" do
+    a = Array.new
+    `a.slice = function() { return ['sliced'] }`
+    lambda { a.dup }.should_not raise_error
+    a.dup.should == ['sliced']
+  end
+
+  it "should use slice optimization on Array subclass" do
+    subclass = Class.new(Array)
+    a = subclass.new
+    `a.slice = function() { return ['sliced'] }`
+    lambda { a.dup }.should_not raise_error
+    a.dup.should == ['sliced']
+  end
+
+  it "should not use slice optimization when allocation is redefined" do
+    subclass = Class.new(Array)
+    a = subclass.new
+    subclass.define_singleton_method(:allocate) { raise 'Overriden method, no slice optimization for you!' }
+    lambda { a.dup }.should raise_error # dup should call allocate because the method is overriden
+  end
+end

data/spec/opal/core/array/intersection_spec.rb

@@ -0,0 +1,38 @@
+describe "Array#&" do
+  it "relies on Ruby's #hash (not JavaScript's #toString) for identifying array items" do
+    a1 = [ 123, '123']
+    a2 = ['123', 123 ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+
+    a1 = [ Time.at(1429521600.1), Time.at(1429521600.9) ]
+    a2 = [ Time.at(1429521600.9), Time.at(1429521600.1) ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+
+    a1 = [ Object.new, Object.new ]
+    a2 = [ Object.new, Object.new ]
+    (a1 & a2).should == []
+    (a2 & a1).should == []
+
+    a1 = [ 1, 2, 3, '1', '2', '3']
+    a2 = ['1', '2', '3', 1, 2, 3 ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+
+    a1 = [ [1, 2, 3], '1,2,3']
+    a2 = ['1,2,3', [1, 2, 3] ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+
+    a1 = [ true, 'true']
+    a2 = ['true', true ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+
+    a1 = [ false, 'false']
+    a2 = ['false', false ]
+    (a1 & a2).should == a1
+    (a2 & a1).should == a2
+  end
+end

data/spec/opal/core/array/minus_spec.rb

@@ -0,0 +1,38 @@
+describe "Array#-" do
+  it "relies on Ruby's #hash (not JavaScript's #toString) for identifying array items" do
+    a1 = [ 123 ]
+    a2 = ['123']
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ Time.at(1429521600.1) ]
+    a2 = [ Time.at(1429521600.9) ]
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ Object.new ]
+    a2 = [ Object.new ]
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ 1, 2, 3 ]
+    a2 = ['1', '2', '3']
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ 1, 2, 3 ]
+    a2 = ['1,2,3']
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ true ]
+    a2 = ['true']
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+
+    a1 = [ false ]
+    a2 = ['false']
+    (a1 - a2).should == a1
+    (a2 - a1).should == a2
+  end
+end

data/spec/opal/core/array/union_spec.rb

@@ -0,0 +1,38 @@
+describe "Array#|" do
+  it "relies on Ruby's #hash (not JavaScript's #toString) for identifying array items" do
+    a1 = [ 123, '123']
+    a2 = ['123', 123 ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+
+    a1 = [ Time.at(1429521600.1), Time.at(1429521600.9) ]
+    a2 = [ Time.at(1429521600.9), Time.at(1429521600.1) ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+
+    a1 = [ Object.new, Object.new ]
+    a2 = [ Object.new, Object.new ]
+    (a1 | a2).should == a1 + a2
+    (a2 | a1).should == a2 + a1
+
+    a1 = [ 1, 2, 3, '1', '2', '3']
+    a2 = ['1', '2', '3', 1, 2, 3 ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+
+    a1 = [ [1, 2, 3], '1,2,3']
+    a2 = ['1,2,3', [1, 2, 3] ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+
+    a1 = [ true, 'true']
+    a2 = ['true', true ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+
+    a1 = [ false, 'false']
+    a2 = ['false', false ]
+    (a1 | a2).should == a1
+    (a2 | a1).should == a2
+  end
+end

data/spec/opal/core/array/uniq_spec.rb

@@ -0,0 +1,49 @@
+describe "Array#uniq" do
+  it "relies on Ruby's #hash (not JavaScript's #toString) for identifying array items" do
+    a = [ 123, '123']
+    a.uniq.should == a
+
+    a = [ Time.at(1429521600.1), Time.at(1429521600.9) ]
+    a.uniq.should == a
+
+    a = [ Object.new, Object.new ]
+    a.uniq.should == a
+
+    a = [ 1, 2, 3, '1', '2', '3']
+    a.uniq.should == a
+
+    a = [ [1, 2, 3], '1,2,3']
+    a.uniq.should == a
+
+    a = [ true, 'true']
+    a.uniq.should == a
+
+    a = [ false, 'false']
+    a.uniq.should == a
+  end
+end
+
+describe "Array#uniq!" do
+  it "relies on Ruby's #hash (not JavaScript's #toString) for identifying array items" do
+    a = [ 123, '123']
+    a.uniq!.should == nil
+
+    a = [ Time.at(1429521600.1), Time.at(1429521600.9) ]
+    a.uniq!.should == nil
+
+    a = [ Object.new, Object.new ]
+    a.uniq!.should == nil
+
+    a = [ 1, 2, 3, '1', '2', '3']
+    a.uniq!.should == nil
+
+    a = [ [1, 2, 3], '1,2,3']
+    a.uniq!.should == nil
+
+    a = [ true, 'true']
+    a.uniq!.should == nil
+
+    a = [ false, 'false']
+    a.uniq!.should == nil
+  end
+end

data/spec/opal/core/class/inherited_spec.rb

@@ -0,0 +1,18 @@
+module ModuleInheritedTestModule
+  class A
+    def self.inherited(subclass)
+      $ScratchPad << subclass.name
+    end
+  end
+end
+
+describe 'Class#inherited' do
+  it 'gets called after setting a base scope of the subclass' do
+    $ScratchPad = []
+    module ModuleInheritedTestModule
+      class B < A
+      end
+    end
+    $ScratchPad.should == ['ModuleInheritedTestModule::B']
+  end
+end

data/spec/opal/core/enumerable/all_break_spec.rb

@@ -0,0 +1,5 @@
+describe "Enumerable#all?" do
+  it "breaks out with the proper value" do
+    [1, 2, 3].all? { break 42 }.should == 42
+  end
+end