opal 0.10.0 → 0.11.0

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.3'
-RUBY_ENGINE_VERSION = '0.10.0'
-RUBY_RELEASE_DATE   = '2016-07-04'
+RUBY_VERSION        = '2.4.0'
+RUBY_ENGINE_VERSION = '0.11.0'
+RUBY_RELEASE_DATE   = '2017-12-08'
 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)
+    return to_enum(:chunk) { self.enumerator_size } 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?
 
@@ -114,6 +114,12 @@ module Enumerable
   def count(object = undefined, &block)
     result = 0
 
+    %x{
+      if (object != null && block !== nil) {
+        #{warn('warning: given block not used')}
+      }
+    }
+
     if `object != null`
       block = proc do |*args|
         Opal.destructure(args) == object
@@ -450,6 +456,12 @@ module Enumerable
   def find_index(object = undefined, &block)
     return enum_for :find_index if `object === undefined && block === nil`
 
+    %x{
+      if (object != null && block !== nil) {
+        #{warn('warning: given block not used')}
+      }
+    }
+
     index = 0
 
     if `object != null`
@@ -539,6 +551,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 +985,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 +1048,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?
@@ -1016,6 +1146,21 @@ module Enumerable
     dup.map! { |i| `i[1]` }
   end
 
+  def sum(initial = 0, &block)
+    result = initial
+
+    each do |*args|
+      if block_given?
+        item = block.call(*args)
+      else
+        item = Opal.destructure(args)
+      end
+      result += item
+    end
+
+    result
+  end
+
   def take(num)
     first(num)
   end
@@ -1036,6 +1181,26 @@ module Enumerable
     end
   end
 
+  def uniq(&block)
+    hash = {}
+
+    each do |*args|
+      value = Opal.destructure(args)
+
+      produced = if block_given?
+        block.call(value)
+      else
+        value
+      end
+
+      unless hash.has_key?(produced)
+        hash[produced] = value
+      end
+    end
+
+    hash.values
+  end
+
   alias to_a entries
 
   def zip(*others, &block)

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