opal 1.3.1 → 1.4.1

data/stdlib/pathname.rb

@@ -165,12 +165,6 @@ class Pathname
     path <=> other.path
   end
 
-  alias eql? ==
-  alias === ==
-
-  alias to_str to_path
-  alias to_s to_path
-
   SAME_PATHS = if File::FNM_SYSCASE.nonzero?
                  # Avoid #zero? here because #casecmp can return nil.
                  proc { |a, b| a.casecmp(b) == 0 }
@@ -217,6 +211,11 @@ class Pathname
   def entries
     Dir.entries(@path).map { |f| self.class.new(f) }
   end
+
+  alias === ==
+  alias eql? ==
+  alias to_s to_path
+  alias to_str to_path
 end
 
 module Kernel

data/stdlib/pp.rb

@@ -151,7 +151,23 @@ class PP < PrettyPrint
     #
     # Object#pretty_print_cycle is used when +obj+ is already
     # printed, a.k.a the object reference chain has a cycle.
-    def pp(obj)
+    def pp(obj = undefined)
+      # Opal: consider JS-native variables:
+      %x{
+        if (obj === null) {
+          #{text "null"}
+          #{return}
+        }
+        else if (obj === undefined) {
+          #{text "undefined"}
+          #{return}
+        }
+        else if (obj.$$class === undefined) {
+          #{text `Object.prototype.toString.apply(obj)`}
+          #{return}
+        }
+      }
+
       # If obj is a Delegator then use the object being delegated to for cycle
       # detection
       obj = obj.__getobj__ if defined?(::Delegator) and obj.is_a?(::Delegator)
@@ -180,7 +196,7 @@ class PP < PrettyPrint
     # object_id.
     def object_address_group(obj, &block)
       str = Kernel.instance_method(:to_s).bind_call(obj)
-      str.chomp!('>')
+      str = str.chomp('>')
       group(1, str, '>', &block)
     end
 

data/stdlib/promise/v2.rb

@@ -98,13 +98,6 @@
 #     end
 #
 
-if `Opal.config.experimental_features_severity == 'warning'`
-  warn 'PromiseV2 is a technology preview, which means it may change its behavior ' \
-      'in the future until this warning is removed. If you are interested in this part, ' \
-      'please make sure you track the async/await/promises tag on Opal issues: ' \
-      'https://github.com/opal/opal/issues?q=label%3Aasync%2Fawait%2Fpromises'
-end
-
 class PromiseV2 < `Promise`
   class << self
     def allocate
@@ -124,8 +117,6 @@ class PromiseV2 < `Promise`
       end
     end
 
-    alias all when
-
     def all_resolved(*promises)
       promises = Array(promises.length == 1 ? promises.first : promises)
       `Promise.allResolved(#{promises})`.tap do |prom|
@@ -154,7 +145,6 @@ class PromiseV2 < `Promise`
         prom.instance_variable_set(:@value, value)
       end
     end
-    alias value resolve
 
     def reject(value = nil)
       `Promise.reject(#{value})`.tap do |prom|
@@ -163,7 +153,10 @@ class PromiseV2 < `Promise`
         prom.instance_variable_set(:@value, value)
       end
     end
+
+    alias all when
     alias error reject
+    alias value resolve
   end
 
   attr_reader :prev, :next
@@ -209,7 +202,6 @@ class PromiseV2 < `Promise`
     @resolve_proc.call(value)
     self
   end
-  alias resolve! resolve
 
   def reject(value = nil)
     nativity_check!
@@ -219,7 +211,6 @@ class PromiseV2 < `Promise`
     @reject_proc.call(value)
     self
   end
-  alias reject! reject
 
   def then(&block)
     prom = nil
@@ -239,9 +230,6 @@ class PromiseV2 < `Promise`
     self.then(&block)
   end
 
-  alias do then
-  alias do! then!
-
   def fail(&block)
     prom = nil
     blk = gen_tracing_proc(block) do |val|
@@ -260,11 +248,6 @@ class PromiseV2 < `Promise`
     fail(&block)
   end
 
-  alias rescue fail
-  alias catch fail
-  alias rescue! fail!
-  alias catch! fail!
-
   def always(&block)
     prom = nil
     blk = gen_tracing_proc(block) do |val|
@@ -283,11 +266,6 @@ class PromiseV2 < `Promise`
     always(&block)
   end
 
-  alias finally always
-  alias ensure always
-  alias finally! always!
-  alias ensure! always!
-
   def trace(depth = nil, &block)
     prom = self.then do
       values = []
@@ -362,8 +340,6 @@ class PromiseV2 < `Promise`
     yield self if block_given?
   end
 
-  alias to_v2 itself
-
   def to_v1
     v1 = PromiseV1.new
 
@@ -372,8 +348,6 @@ class PromiseV2 < `Promise`
     v1
   end
 
-  alias to_n itself
-
   def inspect
     result = "#<#{self.class}"
 
@@ -395,4 +369,19 @@ class PromiseV2 < `Promise`
 
     result
   end
+
+  alias catch fail
+  alias catch! fail!
+  alias do then
+  alias do! then!
+  alias ensure always
+  alias ensure! always!
+  alias finally always
+  alias finally! always!
+  alias reject! reject
+  alias rescue fail
+  alias rescue! fail!
+  alias resolve! resolve
+  alias to_n itself
+  alias to_v2 itself
 end

data/stdlib/promise.rb

@@ -275,9 +275,6 @@ class Promise
     self.then(&block)
   end
 
-  alias do then
-  alias do! then!
-
   def fail(&block)
     self ^ Promise.new(failure: block)
   end
@@ -287,11 +284,6 @@ class Promise
     fail(&block)
   end
 
-  alias rescue fail
-  alias catch fail
-  alias rescue! fail!
-  alias catch! fail!
-
   def always(&block)
     self ^ Promise.new(always: block)
   end
@@ -301,11 +293,6 @@ class Promise
     always(&block)
   end
 
-  alias finally always
-  alias ensure always
-  alias finally! always!
-  alias ensure! always!
-
   def trace(depth = nil, &block)
     self ^ Trace.new(depth, block)
   end
@@ -337,8 +324,6 @@ class Promise
     result
   end
 
-  alias to_v1 itself
-
   def to_v2
     v2 = PromiseV2.new
 
@@ -347,7 +332,18 @@ class Promise
     v2
   end
 
+  alias catch fail
+  alias catch! fail!
+  alias do then
+  alias do! then!
+  alias ensure always
+  alias ensure! always!
+  alias finally always
+  alias finally! always!
+  alias rescue fail
+  alias rescue! fail!
   alias to_n to_v2
+  alias to_v1 itself
 
   class Trace < self
     def self.it(promise)
@@ -414,10 +410,6 @@ class Promise
       end
     end
 
-    alias map collect
-
-    alias reduce inject
-
     def wait(promise)
       unless Promise === promise
         promise = Promise.value(promise)
@@ -436,8 +428,6 @@ class Promise
       self
     end
 
-    alias and wait
-
     def >>(*)
       super.tap do
         try
@@ -454,6 +444,10 @@ class Promise
         end
       end
     end
+
+    alias map collect
+    alias reduce inject
+    alias and wait
   end
 end
 

data/stdlib/quickjs/io.rb

@@ -1,5 +1,3 @@
-`/* global std */`
-
 %x{
   Opal.gvars.stdout.write_proc = function(s) {
     std.out.printf("%s", s);

data/stdlib/quickjs/kernel.rb

@@ -1,5 +1,3 @@
-`/* global std, scriptArgs */`
-
 ARGV = `scriptArgs`
 
 `Opal.exit = std.exit`

data/stdlib/quickjs.rb

@@ -1,2 +1,4 @@
+`/* global std, scriptArgs */`
+
 require 'quickjs/io'
 require 'quickjs/kernel'

data/stdlib/set.rb

@@ -1,6 +1,6 @@
 # Portions Copyright (c) 2002-2013 Akinori MUSHA <knu@iDaemons.org>
-class Set
-  include Enumerable
+class ::Set
+  include ::Enumerable
 
   def self.[](*ary)
     new(ary)
@@ -10,7 +10,7 @@ class Set
     @hash = {}
 
     return if enum.nil?
-    raise ArgumentError, 'value must be enumerable' unless Enumerable === enum
+    ::Kernel.raise ::ArgumentError, 'value must be enumerable' unless ::Enumerable === enum
 
     if block
       enum.each { |item| add yield(item) }
@@ -26,12 +26,11 @@ class Set
 
   def -(enum)
     unless enum.respond_to? :each
-      raise ArgumentError, 'value must be enumerable'
+      ::Kernel.raise ::ArgumentError, 'value must be enumerable'
     end
 
     dup.subtract(enum)
   end
-  alias difference -
 
   def inspect
     "#<Set: {#{to_a.join(',')}}>"
@@ -42,7 +41,7 @@ class Set
       true
     elsif other.instance_of?(self.class)
       @hash == other.instance_variable_get(:@hash)
-    elsif other.is_a?(Set) && size == other.size
+    elsif other.is_a?(::Set) && size == other.size
       other.all? { |o| @hash.include?(o) }
     else
       false
@@ -53,12 +52,11 @@ class Set
     @hash[o] = true
     self
   end
-  alias << add
 
   def classify(&block)
     return enum_for(:classify) unless block_given?
 
-    result = Hash.new { |h, k| h[k] = self.class.new }
+    result = ::Hash.new { |h, k| h[k] = self.class.new }
 
     each { |item| result[yield(item)].add item }
 
@@ -71,7 +69,6 @@ class Set
     each { |item| result << yield(item) }
     replace result
   end
-  alias map! collect!
 
   def delete(o)
     @hash.delete(o)
@@ -113,8 +110,6 @@ class Set
     size == before ? nil : self
   end
 
-  alias filter! select!
-
   def add?(o)
     if include?(o)
       nil
@@ -145,7 +140,6 @@ class Set
   def include?(o)
     @hash.include?(o)
   end
-  alias member? include?
 
   def merge(enum)
     enum.each { |item| add item }
@@ -162,7 +156,6 @@ class Set
   def size
     @hash.size
   end
-  alias length size
 
   def subtract(enum)
     enum.each { |item| delete item }
@@ -171,46 +164,43 @@ class Set
 
   def |(enum)
     unless enum.respond_to? :each
-      raise ArgumentError, 'value must be enumerable'
+      ::Kernel.raise ::ArgumentError, 'value must be enumerable'
     end
     dup.merge(enum)
   end
 
+  %x{
+    function is_set(set) {
+      #{`set`.is_a?(::Set) || ::Kernel.raise(::ArgumentError, 'value must be a set')}
+    }
+  }
+
   def superset?(set)
-    set.is_a?(Set) || raise(ArgumentError, 'value must be a set')
+    `is_set(set)`
     return false if size < set.size
     set.all? { |o| include?(o) }
   end
 
-  alias >= superset?
-
   def proper_superset?(set)
-    set.is_a?(Set) || raise(ArgumentError, 'value must be a set')
+    `is_set(set)`
     return false if size <= set.size
     set.all? { |o| include?(o) }
   end
 
-  alias > proper_superset?
-
   def subset?(set)
-    set.is_a?(Set) || raise(ArgumentError, 'value must be a set')
+    `is_set(set)`
     return false if set.size < size
     all? { |o| set.include?(o) }
   end
 
-  alias <= subset?
-
   def proper_subset?(set)
-    set.is_a?(Set) || raise(ArgumentError, 'value must be a set')
+    `is_set(set)`
     return false if set.size <= size
     all? { |o| set.include?(o) }
   end
 
-  alias < proper_subset?
-
   def intersect?(set)
-    raise ArgumentError, 'value must be a set' unless set.is_a?(Set)
-
+    `is_set(set)`
     if size < set.size
       any? { |o| set.include?(o) }
     else
@@ -222,15 +212,25 @@ class Set
     !intersect?(set)
   end
 
-  alias + |
-  alias union |
-
   def to_a
     @hash.keys
   end
+
+  alias + |
+  alias < proper_subset?
+  alias << add
+  alias <= subset?
+  alias > proper_superset?
+  alias >= superset?
+  alias difference -
+  alias filter! select!
+  alias length size
+  alias map! collect!
+  alias member? include?
+  alias union |
 end
 
-module Enumerable
+module ::Enumerable
   def to_set(klass = Set, *args, &block)
     klass.new(self, *args, &block)
   end

data/stdlib/shellwords.rb

@@ -0,0 +1,240 @@
+# frozen-string-literal: true
+##
+# == Manipulates strings like the UNIX Bourne shell
+#
+# This module manipulates strings according to the word parsing rules
+# of the UNIX Bourne shell.
+#
+# The shellwords() function was originally a port of shellwords.pl,
+# but modified to conform to the Shell & Utilities volume of the IEEE
+# Std 1003.1-2008, 2016 Edition [1].
+#
+# === Usage
+#
+# You can use Shellwords to parse a string into a Bourne shell friendly Array.
+#
+#   require 'shellwords'
+#
+#   argv = Shellwords.split('three blind "mice"')
+#   argv #=> ["three", "blind", "mice"]
+#
+# Once you've required Shellwords, you can use the #split alias
+# String#shellsplit.
+#
+#   argv = "see how they run".shellsplit
+#   argv #=> ["see", "how", "they", "run"]
+#
+# They treat quotes as special characters, so an unmatched quote will
+# cause an ArgumentError.
+#
+#   argv = "they all ran after the farmer's wife".shellsplit
+#        #=> ArgumentError: Unmatched quote: ...
+#
+# Shellwords also provides methods that do the opposite.
+# Shellwords.escape, or its alias, String#shellescape, escapes
+# shell metacharacters in a string for use in a command line.
+#
+#   filename = "special's.txt"
+#
+#   system("cat -- #{filename.shellescape}")
+#   # runs "cat -- special\\'s.txt"
+#
+# Note the '--'.  Without it, cat(1) will treat the following argument
+# as a command line option if it starts with '-'.  It is guaranteed
+# that Shellwords.escape converts a string to a form that a Bourne
+# shell will parse back to the original string, but it is the
+# programmer's responsibility to make sure that passing an arbitrary
+# argument to a command does no harm.
+#
+# Shellwords also comes with a core extension for Array, Array#shelljoin.
+#
+#   dir = "Funny GIFs"
+#   argv = %W[ls -lta -- #{dir}]
+#   system(argv.shelljoin + " | less")
+#   # runs "ls -lta -- Funny\\ GIFs | less"
+#
+# You can use this method to build a complete command line out of an
+# array of arguments.
+#
+# === Authors
+# * Wakou Aoyama
+# * Akinori MUSHA <knu@iDaemons.org>
+#
+# === Contact
+# * Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+#
+# === Resources
+#
+# 1: {IEEE Std 1003.1-2008, 2016 Edition, the Shell & Utilities volume}[http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.html]
+
+module Shellwords
+  # Splits a string into an array of tokens in the same way the UNIX
+  # Bourne shell does.
+  #
+  #   argv = Shellwords.split('here are "two words"')
+  #   argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell
+  # metacharacters except for the single and double quotes and
+  # backslash are not treated as such.
+  #
+  #   argv = Shellwords.split('ruby my_prog.rb | less')
+  #   argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #   argv = 'here are "two words"'.shellsplit
+  #   argv #=> ["here", "are", "two words"]
+  def shellsplit(line)
+    line += ' ' # Somehow this is needed for the JS regexp engine
+    words = []
+    field = String.new
+    line.scan(/\s*(?:([^\s\\\'\"]+)|'([^\']*)'|"((?:[^\"\\]|\\.)*)"|(\\.?)|(\S))(\r?\n?\Z|\s)?/m) do |(word, sq, dq, esc, garbage, sep)|
+      raise ArgumentError, "Unmatched quote: #{line.inspect}" if garbage
+      # 2.2.3 Double-Quotes:
+      #
+      #   The <backslash> shall retain its special meaning as an
+      #   escape character only when followed by one of the following
+      #   characters when considered special:
+      #
+      #   $ ` " \ <newline>
+      field += (word || sq || (dq && dq.gsub(/\\([$`"\\\n])/, '\\1')) || esc.gsub(/\\(.)/, '\\1'))
+      if sep
+        words << field
+        field = String.new
+      end
+    end
+    words
+  end
+
+  alias shellwords shellsplit
+
+  module_function :shellsplit, :shellwords
+
+  class << self
+    alias split shellsplit
+  end
+
+  # Escapes a string so that it can be safely used in a Bourne shell
+  # command line.  +str+ can be a non-string object that responds to
+  # +to_s+.
+  #
+  # Note that a resulted string should be used unquoted and is not
+  # intended for use in double quotes nor in single quotes.
+  #
+  #   argv = Shellwords.escape("It's better to give than to receive")
+  #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #   argv = "It's better to give than to receive".shellescape
+  #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #   # Search files in lib for method definitions
+  #   pattern = "^[ \t]*def "
+  #   open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #     grep.each_line { |line|
+  #       file, lineno, matched_line = line.split(':', 3)
+  #       # ...
+  #     }
+  #   }
+  #
+  # It is the caller's responsibility to encode the string in the right
+  # encoding for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if +str+ has a length of zero.
+  def shellescape(str)
+    str = str.to_s
+
+    # An empty argument will be skipped, so return empty quotes.
+    return "''".dup if str.empty?
+
+    str = str.dup
+
+    # Treat multibyte characters as is.  It is the caller's responsibility
+    # to encode the string in the right encoding for the shell
+    # environment.
+    str = str.gsub(/[^A-Za-z0-9_\-.,:+\/@\n]/, '\\\\\\&')
+
+    # A LF cannot be escaped with a backslash because a backslash + LF
+    # combo is regarded as a line continuation and simply ignored.
+    str = str.gsub(/\n/, "'\n'")
+
+    str
+  end
+
+  module_function :shellescape
+
+  class << self
+    alias escape shellescape
+  end
+
+  # Builds a command line string from an argument list, +array+.
+  #
+  # All elements are joined into a single string with fields separated by a
+  # space, where each element is escaped for the Bourne shell and stringified
+  # using +to_s+.
+  #
+  #   ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #   argv = Shellwords.join(ary)
+  #   argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #   ary = ["Don't", "rock", "the", "boat"]
+  #   argv = ary.shelljoin
+  #   argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #   output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def shelljoin(array)
+    array.map { |arg| shellescape(arg) }.join(' ')
+  end
+
+  module_function :shelljoin
+
+  class << self
+    alias join shelljoin
+  end
+end
+
+class String
+  # call-seq:
+  #   str.shellsplit => array
+  #
+  # Splits +str+ into an array of tokens in the same way the UNIX
+  # Bourne shell does.
+  #
+  # See Shellwords.shellsplit for details.
+  def shellsplit
+    Shellwords.split(self)
+  end
+
+  # call-seq:
+  #   str.shellescape => string
+  #
+  # Escapes +str+ so that it can be safely used in a Bourne shell
+  # command line.
+  #
+  # See Shellwords.shellescape for details.
+  def shellescape
+    Shellwords.escape(self)
+  end
+end
+
+class Array
+  # call-seq:
+  #   array.shelljoin => string
+  #
+  # Builds a command line string from an argument list +array+ joining
+  # all elements escaped for the Bourne shell and separated by a space.
+  #
+  # See Shellwords.shelljoin for details.
+  def shelljoin
+    Shellwords.join(self)
+  end
+end