opal 0.10.6 → 0.11.0.rc1

data/opal/corelib/basic_object.rb

@@ -48,13 +48,13 @@ class BasicObject
 
   def instance_eval(*args, &block)
     if block.nil? && `!!Opal.compile`
-      Kernel.raise ArgumentError, "wrong number of arguments (0 for 1..3)" unless (1..3).cover? args.size
+      ::Kernel.raise ::ArgumentError, "wrong number of arguments (0 for 1..3)" unless (1..3).cover? args.size
 
       string, file, _lineno = *args
       default_eval_options = { file: (file || '(eval)'), eval: true }
       compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
-      compiled = Opal.compile string, compiling_options
-      block = Kernel.proc do
+      compiled = ::Opal.compile string, compiling_options
+      block = ::Kernel.proc do
         %x{
           return (function(self) {
             return eval(compiled);
@@ -62,7 +62,7 @@ class BasicObject
         }
       end
     elsif args.size > 0
-      Kernel.raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
+      ::Kernel.raise ::ArgumentError, "wrong number of arguments (#{args.size} for 0)"
     end
 
     %x{
@@ -94,7 +94,7 @@ class BasicObject
   end
 
   def instance_exec(*args, &block)
-    Kernel.raise ArgumentError, "no block given" unless block
+    ::Kernel.raise ::ArgumentError, "no block given" unless block
 
     %x{
       var block_self = block.$$s,
@@ -131,7 +131,7 @@ class BasicObject
   end
 
   def method_missing(symbol, *args, &block)
-    Kernel.raise NoMethodError.new(`self.$inspect && !self.$inspect.$$stub` ?
+    ::Kernel.raise ::NoMethodError.new(`self.$inspect && !self.$inspect.$$stub` ?
       "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}" :
       "undefined method `#{symbol}' for #{`self.$$class`}", symbol)
   end

data/opal/corelib/class.rb

@@ -7,15 +7,12 @@ class Class
         throw Opal.TypeError.$new("superclass must be a Class");
       }
 
-      var alloc = Opal.boot_class_alloc(null, function(){}, superclass)
+      var alloc = Opal.boot_class_alloc(null, function(){}, superclass);
       var klass = Opal.setup_class_object(null, alloc, superclass.$$name, superclass.constructor);
 
-      klass.$$super = superclass;
+      klass.$$super  = superclass;
       klass.$$parent = superclass;
 
-      // inherit scope from parent
-      Opal.create_scope(superclass.$$scope, klass);
-
       superclass.$inherited(klass);
       Opal.module_initialize(klass, block);
 
@@ -34,13 +31,19 @@ class Class
   def inherited(cls)
   end
 
-  def new(*args, &block)
+  def initialize_dup(original)
+    initialize_copy(original)
     %x{
-      var obj = #{allocate};
+      self.$$name = null;
+      self.$$full_name = null;
+    }
+  end
 
-      obj.$initialize.$$p = block;
-      obj.$initialize.apply(obj, args);
-      return obj;
+  def new(*args, &block)
+    %x{
+      var object = #{allocate};
+      Opal.send(object, object.$initialize, args, block);
+      return object;
     }
   end
 
@@ -57,7 +60,7 @@ class Class
       }
       else if (singleton_of) {
         // a singleton class created from an object
-        return #{"#<Class:#<#{`singleton_of.$$class`.name}:0x#{`singleton_of.$$id`.to_s(16)}>>"};
+        return #{"#<Class:#<#{`singleton_of.$$class`.name}:0x#{`Opal.id(singleton_of)`.to_s(16)}>>"};
       }
       return #{super()};
     }

data/opal/corelib/complex.rb

@@ -190,6 +190,8 @@ class Complex < Numeric
 
   alias magnitude abs
 
+  undef negative?
+
   def numerator
     d = denominator
 
@@ -203,6 +205,8 @@ class Complex < Numeric
     [abs, arg]
   end
 
+  undef positive?
+
   alias quo /
 
   def rationalize(eps = undefined)
@@ -256,7 +260,7 @@ class Complex < Numeric
   def to_s
     result = @real.inspect
 
-    if (Number === @imag && @imag.nan?) || @imag.positive?
+    if (Number === @imag && @imag.nan?) || @imag.positive? || @imag.zero?
       result += ?+
     else
       result += ?-

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '2.2.10'
-RUBY_ENGINE_VERSION = '0.10.6'
-RUBY_RELEASE_DATE   = '2018-06-21'
+RUBY_VERSION        = '2.3.4'
+RUBY_ENGINE_VERSION = '0.11.0.rc1'
+RUBY_RELEASE_DATE   = '2017-05-01'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = 0
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2015 Adam Beynon'

data/opal/corelib/enumerable.rb

@@ -43,18 +43,12 @@ module Enumerable
     false
   end
 
-  def chunk(state = undefined, &original_block)
-    Kernel.raise ArgumentError, "no block given" unless original_block
+  def chunk(&block)
+    Kernel.raise ArgumentError, "no block given" unless block_given?
 
     ::Enumerator.new do |yielder|
       %x{
-        var block, previous = nil, accumulate = [];
-
-        if (state == undefined || state === nil) {
-          block = original_block;
-        } else {
-          block = #{Proc.new { |val| original_block.yield(val, state.dup)}}
-        }
+        var previous = nil, accumulate = [];
 
         function releaseAccumulate() {
           if (accumulate.length > 0) {
@@ -88,6 +82,12 @@ module Enumerable
     end
   end
 
+  def chunk_while(&block)
+    raise ArgumentError, "no block given" unless block_given?
+
+    slice_when { |before, after| !(yield before, after) }
+  end
+
   def collect(&block)
     return enum_for(:collect){self.enumerator_size} unless block_given?
 
@@ -539,6 +539,39 @@ module Enumerable
     }
   end
 
+  def grep_v(pattern, &block)
+    %x{
+      var result = [];
+
+      if (block !== nil) {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
+
+          if (#{Opal.falsy?(`value`)}) {
+            value = Opal.yield1(block, param);
+
+            result.push(value);
+          }
+        };
+      }
+      else {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
+
+          if (#{Opal.falsy?(`value`)}) {
+            result.push(param);
+          }
+        };
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
   def group_by(&block)
     return enum_for(:group_by){self.enumerator_size} unless block_given?
 
@@ -940,8 +973,12 @@ module Enumerable
   alias select find_all
 
   def slice_before(pattern = undefined, &block)
-    if `pattern === undefined && block === nil || arguments.length > 1`
-      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 1)"
+    if `pattern === undefined && block === nil`
+      raise ArgumentError, "both pattern and block are given"
+    end
+
+    if `pattern !== undefined && block !== nil || arguments.length > 1`
+      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} expected 1)"
     end
 
     Enumerator.new {|e|
@@ -999,6 +1036,87 @@ module Enumerable
     }
   end
 
+  def slice_after(pattern = undefined, &block)
+    if `pattern === undefined && block === nil`
+      raise ArgumentError, "both pattern and block are given"
+    end
+
+    if `pattern !== undefined && block !== nil || arguments.length > 1`
+      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} expected 1)"
+    end
+
+    if `pattern !== undefined`
+      block = proc { |e| pattern === e }
+    end
+
+    Enumerator.new do |yielder|
+      %x{
+        var accumulate;
+
+        self.$each.$$p = function() {
+          var element = #{Opal.destructure(`arguments`)},
+              end_chunk = Opal.yield1(block, element);
+
+          if (accumulate == null) {
+            accumulate = [];
+          }
+
+          if (#{Opal.truthy?(`end_chunk`)}) {
+            accumulate.push(element);
+            #{yielder.yield(`accumulate`)};
+            accumulate = null;
+          } else {
+            accumulate.push(element)
+          }
+        }
+
+        self.$each();
+
+        if (accumulate != null) {
+          #{yielder.yield(`accumulate`)};
+        }
+      }
+    end
+  end
+
+  def slice_when(&block)
+    raise ArgumentError, "wrong number of arguments (0 for 1)" unless block_given?
+
+    Enumerator.new do |yielder|
+      %x{
+        var slice = nil, last_after = nil;
+
+        self.$each_cons.$$p = function() {
+          var params = #{Opal.destructure(`arguments`)},
+              before = params[0],
+              after = params[1],
+              match = Opal.yieldX(block, [before, after]);
+
+          last_after = after;
+
+          if (slice === nil) {
+            slice = [];
+          }
+
+          if (#{Opal.truthy?(`match`)}) {
+            slice.push(before);
+            #{yielder.yield(`slice`)};
+            slice = [];
+          } else {
+            slice.push(before);
+          }
+        }
+
+        self.$each_cons(2);
+
+        if (slice !== nil) {
+          slice.push(last_after);
+          #{yielder.yield(`slice`)};
+        }
+      }
+    end
+  end
+
   def sort(&block)
     ary = to_a
     block = -> a,b {a <=> b} unless block_given?

data/opal/corelib/error.rb

@@ -1,19 +1,26 @@
 class Exception < `Error`
+  `var Kernel$raise = #{Kernel}.$raise`
   def self.new(*args)
     %x{
-      var message = (args.length > 0) ? args[0] : nil;
-      var err = new self.$$alloc(message);
-
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(err);
+      var message   = (args.length > 0) ? args[0] : nil;
+      var error     = new self.$$alloc(message);
+      error.name    = self.$$name;
+      error.message = message;
+      Opal.send(error, error.$initialize, args);
+
+      // Error.captureStackTrace() will use .name and .toString to build the
+      // first line of the stack trace so it must be called after the error
+      // has been initialized.
+      // https://nodejs.org/dist/latest-v6.x/docs/api/errors.html
+      if (Opal.config.enable_stack_trace && Error.captureStackTrace) {
+        // Passing Kernel.raise will cut the stack trace from that point above
+        Error.captureStackTrace(error, Kernel$raise);
       }
 
-      err.name = self.$$name;
-      err.$initialize.apply(err, args);
-      return err;
+      return error;
     }
   end
-  
+
   def self.exception(*args)
     new(*args)
   end
@@ -37,19 +44,19 @@ class Exception < `Error`
       return [];
     }
   end
-  
+
   def exception(str=nil)
     %x{
       if (str === nil || self === str) {
         return self;
       }
-      
+
       var cloned = #{self.clone};
       cloned.message = str;
       return cloned;
     }
   end
-  
+
   # not using alias message to_s because you need to be able to override to_s and have message use overridden method, won't work with alias
   def message
     to_s
@@ -59,7 +66,7 @@ class Exception < `Error`
     as_str = to_s
     as_str.empty? ? self.class.to_s : "#<#{self.class.to_s}: #{to_s}>"
   end
-  
+
   def to_s
     # using self.message aka @message to retain compatibility with native exception's message property
     (@message && @message.to_s) || self.class.to_s
@@ -96,8 +103,10 @@ class SystemCallError     < StandardError; end
 
 module Errno
   class EINVAL              < SystemCallError
-    def self.new
-      super('Invalid argument')
+    def self.new(name = nil)
+      message = "Invalid argument"
+      message += " - #{name}" if name
+      super(message)
     end
   end
 end
@@ -115,7 +124,7 @@ end
 
 class NameError
   attr_reader :name
-  
+
   def initialize(message, name=nil)
     super message
     @name = name
@@ -124,9 +133,18 @@ end
 
 class NoMethodError
   attr_reader :args
-  
+
   def initialize(message, name=nil, args=[])
     super message, name
     @args = args
   end
 end
+
+class StopIteration
+  attr_reader :result
+end
+
+module JS
+  class Error
+  end
+end

data/opal/corelib/file.rb

@@ -25,209 +25,75 @@ class File < IO
     alias realpath expand_path
 
     %x{
-      function chompdirsep(path) {
-        var last;
-
-        while (path.length > 0) {
-          if (isDirSep(path)) {
-            last = path;
-            path = path.substring(1, path.length);
-            while (path.length > 0 && isDirSep(path)) {
-              path = inc(path);
-            }
-            if (path.length == 0) {
-              return last;
-            }
-          }
-          else {
-            path = inc(path);
-          }
-        }
-        return path;
-      }
-
-      function inc(a) {
-        return a.substring(1, a.length);
-      }
-
-      function skipprefix(path) {
-        return path;
-      }
-
-      function lastSeparator(path) {
-        var tmp, last;
-
-        while (path.length > 0) {
-          if (isDirSep(path)) {
-            tmp = path;
-            path = inc(path);
-
-            while (path.length > 0 && isDirSep(path)) {
-              path = inc(path);
-            }
-            if (!path) {
-              break;
-            }
-            last = tmp;
-          }
-          else {
-            path = inc(path);
-          }
+      // Coerce a given path to a path string using #to_path and #to_str
+      function $coerce_to_path(path) {
+        if (#{Opal.truthy?(`path`.respond_to?(:to_path))}) {
+          path = path.$to_path();
         }
 
-        return last;
-      }
-
-      function isDirSep(sep) {
-        return sep.charAt(0) === #{SEPARATOR};
-      }
+        path = #{Opal.coerce_to!(`path`, String, :to_str)};
 
-      function skipRoot(path) {
-        while (path.length > 0 && isDirSep(path)) {
-          path = inc(path);
-        }
         return path;
       }
 
-      function pointerSubtract(a, b) {
-        if (a.length == 0) {
-          return b.length;
-        }
-        return b.indexOf(a);
-      }
-
-      function handleSuffix(n, f, p, suffix, name, origName) {
-        var suffixMatch;
-
-        if (n >= 0) {
-          if (suffix === nil) {
-            f = n;
-          }
-          else {
-            suffixMatch = suffix === '.*' ? '\\.\\w+' : suffix.replace(/\?/g, '\\?');
-            suffixMatch = new RegExp(suffixMatch + #{Separator} + '*$').exec(p);
-            if (suffixMatch) {
-              f = suffixMatch.index;
-            }
-            else {
-              f = n;
-            }
-          }
-
-          if (f === origName.length) {
-            return name;
-          }
+      // Return a RegExp compatible char class
+      function $sep_chars() {
+        if (#{ALT_SEPARATOR} === nil) {
+          return Opal.escape_regexp(#{SEPARATOR});
+        } else {
+          return Opal.escape_regexp(#{SEPARATOR+ALT_SEPARATOR});
         }
-
-        return p.substring(0, f);
       }
     }
 
     def dirname(path)
+      sep_chars = `$sep_chars()`
+      path = `$coerce_to_path(path)`
       %x{
-        if (path === nil) {
-          #{raise TypeError, 'no implicit conversion of nil into String'}
-        }
-        if (#{path.respond_to?(:to_path)}) {
-          path = #{path.to_path};
-        }
-        if (!path.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{path.class} into String"}
-        }
-
-        var root, p;
+        var absolute = path.match(new RegExp(#{"^[#{sep_chars}]"}));
 
-        root = skipRoot(path);
+        path = path.replace(new RegExp(#{"[#{sep_chars}]+$"}), ''); // remove trailing separators
+        path = path.replace(new RegExp(#{"[^#{sep_chars}]+$"}), ''); // remove trailing basename
+        path = path.replace(new RegExp(#{"[#{sep_chars}]+$"}), ''); // remove final trailing separators
 
-        // if (root > name + 1) in the C code
-        if (root.length == 0) {
-          path = path.substring(path.length - 1, path.length);
-        }
-        else if (root.length - path.length < 0) {
-          path = path.substring(path.indexOf(root)-1, path.length);
+        if (path === '') {
+          return absolute ? '/' : '.';
         }
 
-        p = lastSeparator(root);
-        if (!p) {
-          p = root;
-        }
-        if (p === path) {
-          return '.';
-        }
-        return path.substring(0, path.length - p.length);
+        return path;
       }
     end
 
     def basename(name, suffix=nil)
+      sep_chars = `$sep_chars()`
+      name = `$coerce_to_path(name)`
       %x{
-        var p, q, e, f = 0, n = -1, tmp, pointerMath, origName;
-
-        if (name === nil) {
-          #{raise TypeError, 'no implicit conversion of nil into String'}
-        }
-        if (#{name.respond_to?(:to_path)}) {
-          name = #{name.to_path};
-        }
-        if (!name.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{name.class} into String"}
-        }
-        if (suffix !== nil && !suffix.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{suffix.class} into String"}
-        }
-
         if (name.length == 0) {
           return name;
         }
 
-        origName = name;
-        name = skipprefix(name);
-
-        while (isDirSep(name)) {
-          tmp = name;
-          name = inc(name);
-        }
-
-        if (!name) {
-          p = tmp;
-          f = 1;
+        if (suffix !== nil) {
+          suffix = #{Opal.coerce_to!(suffix, String, :to_str)}
+        } else {
+          suffix = null;
         }
-        else {
-          if (!(p = lastSeparator(name))) {
-            p = name;
-          }
-          else {
-            while (isDirSep(p)) {
-              p = inc(p);
-            }
-          }
 
-          n = pointerSubtract(chompdirsep(p), p);
+        name = name.replace(new RegExp(#{"(.)[#{sep_chars}]*$"}), '$1');
+        name = name.replace(new RegExp(#{"^(?:.*[#{sep_chars}])?([^#{sep_chars}]+)$"}), '$1');
 
-          for (q = p; pointerSubtract(q, p) < n && q.charAt(0) === '.'; q = inc(q)) {
-          }
-
-          for (e = null; pointerSubtract(q, p) < n; q = inc(q)) {
-            if (q.charAt(0) === '.') {
-              e = q;
-            }
-          }
-
-          if (e) {
-            f = pointerSubtract(e, p);
-          }
-          else {
-            f = n;
-          }
+        if (suffix === ".*") {
+          name = name.replace(/\.[^\.]+$/, '');
+        } else if(suffix !== null) {
+          suffix = Opal.escape_regexp(suffix);
+          name = name.replace(new RegExp(#{"#{suffix}$"}), '');
         }
 
-        return handleSuffix(n, f, p, suffix, name, origName);
+        return name;
       }
     end
 
     def extname(path)
-      raise TypeError, 'no implicit conversion of nil into String' if path.nil?
-      path = path.to_path if path.respond_to?(:to_path)
-      raise TypeError, "no implicit conversion of #{path.class} into String" unless path.is_a?(String)
+      `path = $coerce_to_path(path);`
       filename = basename(path)
       return '' if filename.empty?
       last_dot_idx = filename[1..-1].rindex('.')
@@ -255,7 +121,36 @@ class File < IO
     end
 
     def join(*paths)
-      paths.join(SEPARATOR).gsub(%r{#{SEPARATOR}+}, SEPARATOR)
+      if paths.length == 0
+        return ''
+      end
+      result = ''
+      paths = paths.flatten.each_with_index.map do |item, index|
+        if index == 0 && item.empty?
+          SEPARATOR
+        elsif paths.length == index + 1 && item.empty?
+          SEPARATOR
+        else
+          item
+        end
+      end
+      paths = paths.reject { |path| path.empty? }
+      paths.each_with_index do |item, index|
+        next_item = paths[index + 1]
+        if next_item.nil?
+          result = "#{result}#{item}"
+        else
+          if item.end_with?(SEPARATOR) && next_item.start_with?(SEPARATOR)
+            item = item.sub(%r{#{SEPARATOR}+$}, '')
+          end
+          if item.end_with?(SEPARATOR) || next_item.start_with?(SEPARATOR)
+            result = "#{result}#{item}"
+          else
+            result = "#{result}#{item}#{SEPARATOR}"
+          end
+        end
+      end
+      result
     end
 
     def split(path)