opal 0.10.0 → 0.11.0.rc1

data/spec/lib/spec_helper.rb

@@ -5,12 +5,96 @@ end
 
 require 'opal'
 
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-  config.order = 'random'
   config.before { Opal.reset_paths! }
   config.before { Opal::Config.reset! if defined? Opal::Config }
   config.before { Opal::Processor.reset_cache_key! if defined? Opal::Processor }
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+
+    expectations.syntax = [:expect, :should]
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+
+    mocks.syntax = [:expect, :should]
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `||\describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "tmp/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  # config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  else
+    # The RSpec specs are stored in spec/lib.
+    config.pattern = 'spec/lib/**/*_spec.rb'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
 end

data/spec/mspec-opal/formatters.rb

@@ -1,4 +1,4 @@
-class BrowserFormatter
+class BaseOpalFormatter
   def initialize(out=nil)
     @exception = @failure = false
     @exceptions = []
@@ -18,12 +18,16 @@ class BrowserFormatter
     MSpec.register :enter,     self
   end
 
+  def red(str)
+    `console.error(str)`
+  end
+
   def green(str)
     `console.info(str)`
   end
 
-  def red(str)
-    `console.error(str)`
+  def cyan(str)
+    `console.info(str)`
   end
 
   def log(str)
@@ -66,7 +70,7 @@ class BrowserFormatter
 
     if @exceptions.empty?
       log "\nFinished"
-      green "#{@examples} examples, #{@count} failures (time taken: #{time})"
+      green "#{@examples} examples, #{@count} failures (time taken: #{time})\n"
 
       finish_with_code 0
     else
@@ -81,6 +85,15 @@ class BrowserFormatter
       log "\nFinished"
       red "#{@examples} examples, #{@count} failures (time taken: #{time})"
 
+      log "\n\nFilters for failed examples:\n\n"
+      @exceptions.map do |exception|
+        ["#{exception.describe} #{exception.it}", exception.message.tr("\n", " ")]
+      end.sort.each do |(description, message)|
+        red "fails #{description.inspect}"
+        cyan " # #{message}\n"
+      end
+      log "\n"
+
       finish_with_code(1)
     end
   end
@@ -90,15 +103,40 @@ class BrowserFormatter
   end
 end
 
-class PhantomFormatter < BrowserFormatter
-  def green(str)
-    `console.log('\u001b[32m' + str + '\u001b[0m')`
+class BrowserFormatter < BaseOpalFormatter
+  def initialize(*args, &block)
+    $passed = 0
+    $failed = 0
+    $errored = 0
+    super
+  end
+
+  def print_example(state)
+    unless exception?
+      $passed += 1
+    else
+      if failure?
+        $failed += 1
+      else
+        $errored += 1
+      end
+    end
   end
+end
 
+class PhantomFormatter < BaseOpalFormatter
   def red(str)
     `console.log('\u001b[31m' + str + '\u001b[0m')`
   end
 
+  def green(str)
+    `console.log('\u001b[32m' + str + '\u001b[0m')`
+  end
+
+  def cyan(str)
+    `console.log('\u001b[36m' + str + '\u001b[0m')`
+  end
+
   def log(str)
     `console.log(str)`
   end
@@ -113,15 +151,24 @@ class PhantomFormatter < BrowserFormatter
   end
 end
 
-class NodeJSFormatter < BrowserFormatter
-  def green(str)
-    `process.stdout.write("\u001b[32m"+#{str}+"\u001b[0m")`
+class NodeJSFormatter < BaseOpalFormatter
+  def initialize(*args, &block)
+    require 'nodejs/stacktrace'
+    super
   end
 
   def red(str)
     `process.stdout.write("\u001b[31m"+#{str}+"\u001b[0m")`
   end
 
+  def green(str)
+    `process.stdout.write("\u001b[32m"+#{str}+"\u001b[0m")`
+  end
+
+  def cyan(str)
+    `process.stdout.write("\u001b[36m"+#{str}+"\u001b[0m")`
+  end
+
   def log(str)
     puts str
   end
@@ -152,12 +199,16 @@ class PhantomDocFormatter < PhantomFormatter
 end
 
 class NodeJSDocFormatter < NodeJSFormatter
+  def before(example)
+    print example.description
+  end
+
   def print_example(state)
-    (@exception && state) ? red(state.description+"\n") : green(state.description+"\n")
+    (@exception && state) ? red(" ✗\n") : green(" ✓\n")
   end
 end
 
-class InvertedFormatter < DottedFormatter
+module InvertedFormatter
   def initialize(out=nil)
     super
     @actually_passing = []
@@ -171,15 +222,12 @@ class InvertedFormatter < DottedFormatter
   end
 
   def after(state=nil)
-    unless exception?
-      @actually_passing << @current_state
-    end
-
+    @actually_passing << @current_state unless exception?
     super
   end
 
   def finish
-    puts "\n\nExpected to fail:\n"
+    puts "\n\nExpected #{@actually_passing.size} examples to fail:\n"
     @actually_passing.each_with_index do |example, idx|
       puts "  #{idx + 1}) #{example.description.inspect}"
     end

data/spec/mspec-opal/runner.rb

@@ -1,3 +1,5 @@
+require 'mspec-opal/formatters'
+
 class OSpecFilter
   def self.main
     @main ||= self.new
@@ -29,6 +31,14 @@ class OSpecFilter
     @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
@@ -36,7 +46,7 @@ class OSpecFilter
     if list
       puts
       puts "Unused filters:"
-      unused.each {|u| puts "- #{u}".gsub("\n", "\\n")}
+      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"
@@ -49,43 +59,13 @@ class Object
     OSpecFilter.main.register_filters(description, block)
   end
 
-  # Copyed from MSpec, with changes.
-  def with_timezone(name, offset = nil, daylight_saving_zone = "")
-    zone = name.dup
-
-    if offset
-      # TZ convention is backwards
-      offset = -offset
-
-      zone += offset.to_s
-      zone += ":00:00"
-    end
-    zone += daylight_saving_zone
-
-    # WAS:
-    #
-    #   old = ENV["TZ"]
-    #   ENV["TZ"] = zone
-    #
-    #   begin
-    #     yield
-    #   ensure
-    #     ENV["TZ"] = old
-    #   end
-    #
-    if ENV["TZ"] == zone
-      yield
-    else
-      1.should == 1 # MSpec will get mad if the example has no expectations.
-      warn "Skipped spec for TZ=#{zone} as it's not supported"
-    end
-  end
+  alias opal_unsupported_filter opal_filter
 end
 
-module MSpec
-  def self.opal_runner
-    @env = Object.new
-    @env.extend MSpec
+# MSpec relies on File.readable? to do method detection on backtraces
+class File
+  def self.readable?(path)
+    false
   end
 end
 
@@ -95,16 +75,31 @@ class OSpecFormatter
   end
 
   def default_formatter
-    return InvertedFormatter if ENV['INVERT_RUNNING_MODE']
+    formatters = {
+      'browser'      => BrowserFormatter,
+      'server'       => BrowserFormatter,
+      'node'         => NodeJSFormatter,
+      'nodejs'       => NodeJSFormatter,
+      'nodedoc'      => NodeJSDocFormatter,
+      'nodejsdoc'    => NodeJSDocFormatter,
+      'phantom'      => PhantomFormatter,
+      'phantomjs'    => PhantomFormatter,
+      'phantomdoc'   => PhantomDocFormatter,
+      'phantomjsdoc' => PhantomDocFormatter,
+      '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
 
-    # Uncomment one of the following to use a different formatter:
-    #
-    # BrowserFormatter
-    # NodeJSFormatter
-    # NodeJSDocFormatter
-    # PhantomFormatter
-    # PhantomDocFormatter
-    DottedFormatter
+    formatter
   end
 
   def register(formatter_class = default_formatter)
@@ -112,35 +107,18 @@ class OSpecFormatter
   end
 end
 
-class OSpecRunner
+class OpalBM
   def self.main
     @main ||= self.new
   end
 
-  def initialize
-    register
-    run
-  end
-
-  def register
-    OSpecFormatter.main.register
-    OSpecFilter.main.register
-  end
-
-  def run
-    MSpec.opal_runner
-  end
-
-  def will_start
-    MSpec.actions :start
-  end
-
-  def bm!(repeat, bm_filepath)
+  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)
@@ -159,7 +137,7 @@ class OSpecRunner
     }
   end
 
-  def did_finish
+  def finish
     %x{
       var obj = self.bm, key, val, report = '';
       if (obj) {
@@ -172,7 +150,6 @@ class OSpecRunner
         require('fs').writeFileSync(self.bm_filepath, report);
       }
     }
-    MSpec.actions :finish
   end
 end
 
@@ -191,3 +168,6 @@ module OutputSilencer
     end
   end
 end
+
+OSpecFormatter.main.register
+OSpecFilter.main.register

data/spec/opal/core/date_spec.rb

@@ -8,6 +8,11 @@ describe Date do
       Date.parse('2013-10-4').should == Date.new(2013, 10, 4)
       Date.parse('2013-06-02').should == Date.new(2013, 6, 2)
     end
+
+    it "parses date string with month name into a Date instance" do
+      Date.parse("2013 Jun 02").should == Date.new(2013, 6, 2)
+      Date.parse("2013 jun 02").should == Date.new(2013, 6, 2)
+    end
   end
 
   describe "#<" do
@@ -46,6 +51,10 @@ describe Date do
     it 'returns 1 when self is greater than other' do
       (Date.new(2015, 1, 2) <=> Date.new(2015, 1, 1)).should == 1
     end
+
+    it 'returns nil when compared to non-Date objects' do
+      (Date.new <=> nil).should == nil
+    end
   end
 
   describe "#==" do
@@ -56,6 +65,11 @@ describe Date do
     it "returns false if self is not equal to other date" do
       (Date.new(2013, 10, 2) == Date.new(2013, 10, 11)).should == false
     end
+
+    it 'returns false when compared to non-Date objects' do
+      (Date.new == nil).should == false
+      (Date.new == Object.new).should == false
+    end
   end
 
   describe "#clone" do

data/spec/opal/core/exception_spec.rb

@@ -18,3 +18,13 @@ describe "Native exception" do
     exception.message.should == "native message"
   end
 end
+
+# TODO: Delete when this code is added to the ruby spec
+describe "Exception#to_s" do
+  it "calls #to_s on the message" do
+    message = mock("message")
+    message.should_receive(:to_s).and_return("message").any_number_of_times
+    ExceptionSpecs::Exceptional.new(message).to_s.should == "message"
+  end
+end
+

data/spec/opal/core/hash/internals_spec.rb

@@ -188,11 +188,11 @@ describe 'Hash' do
         @obj1  => 'xyz'
       }
 
-      `#@hash.$$map.hasOwnProperty('hhh')`.should == true
-      `#@hash.$$map.hasOwnProperty(#{@obj1.hash})`.should == true
-      `#@hash.$$smap.hasOwnProperty('a')`.should == true
-      `#@hash.$$smap.hasOwnProperty('b')`.should == true
-      `#@hash.$$smap.hasOwnProperty('c')`.should == true
+      `Opal.hasOwnProperty.call(#@hash.$$map, 'hhh')`.should == true
+      `Opal.hasOwnProperty.call(#@hash.$$map, #{@obj1.hash})`.should == true
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'a')`.should == true
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'b')`.should == true
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'c')`.should == true
 
       `#@hash.$$keys.length`.should == 8
       `Object.keys(#@hash.$$map).length`.should == 2
@@ -322,11 +322,11 @@ describe 'Hash' do
       `#@hash.$$smap['b'] === undefined`.should == true
       `#@hash.$$smap['c'] === undefined`.should == true
 
-      `#@hash.$$map.hasOwnProperty('hhh')`.should == false
-      `#@hash.$$map.hasOwnProperty(#{@obj1.hash})`.should == false
-      `#@hash.$$smap.hasOwnProperty('a')`.should == false
-      `#@hash.$$smap.hasOwnProperty('b')`.should == false
-      `#@hash.$$smap.hasOwnProperty('c')`.should == false
+      `Opal.hasOwnProperty.call(#@hash.$$map, 'hhh')`.should == false
+      `Opal.hasOwnProperty.call(#@hash.$$map, #{@obj1.hash})`.should == false
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'a')`.should == false
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'b')`.should == false
+      `Opal.hasOwnProperty.call(#@hash.$$smap, 'c')`.should == false
     end
   end
 end

data/spec/opal/core/kernel/rand_spec.rb

@@ -12,10 +12,6 @@ describe "Kernel.rand" do
     r.to_a.include?(rand(r)).should == true
   end
 
-  it "should convert negative number and convert to integer" do
-    rand(-0.1).should == 0
-  end
-
   it "returns a numeric in opal" do
     rand.should be_kind_of(Numeric)
     rand(77).should be_kind_of(Numeric)

data/spec/opal/core/kernel/respond_to_spec.rb

@@ -12,6 +12,9 @@ class RespondToSpecs
   def some_method
     :foo
   end
+
+  def foo
+  end
 end
 
 describe "Kernel.respond_to?" do
@@ -35,7 +38,7 @@ describe "Kernel#respond_to?" do
   end
 
   it "returns false if a method exists, but is marked with a '$$stub' property" do
-    `#{@a}.$some_method.$$stub = true`
-    @a.respond_to?(:some_method).should be_false
+    `#{@a}.$foo.$$stub = true`
+    @a.respond_to?(:foo).should be_false
   end
 end

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

@@ -0,0 +1,38 @@
+ConstantLookupSpec_TopDef = 123
+def self._ConstantLookupSpec_TopDef
+  ConstantLookupSpec_TopDef
+end
+ConstantLookupSpec_TopDefValue = _ConstantLookupSpec_TopDef
+
+module ConstantLookupSpec_Module
+end
+class ConstantLookupSpec_Class
+end
+
+module ConstantLookupSpec_Namespace
+  class NamespacedClass
+    def self.foo
+      ConstantLookupSpec_TopDef
+    end
+  end
+end
+
+
+describe 'constant lookup' do
+  it 'can reach constants from methods defined at top level' do
+    ::ConstantLookupSpec_TopDefValue.should == 123
+    ::ConstantLookupSpec_TopDefValue.should == ::ConstantLookupSpec_TopDef
+    ::ConstantLookupSpec_TopDefValue.should == ConstantLookupSpec_TopDef
+  end
+
+  it 'cannot reach a toplevel constant from a qualified lookup on another toplevel constant' do
+    ->{ConstantLookupSpec_Module::ConstantLookupSpec_Class}.should raise_error(NameError)
+
+    # When the cref is a module then ::Object is added to the search
+    ->{ConstantLookupSpec_Class::ConstantLookupSpec_Module}.should_not raise_error
+  end
+
+  it 'can reach a constant from inside a namespaced class' do
+    ConstantLookupSpec_Namespace::NamespacedClass.foo.should == 123
+  end
+end

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

@@ -0,0 +1,7 @@
+describe 'Safe navigator' do
+  it "handles also null and undefined" do
+    [`null`, `undefined`].each do |value|
+      value&.unknown.should == nil
+    end
+  end
+end

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

@@ -73,7 +73,7 @@ describe "Invoking a method" do
         specs.fooM1O1(1,2,3)
       }.should raise_error(ArgumentError)
     end
-    
+
     it "keeps the block if supplied" do
       block = lambda {}
       specs.fooM1O2(1, foo: :bar, &block).should == [1, {foo: :bar}, block]
@@ -102,14 +102,6 @@ describe "Invoking a method" do
     prc.call.should == "hello"
   end
 
-  it "with an object as a block uses 'to_proc' for coercion" do
-    o = LangSendSpecs::ToProc.new(:from_to_proc)
-
-    specs.makeproc(&o).call.should == :from_to_proc
-
-    specs.yield_now(&o).should == :from_to_proc
-  end
-
   it "raises a SyntaxError with both a literal block and an object as block" do
     lambda {
       eval "specs.oneb(10, &l){ 42 }"

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

@@ -16,29 +16,29 @@ describe "Ruby character strings" do
 
   it "should not process escape characters in single-quoted heredocs" do
     s = <<'EOD'
-      hey\now\brown\cow
-    EOD
+  hey\now\brown\cow
+EOD
     s.strip.should == 'hey\now\brown\cow'
   end
 
   it "should ignore single-quote escapes in single-quoted heredocs" do
     s = <<'EOD'
-      they\'re greeeeaaat!
-    EOD
+  they\'re greeeeaaat!
+EOD
     s.strip.should == 'they\\\'re greeeeaaat!'
   end
 
   it "should process escape characters in double quoted heredocs" do
     s = <<"EOD"
-      hey\now\brown\cow
-    EOD
+  hey\now\brown\cow
+EOD
     s.strip.should == "hey\now\brown\cow"
   end
 
   it "should treat bare-word heredoc identifiers as double-quoted" do
     s = <<EOD
-      hey\now\brown\cow
-    EOD
+  hey\now\brown\cow
+EOD
     s.strip.should == "hey\now\brown\cow"
   end
 end

data/spec/opal/core/language/versions/def_2_0_spec.rb

@@ -17,10 +17,6 @@ describe "An instance method with keyword arguments" do
       foo(a: nil).should be_nil
     end
 
-    it "raises an argument error when an unknown keyword argument is provided" do
-      lambda { foo(b: 20) }.should raise_error(ArgumentError)
-    end
-
     it "raises an argument error when a non-keyword argument is provided" do
       lambda { foo(1) }.should raise_error(ArgumentError)
     end