opal 1.3.2 → 1.4.0.alpha1

data/stdlib/nodejs/base.rb

@@ -0,0 +1,29 @@
+module NodeJS
+  VERSION = `process.version`
+end
+
+`Opal.exit = process.exit`
+
+ARGV = `process.argv.slice(2)`
+ARGV.shift if ARGV.first == '--'
+
+STDOUT.write_proc = ->(string) { `process.stdout.write(string)` }
+STDERR.write_proc = ->(string) { `process.stderr.write(string)` }
+
+`var __fs__ = require('fs')`
+STDIN.read_proc = %x{function(_count) {
+  // Ignore count, return as much as we can get
+  var buf = Buffer.alloc(65536), count;
+  try {
+    count = __fs__.readSync(this.fd, buf, 0, 65536, null);
+  }
+  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/nodejs/dir.rb

@@ -44,7 +44,7 @@ class Dir
       pattern = [pattern] unless pattern.respond_to? :each
       pattern.flat_map do |subpattern|
         subpattern = subpattern.to_path if subpattern.respond_to? :to_path
-        subpattern = Opal.coerce_to!(subpattern, String, :to_str)
+        subpattern = ::Opal.coerce_to!(subpattern, String, :to_str)
         `__glob__.sync(subpattern)`
       end
     end

data/stdlib/nodejs/env.rb

@@ -13,11 +13,6 @@ class << ENV
     `process.env.hasOwnProperty(#{name})`
   end
 
-  # alias
-  alias has_key? key?
-  alias include? key?
-  alias member? key?
-
   def empty?
     `Object.keys(process.env).length === 0`
   end
@@ -45,15 +40,17 @@ class << ENV
     'ENV'
   end
 
-  alias inspect to_s
-
   def to_h
     keys.to_h { |k| [k, self[k]] }
   end
 
-  alias to_hash to_h
-
   def merge(keys)
     to_h.merge(keys)
   end
+
+  alias has_key? key?
+  alias include? key?
+  alias inspect to_s
+  alias member? key?
+  alias to_hash to_h
 end

data/stdlib/nodejs/file.rb

@@ -1,13 +1,7 @@
 require 'corelib/file'
 
 %x{
-  var warnings = {}, errno_code, errno_codes = [
-    'EACCES',
-    'EISDIR',
-    'EMFILE',
-    'ENOENT',
-    'EPERM'
-  ];
+  var warnings = {}, errno_codes = #{Errno.constants};
 
   function handle_unsupported_feature(message) {
     switch (Opal.config.unsupported_features_severity) {
@@ -107,16 +101,9 @@ require 'corelib/file'
     } catch (error) {
       if (errno_codes.indexOf(error.code) >= 0) {
         var error_class = #{Errno.const_get(`error.code`)}
-        throw #{`error_class`.new(`error.message`)};
+        #{Kernel.raise `error_class`.new(`error.message`)}
       }
-      throw error;
-    }
-  }
-
-  for(var i = 0, ii = errno_codes.length; i < ii; i++) {
-    errno_code = errno_codes[i];
-    if (!#{Errno.const_defined?(`errno_code`)}) {
-      #{Errno.const_set(`errno_code`, Class.new(SystemCallError))}
+      #{Kernel.raise error}
     }
   }
 }
@@ -176,7 +163,10 @@ class File < IO
   end
 
   def self.join(*paths)
-    `__path__.posix.join.apply(__path__, #{paths})`
+    # by itself, `path.posix.join` normalizes leading // to /.
+    # restore the leading / on UNC paths (i.e., paths starting with //).
+    prefix = paths.first&.start_with?('//') ? '/' : ''
+    `#{prefix} + __path__.posix.join.apply(__path__, #{paths})`
   end
 
   def self.directory?(path)
@@ -326,7 +316,23 @@ class File::Stat
     `return executeIOAction(function(){return __fs__.statSync(#{@path}).isFile()})`
   end
 
+  def directory?
+    `return executeIOAction(function(){return __fs__.statSync(#{@path}).isDirectory()})`
+  end
+
   def mtime
     `return executeIOAction(function(){return __fs__.statSync(#{@path}).mtime})`
   end
+
+  def readable?
+    `return executeIOAction(function(){return __fs__.accessSync(#{@path}, __fs__.constants.R_OK)})`
+  end
+
+  def writable?
+    `return executeIOAction(function(){return __fs__.accessSync(#{@path}, __fs__.constants.W_OK)})`
+  end
+
+  def executable?
+    `return executeIOAction(function(){return __fs__.accessSync(#{@path}, __fs__.constants.X_OK)})`
+  end
 end

data/stdlib/nodejs/fileutils.rb

@@ -23,11 +23,11 @@ module FileUtils
     `__fs__.mkdirSync(#{path})`
   end
 
-  alias mkpath mkdir_p
-  alias makedirs mkdir_p
-
   def mv(source, target)
     target = File.join(target, File.basename(source)) if File.directory? target
     `__fs__.renameSync(source, target)`
   end
+
+  alias mkpath mkdir_p
+  alias makedirs mkdir_p
 end

data/stdlib/nodejs/io.rb

@@ -1,3 +1,5 @@
+require 'nodejs/file'
+
 %x{
   function executeIOAction(action) {
     try {
@@ -41,23 +43,3 @@ class IO
     `return executeIOAction(function(){return __fs__.readFileSync(#{path}).toString('binary')})`
   end
 end
-
-STDOUT.write_proc = ->(string) { `process.stdout.write(string)` }
-STDERR.write_proc = ->(string) { `process.stderr.write(string)` }
-
-STDIN.read_proc = %x{function(_count) {
-  // Ignore count, return as much as we can get
-  var buf = Buffer.alloc(65536), count;
-  try {
-    count = __fs__.readSync(this.fd, buf, 0, 65536, null);
-  }
-  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/nodejs/kernel.rb

@@ -1,19 +1,10 @@
-require 'native'
-
-`Opal.exit = process.exit`
+require 'buffer'
+require 'corelib/process/status'
 
 module Kernel
-  NODE_REQUIRE = `require`
-
   @__child_process__ = `require('child_process')`
   `var __child_process__ = #{@__child_process__}`
 
-  # @deprecated Please use `require('module')` instead
-  def node_require(path)
-    warn '[DEPRECATION] node_require is deprecated. Please use `require(\'module\')` instead.'
-    `#{NODE_REQUIRE}(#{path.to_str})`
-  end
-
   def system(*argv, exception: false)
     env = {}
     env = argv.shift if argv.first.is_a? Hash
@@ -41,29 +32,3 @@ module Kernel
     Buffer.new(`__child_process__.execSync(#{cmdline})`).to_s.encode('UTF-8')
   end
 end
-
-module Process
-  class Status
-    def initialize(status, pid)
-      @status, @pid = status, pid
-    end
-
-    def exitstatus
-      @status
-    end
-
-    attr_reader :pid
-
-    def success?
-      @status == 0
-    end
-
-    def inspect
-      "#<Process::Status: pid #{@pid} exit #{@status}>"
-    end
-  end
-end
-
-ARGV = `process.argv.slice(2)`
-
-ARGV.shift if ARGV.first == '--'

data/stdlib/nodejs.rb

@@ -1,6 +1,4 @@
-module NodeJS
-end
-
+require 'nodejs/base'
 require 'nodejs/kernel'
 require 'nodejs/file'
 require 'nodejs/dir'

data/stdlib/opal/miniracer.rb

@@ -1,3 +1,5 @@
+`/* global opalminiracer */`
+
 # Compatibility utilities for the API we provide in
 # lib/opal/cli_runners/mini_racer
 

data/stdlib/opal/platform.rb

@@ -1,17 +1,10 @@
 require 'opal-platform'
 
 case OPAL_PLATFORM
-when 'nashorn'
-  require 'nashorn'
-when 'gjs'
-  require 'gjs'
-when 'quickjs'
-  require 'quickjs'
-when 'nodejs'
-  require 'nodejs/kernel'
-  require 'nodejs/io'
-when 'headless-chrome'
-  require 'headless_chrome'
-when 'opal-miniracer'
-  require 'opal/miniracer'
+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'
 end

data/stdlib/opal/replutils.rb

@@ -45,9 +45,19 @@ module REPLUtils
 
   def eval_and_print(func, mode, colorize)
     printer = if colorize
-                ->(i) { ColorPrinter.default(i) }
+                ->(i) do
+                  ColorPrinter.default(i)
+                rescue => e
+                  ColorPrinter.colorize(Opal.inspect(i))
+                end
               else
-                ->(i) { out = []; PP.pp(i, out); out.join }
+                ->(i) do
+                  out = []
+                  PP.pp(i, out)
+                  out.join
+                rescue
+                  Opal.inspect(i)
+                end
               end
 
     %x{
@@ -231,9 +241,10 @@ module REPLUtils
       TOKEN_COLORS.dig(*name) + string + "\e[0m"
     end
 
-    NUMBER = '[+-]?[0-9.]+(?:e[+-][0-9]+|i)?'
+    NUMBER = '[+-]?(?:0x[0-9a-fA-F]+|[0-9.]+(?:e[+-][0-9]+|i)?)'
     REGEXP = '/.*?/[iesu]*'
-    TOKEN_REGEXP = /(\s+|=>|[@$:]?[a-z]\w+|[A-Z]\w+|#{NUMBER}|#{REGEXP}|".*?"|#<.*?[> ]|.)/
+    STRING = '".*?"'
+    TOKEN_REGEXP = /(\s+|=>|[@$:]?[a-z]\w+|[A-Z]\w+|#{NUMBER}|#{REGEXP}|#{STRING}|#<.*?[> ]|.)/
 
     def self.tokenize(str)
       str.scan(TOKEN_REGEXP).map(&:first)
@@ -256,7 +267,7 @@ module REPLUtils
           token(tok, :symbol, :self)
         when /^[A-Z]/
           token(tok, :constant)
-        when /^#</, '=', '>'
+        when '<', '#', /^#</, '=', '>'
           token(tok, :keyword)
         when /^\/./
           token(tok, :regexp, :self)

data/stdlib/opal-parser.rb

@@ -7,7 +7,7 @@ require 'opal/version'
 
 module Kernel
   def eval(str, binding = nil, file = nil, line = nil)
-    str = Opal.coerce_to!(str, String, :to_str)
+    str = ::Opal.coerce_to!(str, String, :to_str)
     default_eval_options = { file: file || '(eval)', eval: true }
     compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
     code = `Opal.compile(str, compiling_options)`
@@ -35,7 +35,7 @@ end
 %x{
   Opal.compile = function(str, options) {
     try {
-      str = #{Opal.coerce_to!(`str`, String, :to_str)}
+      str = #{::Opal.coerce_to!(`str`, String, :to_str)}
       if (options) options = Opal.hash(options);
       return Opal.Opal.$compile(str, options);
     }

data/stdlib/optparse/ac.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: false
+require 'optparse'
+
+class OptionParser::AC < OptionParser
+  private
+
+  def _check_ac_args(name, block)
+    unless /\A\w[-\w]*\z/ =~ name
+      raise ArgumentError, name
+    end
+    unless block
+      raise ArgumentError, 'no block given', ParseError.filter_backtrace(caller)
+    end
+  end
+
+  ARG_CONV = proc { |val| val.nil? ? true : val }
+
+  def _ac_arg_enable(prefix, name, help_string, block)
+    _check_ac_args(name, block)
+
+    sdesc = []
+    ldesc = ["--#{prefix}-#{name}"]
+    desc = [help_string]
+    q = name.downcase
+    ac_block = proc { |val| block.call(ARG_CONV.call(val)) }
+    enable = Switch::PlacedArgument.new(nil, ARG_CONV, sdesc, ldesc, nil, desc, ac_block)
+    disable = Switch::NoArgument.new(nil, proc { false }, sdesc, ldesc, nil, desc, ac_block)
+    top.append(enable, [], ['enable-' + q], disable, ['disable-' + q])
+    enable
+  end
+
+  public
+
+  def ac_arg_enable(name, help_string, &block)
+    _ac_arg_enable('enable', name, help_string, block)
+  end
+
+  def ac_arg_disable(name, help_string, &block)
+    _ac_arg_enable('disable', name, help_string, block)
+  end
+
+  def ac_arg_with(name, help_string, &block)
+    _check_ac_args(name, block)
+
+    sdesc = []
+    ldesc = ["--with-#{name}"]
+    desc = [help_string]
+    q = name.downcase
+    with = Switch::PlacedArgument.new(*search(:atype, String), sdesc, ldesc, nil, desc, block)
+    without = Switch::NoArgument.new(nil, proc {}, sdesc, ldesc, nil, desc, block)
+    top.append(with, [], ['with-' + q], without, ['without-' + q])
+    with
+  end
+end

data/stdlib/optparse/date.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+require 'optparse'
+require 'date'
+
+OptionParser.accept(DateTime) do |s,|
+  DateTime.parse(s) if s
+rescue ArgumentError
+  raise OptionParser::InvalidArgument, s
+end
+OptionParser.accept(Date) do |s,|
+  Date.parse(s) if s
+rescue ArgumentError
+  raise OptionParser::InvalidArgument, s
+end

data/stdlib/optparse/kwargs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'optparse'
+
+class OptionParser
+  # :call-seq:
+  #   define_by_keywords(options, method, **params)
+  #
+  # :include: ../../doc/optparse/creates_option.rdoc
+  #
+  def define_by_keywords(options, meth, **opts)
+    meth.parameters.each do |type, name|
+      case type
+      when :key, :keyreq
+        op, cl = *(type == :key ? %w"[ ]" : ['', ''])
+        define("--#{name}=#{op}#{name.upcase}#{cl}", *opts[name]) do |o|
+          options[name] = o
+        end
+      end
+    end
+    options
+  end
+end

data/stdlib/optparse/shellwords.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: false
+# -*- ruby -*-
+
+require 'shellwords'
+require 'optparse'
+
+OptionParser.accept(Shellwords) { |s,| Shellwords.shellwords(s) }

data/stdlib/optparse/time.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: false
+require 'optparse'
+require 'time'
+
+OptionParser.accept(Time) do |s,|
+  if s
+    (begin
+       Time.httpdate(s)
+     rescue
+       Time.parse(s)
+     end)
+  end
+rescue
+  raise OptionParser::InvalidArgument, s
+end

data/stdlib/optparse/uri.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: false
+# -*- ruby -*-
+
+require 'optparse'
+require 'uri'
+
+OptionParser.accept(URI) { |s,| URI.parse(s) if s }

data/stdlib/optparse/version.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: false
+# OptionParser internal utility
+
+class << OptionParser
+  def show_version(*pkgs)
+    progname = ARGV.options.program_name
+    result = false
+    show = proc do |klass, cname, version|
+      str = progname.to_s
+      unless (klass == ::Object) && (cname == :VERSION)
+        version = version.join('.') if Array === version
+        str << ": #{klass}" unless klass == Object
+        str << " version #{version}"
+      end
+      %i[Release RELEASE].find do |rel|
+        if klass.const_defined?(rel)
+          str << " (#{klass.const_get(rel)})"
+        end
+      end
+      puts str
+      result = true
+    end
+    if (pkgs.size == 1) && (pkgs[0] == 'all')
+      search_const(::Object, /\AV(?:ERSION|ersion)\z/) do |klass, cname, version|
+        unless (cname[1] == 'e') && klass.const_defined?(:Version)
+          show.call(klass, cname.intern, version)
+        end
+      end
+    else
+      pkgs.each do |pkg|
+        pkg = pkg.split(/::|\//).inject(::Object) { |m, c| m.const_get(c) }
+        v = case
+            when pkg.const_defined?(:Version)
+              pkg.const_get(n = :Version)
+            when pkg.const_defined?(:VERSION)
+              pkg.const_get(n = :VERSION)
+            else
+              n = nil
+              'unknown'
+            end
+        show.call(pkg, n, v)
+      rescue NameError
+      end
+    end
+    result
+  end
+
+  def each_const(path, base = ::Object)
+    path.split(/::|\//).inject(base) do |klass, name|
+      raise NameError, path unless Module === klass
+      klass.constants.grep(/#{name}/i) do |c|
+        klass.const_defined?(c) || next
+        klass.const_get(c)
+      end
+    end
+  end
+
+  def search_const(klass, name)
+    klasses = [klass]
+    while klass = klasses.shift
+      klass.constants.each do |cname|
+        klass.const_defined?(cname) || next
+        const = klass.const_get(cname)
+        yield klass, cname, const if name === cname
+        klasses << const if (Module === const) && (const != ::Object)
+      end
+    end
+  end
+end