opal 1.6.1 → 1.7.0

data/spec/lib/builder_spec.rb

@@ -30,8 +30,8 @@ RSpec.describe Opal::Builder do
 
     it 'compiles them as empty files' do
       source = 'require "foo"'
-      expect(ruby_processor).to receive('new').with(source, anything, anything).once.and_call_original
-      expect(ruby_processor).to receive('new').with('',     anything, anything).once.and_call_original
+      expect(ruby_processor).to receive('new').with(source, anything, anything, anything).once.and_call_original
+      expect(ruby_processor).to receive('new').with('',     anything, anything, anything).once.and_call_original
 
       builder.build_str(source, 'bar.rb')
     end
@@ -53,8 +53,8 @@ RSpec.describe Opal::Builder do
 
     it 'compiles them as empty files' do
       source = 'puts 5'
-      expect(ruby_processor).to receive('new').with(anything, './base64.rb', anything).once.and_call_original
-      expect(ruby_processor).to receive('new').with(source, anything, anything).once.and_call_original
+      expect(ruby_processor).to receive('new').with(anything, './base64.rb', anything, anything).once.and_call_original
+      expect(ruby_processor).to receive('new').with(source, anything, anything, anything).once.and_call_original
 
       builder.build_str(source, 'bar.rb')
     end

data/spec/lib/rewriters/forward_args_spec.rb

@@ -15,6 +15,8 @@ RSpec.describe Opal::Rewriters::ForwardArgs do
       end.yield_self { |children| s(ast.type, *children) }
     when :fwd_rest
       "$fwd_rest"
+    when :fwd_kwrest
+      "$fwd_kwrest"
     when :fwd_block
       "$fwd_block"
     else
@@ -32,6 +34,36 @@ RSpec.describe Opal::Rewriters::ForwardArgs do
     end
   ENDDEST
 
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
+    def forward_star(*)
+      other(*)
+    end
+  ENDSOURCE
+    def forward_star(*fwd_rest)
+      other(*fwd_rest)
+    end
+  ENDDEST
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
+    def forward_kwstar(**)
+      other(**)
+    end
+  ENDSOURCE
+    def forward_kwstar(**fwd_kwrest)
+      other(**fwd_kwrest)
+    end
+  ENDDEST
+
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
+    def forward_block(&)
+      other(&)
+    end
+  ENDSOURCE
+    def forward_block(&fwd_block)
+      other(&fwd_block)
+    end
+  ENDDEST
+
   include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
     def forward(first_arg, ...)
       other(first_arg, second_arg, ...)
@@ -45,16 +77,4 @@ RSpec.describe Opal::Rewriters::ForwardArgs do
       other(*fwd_rest, &fwd_block)
     end
   ENDDEST
-
-  # Not supported by the parser (nor by the rewriter which would have to rearrange the arguments)
-
-  # include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
-  #   def forward(a:, ...)
-  #     other(...)
-  #   end
-  # ENDSOURCE
-  #   def forward(*fwd_rest, a:, &fwd_block)
-  #     other(*fwd_rest, &fwd_block)
-  #   end
-  # ENDDEST
 end

data/spec/mspec-opal/runner.rb

@@ -79,6 +79,8 @@ class OSpecFormatter
       'browser'      => BrowserFormatter,
       'server'       => BrowserFormatter,
       'chrome'       => DottedFormatter,
+      'firefox'      => DottedFormatter,
+      'deno'         => NodeJSFormatter,
       'node'         => NodeJSFormatter,
       'nodejs'       => NodeJSFormatter,
       'gjs'          => ColoredDottedFormatter,

data/spec/ruby_specs

@@ -37,6 +37,8 @@ ruby/core/comparable
 ruby/core/complex
 !ruby/core/complex/marshal_dump_spec
 
+ruby/core/data
+
 ruby/core/enumerable
 ruby/core/enumerator
 ruby/core/enumerator/arithmetic_sequence
@@ -126,6 +128,8 @@ ruby/core/rational
 ruby/core/regexp
 ruby/core/random
 
+ruby/core/refinement
+
 ruby/core/string
 !ruby/core/string/crypt_spec
 !ruby/core/string/scrub_spec

data/stdlib/deno/base.rb

@@ -0,0 +1,28 @@
+module Deno
+  VERSION = `Deno.version.deno`
+end
+
+`Opal.exit = Deno.exit`
+
+ARGV = `Deno.args.slice(2)`
+ARGV.shift if ARGV.first == '--'
+
+STDOUT.write_proc = ->(string) { `Deno.stdout.write(new TextEncoder().encode(string))` }
+STDERR.write_proc = ->(string) { `Deno.stderr.write(new TextEncoder().encode(string))` }
+
+STDIN.read_proc = %x{function(_count) {
+  // Ignore count, return as much as we can get
+  var buf = new Uint8Array(65536), count;
+  try {
+    count = Deno.stdin.readSync(buf);
+  }
+  catch (e) { // Windows systems may raise EOF
+    return nil;
+  }
+  if (count == 0) return nil;
+  return buf.toString('utf8', 0, count);
+}}
+
+STDIN.tty = true
+STDOUT.tty = true
+STDERR.tty = true

data/stdlib/deno/file.rb

@@ -0,0 +1,340 @@
+`/* global Deno */`
+require 'corelib/file'
+
+%x{
+  var warnings = {}, errno_codes = #{Errno.constants};
+
+  function handle_unsupported_feature(message) {
+    switch (Opal.config.unsupported_features_severity) {
+    case 'error':
+      #{Kernel.raise NotImplementedError, `message`}
+      break;
+    case 'warning':
+      warn(message)
+      break;
+    default: // ignore
+      // noop
+    }
+  }
+  function warn(string) {
+    if (warnings[string]) {
+      return;
+    }
+    warnings[string] = true;
+    #{warn(`string`)};
+  }
+  function is_utf8(bytes) {
+    var i = 0;
+    while (i < bytes.length) {
+      if ((// ASCII
+        bytes[i] === 0x09 ||
+        bytes[i] === 0x0A ||
+        bytes[i] === 0x0D ||
+        (0x20 <= bytes[i] && bytes[i] <= 0x7E)
+      )
+      ) {
+        i += 1;
+        continue;
+      }
+
+      if ((// non-overlong 2-byte
+        (0xC2 <= bytes[i] && bytes[i] <= 0xDF) &&
+        (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0xBF)
+      )
+      ) {
+        i += 2;
+        continue;
+      }
+
+      if ((// excluding overlongs
+          bytes[i] === 0xE0 &&
+          (0xA0 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF)
+        ) ||
+        (// straight 3-byte
+          ((0xE1 <= bytes[i] && bytes[i] <= 0xEC) ||
+            bytes[i] === 0xEE ||
+            bytes[i] === 0xEF) &&
+          (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF)
+        ) ||
+        (// excluding surrogates
+          bytes[i] === 0xED &&
+          (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0x9F) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF)
+        )
+      ) {
+        i += 3;
+        continue;
+      }
+
+      if ((// planes 1-3
+          bytes[i] === 0xF0 &&
+          (0x90 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+          (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+        ) ||
+        (// planes 4-15
+          (0xF1 <= bytes[i] && bytes[i] <= 0xF3) &&
+          (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0xBF) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+          (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+        ) ||
+        (// plane 16
+          bytes[i] === 0xF4 &&
+          (0x80 <= bytes[i + 1] && bytes[i + 1] <= 0x8F) &&
+          (0x80 <= bytes[i + 2] && bytes[i + 2] <= 0xBF) &&
+          (0x80 <= bytes[i + 3] && bytes[i + 3] <= 0xBF)
+        )
+      ) {
+        i += 4;
+        continue;
+      }
+
+      return false;
+    }
+
+    return true;
+  }
+  function executeIOAction(action) {
+    try {
+      return action();
+    } catch (error) {
+      if (errno_codes.indexOf(error.code) >= 0) {
+        var error_class = #{Errno.const_get(`error.code`)}
+        #{Kernel.raise `error_class`.new(`error.message`)}
+      }
+      #{Kernel.raise `error`}
+    }
+  }
+}
+
+class File < IO
+  `var __utf8TextDecoder__ = new TextDecoder('utf8')`
+  `var __textEncoder__ = new TextEncoder()`
+
+  def self.read(path)
+    `return executeIOAction(function(){return Deno.readFileSync(#{path}).toString()})`
+  end
+
+  def self.write(path, data)
+    `executeIOAction(function(){return Deno.writeFileSync(#{path}, __textEncoder__.encode(#{data}));})`
+    data.size
+  end
+
+  def self.delete(path)
+    `executeIOAction(function(){return Deno.removeSync(#{path})})`
+  end
+
+  class << self
+    alias unlink delete
+  end
+
+  def self.exist?(path)
+    path = path.path if path.respond_to? :path
+    `return executeIOAction(function(){return Deno.statSync(#{path})})`
+  end
+
+  def self.realpath(pathname, dir_string = nil, cache = nil, &block)
+    pathname = join(dir_string, pathname) if dir_string
+    if block_given?
+      `
+        Deno.realpath(#{pathname}, #{cache}, function(error, realpath){
+          if (error) Opal.IOError.$new(error.message)
+          else #{block.call(`realpath`)}
+        })
+        `
+    else
+      `return executeIOAction(function(){return Deno.realpathSync(#{pathname}, #{cache})})`
+    end
+  end
+
+  def self.join(*paths)
+    # by itself, `path.posix.join` normalizes leading // to /.
+    # restore the leading / on UNC paths (i.e., paths starting with //).
+    paths = paths.map(&:to_s)
+    prefix = paths.first&.start_with?('//') ? '/' : ''
+    path = prefix
+    paths.each do |pth|
+      path << if pth.end_with?('/') || pth.start_with?('/')
+                pth
+              else
+                '/' + pth
+              end
+    end
+    path
+  end
+
+  def self.directory?(path)
+    return false unless exist? path
+    result = `executeIOAction(function(){return !!Deno.lstatSync(path).isDirectory})`
+    unless result
+      realpath = realpath(path)
+      if realpath != path
+        result = `executeIOAction(function(){return !!Deno.lstatSync(realpath).isDirectory})`
+      end
+    end
+    result
+  end
+
+  def self.file?(path)
+    return false unless exist? path
+    result = `executeIOAction(function(){return !!Deno.lstatSync(path).isFile})`
+    unless result
+      realpath = realpath(path)
+      if realpath != path
+        result = `executeIOAction(function(){return !!Deno.lstatSync(realpath).isFile})`
+      end
+    end
+    result
+  end
+
+  def self.readable?(path)
+    return false unless exist? path
+    %{
+      try {
+        Deno.openSync(path, {read: true}).close();
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
+  end
+
+  def self.size(path)
+    `return executeIOAction(function(){return Deno.lstatSync(path).size})`
+  end
+
+  def self.open(path, mode = 'r')
+    file = new(path, mode)
+    if block_given?
+      begin
+        yield(file)
+      ensure
+        file.close
+      end
+    else
+      file
+    end
+  end
+
+  def self.stat(path)
+    path = path.path if path.respond_to? :path
+    File::Stat.new(path)
+  end
+
+  def self.mtime(path)
+    `return executeIOAction(function(){return Deno.statSync(#{path}).mtime})`
+  end
+
+  def self.symlink?(path)
+    `return executeIOAction(function(){return Deno.lstatSync(#{path}).isSymLink})`
+  end
+
+  def self.absolute_path(path, basedir = nil)
+    raise 'File::absolute_path is currently unsupported in Deno!'
+  end
+
+  # Instance Methods
+
+  def initialize(path, flags = 'r')
+    @binary_flag = flags.include?('b')
+    # Node does not recognize this flag
+    flags = flags.delete('b')
+    # encoding flag is unsupported
+    encoding_option_rx = /:(.*)/
+    if encoding_option_rx.match?(flags)
+      `handle_unsupported_feature("Encoding option (:encoding) is unsupported by Node.js openSync method and will be removed.")`
+      flags = flags.sub(encoding_option_rx, '')
+    end
+    @path = path
+
+    fd = `executeIOAction(function(){return Deno.openSync(path, flags)})`
+    super(fd, flags)
+  end
+
+  attr_reader :path
+
+  def sysread(bytes)
+    if @eof
+      raise EOFError, 'end of file reached'
+    else
+      if @binary_flag
+        %x{
+          var buf = executeIOAction(function(){return Deno.readFileSync(#{@path})})
+          var content
+          if (is_utf8(buf)) {
+            content = buf.toString('utf8')
+          } else {
+            // coerce to utf8
+            content = __utf8TextDecoder__.decode(__textEncoder__.encode(buf.toString('binary')))
+          }
+        }
+        res = `content`
+      else
+        res = `executeIOAction(function(){return Deno.readFileSync(#{@path}).toString('utf8')})`
+      end
+      @eof = true
+      @lineno = res.size
+      res
+    end
+  end
+
+  def write(string)
+    `executeIOAction(function(){return #{@fd}.writeSync(__textEncoder__.encode(#{string}))})`
+  end
+
+  def flush
+    # not supported by deno
+  end
+
+  def close
+    `executeIOAction(function(){return #{@fd}.close()})`
+    super
+  end
+
+  def mtime
+    `return executeIOAction(function(){return Deno.statSync(#{@path}).mtime})`
+  end
+end
+
+class File::Stat
+  def initialize(path)
+    @path = path
+  end
+
+  def file?
+    `return executeIOAction(function(){return Deno.statSync(#{@path}).isFile})`
+  end
+
+  def directory?
+    `return executeIOAction(function(){return Deno.statSync(#{@path}).isDirectory})`
+  end
+
+  def mtime
+    `return executeIOAction(function(){return Deno.statSync(#{@path}).mtime})`
+  end
+
+  def readable?
+    %x{
+      return executeIOAction(function(){
+        Deno.openSync(path, {read: true}).close();
+        return true;
+      })
+    }
+  end
+
+  def writable?
+    %x{
+      return executeIOAction(function(){
+        Deno.openSync(path, {write: true}).close();
+        return true;
+      })
+    }
+  end
+
+  def executable?
+    # accessible only over unstable API
+    false
+  end
+end

data/stdlib/{headless_chrome.rb → headless_browser/base.rb}

@@ -9,7 +9,7 @@
 
     if (window.OPAL_EXIT_CODE === "noexit") {
       window.OPAL_EXIT_CODE = code;
-      window.alert("opalheadlesschromeexit");
+      window.alert("opalheadlessbrowserexit");
     }
   }
 }

data/stdlib/headless_browser/file.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class File
+  def self.write(path, data)
+    # This is only to enable CDP runners to write the benchmark results
+    %x{
+      var http = new XMLHttpRequest();
+      http.open("POST", "/File.write");
+      http.setRequestHeader("Content-Type", "application/json");
+      // Failure is not an option
+      http.send(JSON.stringify({filename: #{path}, data: #{data}, secret: window.OPAL_CDP_SHARED_SECRET}));
+    }
+    data.length
+  end
+end

data/stdlib/headless_browser.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'headless_browser/base'
+require 'headless_browser/file'

data/stdlib/native.rb

@@ -615,7 +615,7 @@ end
 class Class
   def native_alias(new_jsid, existing_mid)
     %x{
-      var aliased = #{self}.prototype['$' + #{existing_mid}];
+      var aliased = #{self}.prototype[Opal.jsid(#{existing_mid})];
       if (!aliased) {
         #{raise NameError.new("undefined method `#{existing_mid}' for class `#{inspect}'", existing_mid)};
       }

data/stdlib/nodejs/file.rb

@@ -135,6 +135,11 @@ class File < IO
     data.size
   end
 
+  def self.symlink(path, new_path)
+    `executeIOAction(function(){return __fs__.symlinkSync(#{path}, #{new_path})})`
+    0
+  end
+
   def self.delete(path)
     `executeIOAction(function(){return __fs__.unlinkSync(#{path})})`
   end

data/stdlib/opal/platform.rb

@@ -1,10 +1,12 @@
 require 'opal-platform'
 
 case OPAL_PLATFORM
-when 'nashorn'         then require 'nashorn'
-when 'gjs'             then require 'gjs'
-when 'quickjs'         then require 'quickjs'
-when 'nodejs'          then require 'nodejs/base'
-when 'headless-chrome' then require 'headless_chrome'
-when 'opal-miniracer'  then require 'opal/miniracer'
+when 'nashorn'          then require 'nashorn'
+when 'gjs'              then require 'gjs'
+when 'quickjs'          then require 'quickjs'
+when 'deno'             then require 'deno/base'
+when 'nodejs'           then require 'nodejs/base'
+when 'headless-chrome'  then require 'headless_browser/base'
+when 'headless-firefox' then require 'headless_browser/base'
+when 'opal-miniracer'   then require 'opal/miniracer'
 end

data/stdlib/opal-platform.rb

@@ -1,19 +1,25 @@
-`/* global Java, GjsFileImporter */`
+`/* global Java, GjsFileImporter, Deno */`
 
-browser         = `typeof(document) !== "undefined"`
-node            = `typeof(process) !== "undefined" && process.versions && process.versions.node`
-nashorn         = `typeof(Java) !== "undefined" && Java.type`
-headless_chrome = `typeof(opalheadlesschrome) !== 'undefined'`
-gjs             = `typeof(window) !== "undefined" && typeof(GjsFileImporter) !== 'undefined'`
-quickjs         = `typeof(window) === "undefined" && typeof(__loadScript) !== 'undefined'`
-opal_miniracer  = `typeof(opalminiracer) !== 'undefined'`
+browser          = `typeof(document) !== "undefined"`
+deno             = `typeof(Deno) === "object" && typeof(Deno.version) === "object"`
+node             = `typeof(process) !== "undefined" && process.versions && process.versions.node`
+nashorn          = `typeof(Java) !== "undefined" && Java.type`
+headless_chrome  = `typeof(opalheadlesschrome) !== "undefined"`
+headless_firefox = `typeof(opalheadlessfirefox) !== "undefined"`
+gjs              = `typeof(window) !== "undefined" && typeof(GjsFileImporter) !== "undefined"`
+quickjs          = `typeof(window) === "undefined" && typeof(__loadScript) !== "undefined"`
+opal_miniracer   = `typeof(opalminiracer) !== "undefined"`
 
 OPAL_PLATFORM = if nashorn
                   'nashorn'
+                elsif deno
+                  'deno'
                 elsif node
                   'nodejs'
                 elsif headless_chrome
                   'headless-chrome'
+                elsif headless_firefox
+                  'headless-firefox'
                 elsif gjs
                   'gjs'
                 elsif quickjs