opal 1.8.1 → 1.8.3.rc1

data/spec/lib/rewriters/hashes/key_duplicates_rewriter_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Opal::Rewriters::Hashes::KeyDuplicatesRewriter do
   shared_examples 'it warns' do |code, key_to_warn|
     context "for #{code} code" do
       it "warns about #{key_to_warn.inspect} being overwritten" do
-        expect(Kernel).to receive(:warn).with("warning: key #{key_to_warn.inspect} is duplicated and overwritten")
+        expect(Kernel).to receive(:warn).with("warning: key #{key_to_warn.inspect} is duplicated and overwritten") { nil }
 
         ast = parse_without_rewriting(code)
         rewrite(ast)

data/spec/lib/spec_helper.rb

@@ -5,15 +5,26 @@ if ENV['CHECK_COVERAGE']
   Coveralls.wear!
 end
 
+if ENV['CHECK_COVERAGE_SIMPLECOV']
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'opal'
 
 ENV['OPAL_DISABLE_PREFORK_LOGS'] = '1'
 
+$diagnostic_messages = []
+Opal::Parser.default_parser_class.diagnostics_consumer = ->(diagnostic) do
+  $diagnostic_messages << diagnostic.render
+end
+
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   config.before { Opal.reset_paths! unless RUBY_PLATFORM == 'opal' }
   config.before { Opal::Config.reset! if defined? Opal::Config }
   config.before { Opal::Processor.reset_cache_key! if defined? Opal::Processor }
+  config.before { $diagnostic_messages.clear }
 
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest

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

@@ -0,0 +1,12 @@
+# backtick_javascript: true
+
+describe "Array#include" do
+  it "should respect nil values" do
+    nileq = Object.new
+    def nileq.==(other)
+      nil
+    end
+
+    [nileq].should_not include("no match expected")
+  end
+end

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

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

data/spec/opal/core/string_spec.rb

@@ -26,3 +26,38 @@ describe 'Encoding' do
     end
   end
 end
+
+describe 'strip methods' do
+  def strip_cases(before, after, method)
+    before = before ? 1 : 0
+    after = after ? 1 : 0
+
+    it 'strip spaces' do
+      "#{"  " * before}ABC#{"  " * after}".send(method).should == "ABC"
+    end
+
+    it 'strips NUL bytes' do
+      "#{"\0" * before}ABC#{"\0" * after}".send(method).should == "ABC"
+    end
+
+    it "doesn't strip NBSPs" do
+      "#{"\u{a0}" * before}ABC#{"\u{a0}" * after}".send(method).should != "ABC"
+    end
+
+    it "strips all other supported whitespace characters" do
+      "#{"\r\n\t\v\f" * before}ABC#{"\r\n\t\v\f" * after}".send(method).should == "ABC"
+    end
+  end
+
+  describe '#lstrip' do
+   strip_cases true, false, :lstrip
+  end
+
+  describe '#rstrip' do
+    strip_cases false, true, :rstrip
+  end
+
+  describe '#strip' do
+    strip_cases true, true, :strip
+  end
+end

data/spec/opal/stdlib/native/hash_spec.rb

@@ -82,14 +82,14 @@ describe Hash do
     it 'converts a hash with native objects as values' do
       obj = { 'a_key' => `{ key: 1 }` }
       native = obj.to_n
-      `#{native}.get('a_key').key`.should == 1
+      `#{native}.a_key.key`.should == 1
     end
 
     it 'passes Ruby objects that cannot be converted' do
       object = Object.new
       hash = { foo: object }
       native = hash.to_n
-      expect(`#{native}.get('foo')`).to eq object
+      expect(`#{native}.foo`).to eq object
     end
   end
 end

data/spec/opal/stdlib/opal_raw_spec.rb

@@ -0,0 +1,74 @@
+# backtick_javascript: true
+
+require 'spec_helper'
+require 'opal/raw'
+
+describe 'javascript operations using Opal::Raw module' do
+  it 'Opal::Raw.typeof uses typeof to return underlying javascript type' do
+    [1, `null`, `undefined`, Object.new, [], ""].each do |v|
+      Opal::Raw.typeof(v).should == `typeof #{v}`
+    end
+  end
+
+  it 'Opal::Raw.new uses new to create new instance' do
+    f = `function(){}`
+    f.JS[:prototype].JS[:color] = 'black'
+    Opal::Raw.new(f).JS[:color].should == 'black'
+  end
+
+  it 'Opal::Raw.new handles blocks' do
+    f = `function(a){this.a = a}`
+    Opal::Raw.new(f){1}.JS.a.should == 1
+  end
+
+  it 'Opal::Raw.instanceof uses instanceof to check if value is an instance of a function' do
+    f = `function(){}`
+    Opal::Raw.instanceof(Opal::Raw.new(f), f).should == true
+    Opal::Raw.instanceof(Opal::Raw.new(f), `function(){}`).should == false
+  end
+
+  it 'Opal::Raw.delete uses delete to remove properties from objects' do
+    f = `{a:1}`
+    f.JS[:a].should == 1
+    Opal::Raw.delete(f, :a)
+    `#{f.JS[:a]} === undefined`.should == true
+  end
+
+  it 'Opal::Raw.in uses in to check for properties in objects' do
+    f = `{a:1}`
+    Opal::Raw.in(:a, f).should == true
+    Opal::Raw.in(:b, f).should == false
+  end
+
+  it 'Opal::Raw.void returns undefined' do
+    f = 1
+    `#{Opal::Raw.void(f += 1)} === undefined`.should == true
+    f.should == 2
+  end
+
+  it 'Opal::Raw.call calls global javascript methods' do
+    Opal::Raw.call(:parseFloat, '1.0').should == 1
+    Opal::Raw.call(:parseInt, '1').should == 1
+    Opal::Raw.call(:eval, "({a:1})").JS[:a].should == 1
+  end
+
+  it 'Opal::Raw.method_missing calls global javascript methods' do
+    Opal::Raw.parseFloat('1.0').should == 1
+    Opal::Raw.parseInt('1').should == 1
+  end
+
+  it 'Opal::Raw.call calls global javascript methods with blocks' do
+    begin
+      Opal::Raw.global.JS[:_test_global_function] = lambda{|pr| pr.call + 1}
+      Opal::Raw._test_global_function{1}.should == 2
+    ensure
+      Opal::Raw.delete(Opal::Raw.global, :_test_global_function)
+    end
+  end
+
+  it 'JS.<METHOD> supports complex method calls' do
+    obj = `{ foo: function(){return "foo"} }`
+    args = [1,2,3]
+    obj.JS.foo(*args).should == :foo
+  end
+end

data/spec/support/source_map_helper.rb

@@ -48,7 +48,7 @@ module SourceMapHelper
 
     def find_section_in_map_index(index_map)
       sections = index_map.to_h[:sections]
-      section, section_index = sections.each.with_index.find do |map, index|
+      section, _section_index = sections.each.with_index.find do |map, index|
         next_map = sections[index + 1] or next true # if there's no next map the current one is good
 
         (
@@ -58,8 +58,6 @@ module SourceMapHelper
         )
       end
 
-      next_section = sections[section_index + 1]
-
       section or raise "no map found for #{inspect} among available sections: #{sections.map { |s| s[:offset] }}"
     end
 

data/stdlib/bigdecimal.rb

@@ -2,7 +2,7 @@
 
 class BigDecimal < Numeric; end
 
-require 'js'
+require 'opal/raw'
 require 'bigdecimal/bignumber'
 
 module Kernel
@@ -57,7 +57,7 @@ class BigDecimal < Numeric
   attr_reader :bignumber
 
   def initialize(initial, digits = 0)
-    @bignumber = JS.new(BigNumber, initial)
+    @bignumber = Opal::Raw.new(BigNumber, initial)
   end
 
   def ==(other)
@@ -102,7 +102,7 @@ class BigDecimal < Numeric
   end
 
   def abs
-    self.class.new(bignumber.JS.abs)
+    BigDecimal(bignumber.JS.abs)
   end
 
   def add(other, digits = 0)
@@ -122,7 +122,7 @@ class BigDecimal < Numeric
       result = result.JS.toDigits(digits, self.class.mode(ROUND_MODE))
     end
 
-    self.class.new(result)
+    BigDecimal(result)
   end
 
   def ceil(n = nil)
@@ -133,9 +133,9 @@ class BigDecimal < Numeric
     if n.nil?
       bignumber.JS.round(0, ROUND_CEILING).JS.toNumber
     elsif n >= 0
-      self.class.new(bignumber.JS.round(n, ROUND_CEILING))
+      BigDecimal(bignumber.JS.round(n, ROUND_CEILING))
     else
-      self.class.new(bignumber.JS.round(0, ROUND_CEILING))
+      BigDecimal(bignumber.JS.round(0, ROUND_CEILING))
     end
   end
 
@@ -144,7 +144,7 @@ class BigDecimal < Numeric
     when self.class
       [other, self]
     when Number
-      [self.class.new(other), self]
+      [BigDecimal(other), self]
     else
       raise TypeError, "#{other.class} can't be coerced into #{self.class}"
     end
@@ -168,10 +168,10 @@ class BigDecimal < Numeric
         raise FloatDomainError, "Computation results to 'Infinity'"
       end
 
-      return self.class.new(bignumber.JS.dividedToIntegerBy(other.bignumber))
+      return BigDecimal(bignumber.JS.dividedToIntegerBy(other.bignumber))
     end
 
-    self.class.new(bignumber.JS.dividedBy(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
+    BigDecimal(bignumber.JS.dividedBy(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
   end
 
   def finite?
@@ -185,17 +185,17 @@ class BigDecimal < Numeric
 
   def minus(other)
     other, _ = coerce(other)
-    self.class.new(bignumber.JS.minus(other.bignumber))
+    BigDecimal(bignumber.JS.minus(other.bignumber))
   end
 
   def mult(other, digits = nil)
     other, _ = coerce(other)
 
     if digits.nil?
-      return self.class.new(bignumber.JS.times(other.bignumber))
+      return BigDecimal(bignumber.JS.times(other.bignumber))
     end
 
-    self.class.new(bignumber.JS.times(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
+    BigDecimal(bignumber.JS.times(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
   end
 
   def nan?
@@ -204,7 +204,7 @@ class BigDecimal < Numeric
 
   def quo(other)
     other, _ = coerce(other)
-    self.class.new(bignumber.JS.dividedBy(other.bignumber))
+    BigDecimal(bignumber.JS.dividedBy(other.bignumber))
   end
 
   def sign
@@ -218,7 +218,7 @@ class BigDecimal < Numeric
 
   def sub(other, precision)
     other, _ = coerce(other)
-    self.class.new(bignumber.JS.minus(other.bignumber))
+    BigDecimal(bignumber.JS.minus(other.bignumber))
   end
 
   def to_f

data/stdlib/date/date_time.rb

@@ -29,7 +29,7 @@ class DateTime < Date
   alias second sec
 
   def sec_fraction
-    @date.usec / 1_000_000r
+    @date.usec/1_000_000r
   end
 
   alias second_fraction sec_fraction

data/stdlib/deno/file.rb

@@ -193,7 +193,7 @@ class File < IO
 
   def self.readable?(path)
     return false unless exist? path
-    %{
+    %x{
       try {
         Deno.openSync(path, {read: true}).close();
         return true;

data/stdlib/js.rb

@@ -1,71 +1,12 @@
 # backtick_javascript: true
 
-# The JS module provides syntax sugar for calling native javascript
-# operators (e.g. typeof, instanceof, new, delete) and global functions
-# (e.g. parseFloat, parseInt).
-module JS
-  # Use delete to remove a property from an object.
-  def delete(object, property)
-    `delete #{object}[#{property}]`
-  end
-
-  # The global object
-  def global
-    `Opal.global`
-  end
-
-  # Use in to check for a property in an object.
-  def in(property, object)
-    `#{property} in #{object}`
-  end
-
-  # Use instanceof to return whether value is an instance of the function.
-  def instanceof(value, func)
-    `#{value} instanceof #{func}`
-  end
-
-  # Use new to create a new instance of the prototype of the function.
-  if `typeof Function.prototype.bind == 'function'`
-    def new(func, *args, &block)
-      args.insert(0, `this`)
-      args << block if block
-      `new (#{func}.bind.apply(#{func}, #{args}))()`
-    end
-  else
-    def new(func, *args, &block)
-      args << block if block
-      f = `function(){return func.apply(this, args)}`
-      f.JS[:prototype] = func.JS[:prototype]
-      `new f()`
-    end
-  end
+require 'opal/raw'
 
-  # Use typeof to return the underlying javascript type of value.
-  # Note that for undefined values, this will not work exactly like
-  # the javascript typeof operator, as the argument is evaluated before
-  # the function call.
-  def typeof(value)
-    `typeof #{value}`
-  end
+warn '[Opal] JS module has been renamed to Opal::Raw and will change semantics in Opal 2.1. ' \
+     'In addition, you will need to require "opal/raw" instead of "js". ' \
+     'To ensure forward compatibility, please update your calls.'
 
-  # Use void to return undefined.
-  def void(expr)
-    # Could use `undefined` here, but this is closer to the intent of the method
-    `void #{expr}`
-  end
-
-  # Call the global javascript function with the given arguments.
-  def call(func, *args, &block)
-    g = global
-    args << block if block
-    g.JS[func].JS.apply(g, args)
-  end
-
-  def [](name)
-    `Opal.global[#{name}]`
-  end
-
-  alias method_missing call
-
-  extend self
+module JS
+  extend Opal::Raw
+  include Opal::Raw
 end

data/stdlib/native.rb

@@ -587,14 +587,14 @@ unless Hash.method_defined? :_initialize
       }
     end
 
-    # @return a JavaScript Map but calling #to_n on
+    # @return a JavaScript object, in turn also calling #to_n on
     # all keys and values.
     def to_n
       %x{
-        var result = new Map();
+        var result = {};
 
         Opal.hash_each(self, false, function(key, value) {
-          result.set(#{Native.try_convert(`key`, `key`)} , #{Native.try_convert(`value`, `value`)});
+          result[#{Native.try_convert(`key`, `key`)}] = #{Native.try_convert(`value`, `value`)};
           return [false, false];
         });
 

data/stdlib/nodejs/file.rb

@@ -203,14 +203,14 @@ class File < IO
 
   def self.readable?(path)
     return false unless exist? path
-    %{
-        try {
-          __fs__.accessSync(path, __fs__.R_OK);
-          return true;
-        } catch (error) {
-          return false;
-        }
+    %x{
+      try {
+        __fs__.accessSync(path, __fs__.R_OK);
+        return true;
+      } catch (error) {
+        return false;
       }
+    }
   end
 
   def self.size(path)

data/stdlib/opal/raw.rb

@@ -0,0 +1,73 @@
+# backtick_javascript: true
+
+# The Opal::Raw module provides syntax sugar for calling native javascript
+# operators (e.g. typeof, instanceof, new, delete) and global functions
+# (e.g. parseFloat, parseInt).
+module ::Opal
+  module Raw
+    # Use delete to remove a property from an object.
+    def delete(object, property)
+      `delete #{object}[#{property}]`
+    end
+
+    # The global object
+    def global
+      `Opal.global`
+    end
+
+    # Use in to check for a property in an object.
+    def in(property, object)
+      `#{property} in #{object}`
+    end
+
+    # Use instanceof to return whether value is an instance of the function.
+    def instanceof(value, func)
+      `#{value} instanceof #{func}`
+    end
+
+    # Use new to create a new instance of the prototype of the function.
+    if `typeof Function.prototype.bind == 'function'`
+      def new(func, *args, &block)
+        args.insert(0, `this`)
+        args << block if block
+        `new (#{func}.bind.apply(#{func}, #{args}))()`
+      end
+    else
+      def new(func, *args, &block)
+        args << block if block
+        f = `function(){return func.apply(this, args)}`
+        f.JS[:prototype] = func.JS[:prototype]
+        `new f()`
+      end
+    end
+
+    # Use typeof to return the underlying javascript type of value.
+    # Note that for undefined values, this will not work exactly like
+    # the javascript typeof operator, as the argument is evaluated before
+    # the function call.
+    def typeof(value)
+      `typeof #{value}`
+    end
+
+    # Use void to return undefined.
+    def void(expr)
+      # Could use `undefined` here, but this is closer to the intent of the method
+      `void #{expr}`
+    end
+
+    # Call the global javascript function with the given arguments.
+    def call(func, *args, &block)
+      g = global
+      args << block if block
+      g.JS[func].JS.apply(g, args)
+    end
+
+    def [](name)
+      `Opal.global[#{name}]`
+    end
+
+    alias method_missing call
+
+    extend self # rubocop:disable Style/ModuleFunction
+  end
+end

data/stdlib/optparse.rb

@@ -1932,7 +1932,7 @@ XXX
   octal = "0(?:[0-7]+(?:_[0-7]+)*|#{binary}|#{hex})?"
   integer = "#{octal}|#{decimal}"
 
-  accept(Integer, %r"\A[-+]?(?:#{integer})\z"io) do |s,|
+  accept(Integer, %r"\A[-+]?(?:#{integer})\z"i) do |s,|
     if s
       begin
         Integer(s)
@@ -1946,7 +1946,7 @@ XXX
   # Float number format, and converts to Float.
   #
   float = "(?:#{decimal}(?=(.)?)(?:\\.(?:#{decimal})?)?|\\.#{decimal})(?:E[-+]?#{decimal})?"
-  floatpat = %r"\A[-+]?#{float}\z"io
+  floatpat = %r"\A[-+]?#{float}\z"i
   accept(Float, floatpat) { |s,| s.to_f if s }
 
   #
@@ -1954,7 +1954,7 @@ XXX
   # for float format, and Rational for rational format.
   #
   real = "[-+]?(?:#{octal}|#{float})"
-  accept(Numeric, /\A(#{real})(?:\/(#{real}))?\z/io) do |s, d, f, n,|
+  accept(Numeric, /\A(#{real})(?:\/(#{real}))?\z/i) do |s, d, f, n,|
     if n
       Rational(d, n)
     elsif f
@@ -1967,7 +1967,7 @@ XXX
   #
   # Decimal integer format, to be converted to Integer.
   #
-  DecimalInteger = /\A[-+]?#{decimal}\z/io
+  DecimalInteger = /\A[-+]?#{decimal}\z/i
   accept(DecimalInteger, DecimalInteger) do |s,|
     if s
       begin
@@ -1982,7 +1982,7 @@ XXX
   # Ruby/C like octal/hexadecimal/binary integer format, to be converted to
   # Integer.
   #
-  OctalInteger = /\A[-+]?(?:[0-7]+(?:_[0-7]+)*|0(?:#{binary}|#{hex}))\z/io
+  OctalInteger = /\A[-+]?(?:[0-7]+(?:_[0-7]+)*|0(?:#{binary}|#{hex}))\z/i
   accept(OctalInteger, OctalInteger) do |s,|
     if s
       begin
@@ -2084,7 +2084,7 @@ XXX
 
     def self.filter_backtrace(array)
       unless $DEBUG
-        array.delete_if(&%r"\A#{Regexp.quote(__FILE__)}:"o.method(:=~))
+        array.delete_if(&%r"\A#{Regexp.quote(__FILE__)}:".method(:=~))
       end
       array
     end

data/stdlib/shellwords.rb

@@ -98,7 +98,7 @@ module Shellwords
       #   characters when considered special:
       #
       #   $ ` " \ <newline>
-      field += (word || sq || (dq && dq.gsub(/\\([$`"\\\n])/, '\\1')) || esc.gsub(/\\(.)/, '\\1'))
+      field += word || sq || (dq && dq.gsub(/\\([$`"\\\n])/, '\\1')) || esc.gsub(/\\(.)/, '\\1')
       if sep
         words << field
         field = String.new

data/tasks/testing.rake

@@ -1,6 +1,7 @@
 require_relative "#{__dir__}/../lib/opal/os"
 require_relative "#{__dir__}/../lib/opal/cli_runners"
 
+require 'timeout'
 require 'rspec/core/rake_task'
 
 OS = Opal::OS unless defined? OS
@@ -196,9 +197,14 @@ module Testing
       begin
         server = Process.spawn "bundle exec rackup --host #{host} --port #{port}"
         puts 'Waiting for server…'
-        sleep 0.1 until system "curl -s 'http://#{host}:#{port}/' > /dev/null"
+        Timeout.timeout(30) do
+          sleep 0.1 until system "curl -s 'http://#{host}:#{port}/' > /dev/null"
+        end
         puts 'Server ready.'
         yield self
+      rescue Timeout::Error
+        puts 'Failed to start rack server'
+        exit(1)
       ensure
         Process.kill(:TERM, server)
         Process.wait(server)
@@ -252,9 +258,14 @@ module Testing
       begin
         server = Process.spawn 'ruby test/opal/http_server.rb'
         puts 'Waiting for server…'
-        sleep 0.1 until sinatra_server_running?
+        Timeout.timeout(30) do
+          sleep 0.1 until sinatra_server_running?
+        end
         puts 'Server ready.'
         yield self
+      rescue Timeout::Error
+        puts 'Failed to start Sinatra server'
+        exit(1)
       ensure
         if OS.windows?
           # https://blog.simplificator.com/2016/01/18/how-to-kill-processes-on-windows-using-ruby/