opal 1.0.3 → 1.1.1.rc1

data/opal/corelib/array/pack.rb

@@ -1,3 +1,5 @@
+# helpers: coerce_to
+
 require 'corelib/pack_unpack/format_string_parser'
 
 class Array
@@ -91,7 +93,7 @@ class Array
         var buffer = callback(data);
 
         return buffer.map(function(item) {
-          return #{Opal.coerce_to `item`, Integer, :to_int}
+          return $coerce_to(item, #{Integer}, 'to_int')
         });
       }
     }
@@ -101,7 +103,7 @@ class Array
         var buffer = callback(data);
 
         return buffer.map(function(item) {
-          return #{Opal.coerce_to `item`, String, :to_str}
+          return $coerce_to(item, #{String}, 'to_str')
         });
       }
     }
@@ -225,7 +227,7 @@ class Array
         } else if (source === undefined) {
           #{raise ArgumentError, 'too few arguments'};
         } else {
-          source = #{Opal.coerce_to `source`, String, :to_str};
+          source = $coerce_to(source, #{String}, 'to_str');
         }
 
         buffer = buffer.slice(1, buffer.length);

data/opal/corelib/basic_object.rb

@@ -134,10 +134,6 @@ class BasicObject
   def singleton_method_undefined(*)
   end
 
-  def class
-    `self.$$class`
-  end
-
   def method_missing(symbol, *args, &block)
     message = if `self.$inspect && !self.$inspect.$$stub`
                 "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}"
@@ -147,4 +143,8 @@ class BasicObject
 
     ::Kernel.raise ::NoMethodError.new(message, symbol)
   end
+
+  def respond_to_missing?(method_name, include_all = false)
+    false
+  end
 end

data/opal/corelib/class.rb

@@ -49,13 +49,14 @@ class Class
     %x{
       var singleton_of = self.$$singleton_of;
 
-      if (singleton_of && (singleton_of.$$is_a_module)) {
+      if (singleton_of && singleton_of.$$is_a_module) {
         return #{"#<Class:#{`singleton_of`.name}>"};
       }
       else if (singleton_of) {
         // a singleton class created from an object
         return #{"#<Class:#<#{`singleton_of.$$class`.name}:0x#{`Opal.id(singleton_of)`.to_s(16)}>>"};
       }
+
       return #{super()};
     }
   end

data/opal/corelib/comparable.rb

@@ -1,3 +1,5 @@
+# helpers: falsy
+
 module Comparable
   %x{
     function normalize(what) {
@@ -20,6 +22,12 @@ module Comparable
       }
       #{raise ArgumentError, "comparison of #{`lhs`.class} with #{`class_name`} failed"}
     }
+
+    function cmp_or_fail(lhs, rhs) {
+      var cmp = #{`lhs` <=> `rhs`};
+      if ($falsy(cmp)) fail_comparison(lhs, rhs);
+      return normalize(cmp);
+    }
   }
 
   def ==(other)
@@ -43,35 +51,19 @@ module Comparable
   end
 
   def >(other)
-    unless cmp = (self <=> other)
-      `fail_comparison(self, other)`
-    end
-
-    `normalize(cmp) > 0`
+    `cmp_or_fail(self, other) > 0`
   end
 
   def >=(other)
-    unless cmp = (self <=> other)
-      `fail_comparison(self, other)`
-    end
-
-    `normalize(cmp) >= 0`
+    `cmp_or_fail(self, other) >= 0`
   end
 
   def <(other)
-    unless cmp = (self <=> other)
-      `fail_comparison(self, other)`
-    end
-
-    `normalize(cmp) < 0`
+    `cmp_or_fail(self, other) < 0`
   end
 
   def <=(other)
-    unless cmp = (self <=> other)
-      `fail_comparison(self, other)`
-    end
-
-    `normalize(cmp) <= 0`
+    `cmp_or_fail(self, other) <= 0`
   end
 
   def between?(min, max)
@@ -80,19 +72,45 @@ module Comparable
     true
   end
 
-  def clamp(min, max)
-    cmp = min <=> max
+  def clamp(min, max = nil)
+    %x{
+      var c, excl;
+
+      if (max === nil) {
+        // We are dealing with a new Ruby 2.7 behaviour that we are able to
+        // provide a single Range argument instead of 2 Comparables.
+
+        if (!Opal.is_a(min, Opal.Range)) {
+          #{raise TypeError, "wrong argument type #{min.class} (expected Range)"}
+        }
 
-    unless cmp
-      `fail_comparison(min, max)`
-    end
+        excl = min.excl;
+        max = min.end;
+        min = min.begin;
 
-    if `normalize(cmp) > 0`
-      raise ArgumentError, 'min argument must be smaller than max argument'
-    end
+        if (max !== nil && excl) {
+          #{raise ArgumentError, 'cannot clamp with an exclusive range'}
+        }
+      }
+
+      if (min !== nil && max !== nil && cmp_or_fail(min, max) > 0) {
+        #{raise ArgumentError, 'min argument must be smaller than max argument'}
+      }
+
+      if (min !== nil) {
+        c = cmp_or_fail(self, min);
+
+        if (c == 0) return self;
+        if (c < 0) return min;
+      }
+
+      if (max !== nil) {
+        c = cmp_or_fail(self, max);
 
-    return min if `normalize(#{self <=> min}) < 0`
-    return max if `normalize(#{self <=> max}) > 0`
-    self
+        if (c > 0) return max;
+      }
+
+      return self;
+    }
   end
 end

data/opal/corelib/constants.rb

@@ -1,9 +1,9 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '2.5.7'
-RUBY_ENGINE_VERSION = '1.0.3'
-RUBY_RELEASE_DATE   = '2020-02-01'
+RUBY_VERSION        = '3.0.0'
+RUBY_ENGINE_VERSION = '1.1.1.rc1'
+RUBY_RELEASE_DATE   = '2021-02-22'
 RUBY_PATCHLEVEL     = 0
-RUBY_REVISION       = 0
-RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2020 Adam Beynon and the Opal contributors'
+RUBY_REVISION       = '0'
+RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'
 RUBY_DESCRIPTION    = "opal #{RUBY_ENGINE_VERSION} (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION})"

data/opal/corelib/enumerable.rb

@@ -1,3 +1,5 @@
+# helpers: falsy, truthy, coerce_to
+
 module Enumerable
   %x{
     function comparableForPattern(value) {
@@ -172,8 +174,7 @@ module Enumerable
     end
 
     %x{
-      var result,
-          all = [], i, length, value;
+      var all = [], i, length, value;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)},
@@ -184,10 +185,6 @@ module Enumerable
 
       self.$each();
 
-      if (result !== undefined) {
-        return result;
-      }
-
       if (all.length === 0) {
         return nil;
       }
@@ -235,7 +232,7 @@ module Enumerable
   end
 
   def drop(number)
-    number = Opal.coerce_to number, Integer, :to_int
+    number = `$coerce_to(number, #{Integer}, 'to_int')`
 
     if `number < 0`
       raise ArgumentError, 'attempt to drop negative size'
@@ -272,7 +269,7 @@ module Enumerable
         if (dropping) {
           var value = Opal.yield1(block, param);
 
-          if (#{Opal.falsy?(`value`)}) {
+          if ($falsy(value)) {
             dropping = false;
             result.push(param);
           }
@@ -313,7 +310,7 @@ module Enumerable
     end
 
     %x{
-      var buffer = [], result = nil;
+      var buffer = [];
 
       self.$each.$$p = function() {
         var element = #{Opal.destructure(`arguments`)};
@@ -328,7 +325,7 @@ module Enumerable
 
       self.$each();
 
-      return result;
+      return nil;
     }
   end
 
@@ -351,7 +348,7 @@ module Enumerable
   end
 
   def each_slice(n, &block)
-    n = Opal.coerce_to n, Integer, :to_int
+    n = `$coerce_to(#{n}, #{Integer}, 'to_int')`
 
     if `n <= 0`
       raise ArgumentError, 'invalid slice size'
@@ -360,8 +357,7 @@ module Enumerable
     return enum_for(:each_slice, n) { respond_to?(:size) ? (size / n).ceil : nil } unless block_given?
 
     %x{
-      var result,
-          slice = []
+      var slice = []
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)};
@@ -376,10 +372,6 @@ module Enumerable
 
       self.$each();
 
-      if (result !== undefined) {
-        return result;
-      }
-
       // our "last" group, if smaller than n then won't have been yielded
       if (slice.length > 0) {
         Opal.yield1(block, slice);
@@ -393,8 +385,7 @@ module Enumerable
     return enum_for(:each_with_index, *args) { enumerator_size } unless block_given?
 
     %x{
-      var result,
-          index = 0;
+      var index = 0;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)};
@@ -405,10 +396,6 @@ module Enumerable
       };
 
       self.$each.apply(self, args);
-
-      if (result !== undefined) {
-        return result;
-      }
     }
 
     self
@@ -418,8 +405,6 @@ module Enumerable
     return enum_for(:each_with_object, object) { enumerator_size } unless block_given?
 
     %x{
-      var result;
-
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)};
 
@@ -427,10 +412,6 @@ module Enumerable
       };
 
       self.$each();
-
-      if (result !== undefined) {
-        return result;
-      }
     }
 
     object
@@ -450,6 +431,12 @@ module Enumerable
     }
   end
 
+  def filter_map(&block)
+    return enum_for(:filter_map) { enumerator_size } unless block_given?
+
+    map(&block).select(&:itself)
+  end
+
   alias find detect
 
   def find_all(&block)
@@ -462,7 +449,7 @@ module Enumerable
         var param = #{Opal.destructure(`arguments`)},
             value = Opal.yield1(block, param);
 
-        if (#{Opal.truthy?(`value`)}) {
+        if ($truthy(value)) {
           result.push(param);
         }
       };
@@ -473,6 +460,8 @@ module Enumerable
     }
   end
 
+  alias filter find_all
+
   def find_index(object = undefined, &block)
     return enum_for :find_index if `object === undefined && block === nil`
 
@@ -512,7 +501,7 @@ module Enumerable
       end
     else
       result = []
-      number = Opal.coerce_to number, Integer, :to_int
+      number = `$coerce_to(number, #{Integer}, 'to_int')`
 
       if `number < 0`
         raise ArgumentError, 'attempt to take negative size'
@@ -705,15 +694,19 @@ module Enumerable
           return result;
         }
       }
-    }
 
-    n = Opal.coerce_to(n, Integer, :to_int)
+      n = $coerce_to(n, #{Integer}, 'to_int');
+    }
 
     sort(&block).reverse.first(n)
   end
 
-  def max_by(&block)
-    return enum_for(:max_by) { enumerator_size } unless block
+  def max_by(n = nil, &block)
+    return enum_for(:max_by, n) { enumerator_size } unless block
+
+    unless n.nil?
+      return sort_by(&block).reverse.take n
+    end
 
     %x{
       var result,
@@ -743,7 +736,15 @@ module Enumerable
 
   alias member? include?
 
-  def min(&block)
+  def min(n = nil, &block)
+    unless n.nil?
+      if block_given?
+        return sort { |a, b| yield a, b }.take n
+      else
+        return sort.take n
+      end
+    end
+
     %x{
       var result;
 
@@ -788,8 +789,12 @@ module Enumerable
     }
   end
 
-  def min_by(&block)
-    return enum_for(:min_by) { enumerator_size } unless block
+  def min_by(n = nil, &block)
+    return enum_for(:min_by, n) { enumerator_size } unless block
+
+    unless n.nil?
+      return sort_by(&block).take n
+    end
 
     %x{
       var result,
@@ -854,7 +859,33 @@ module Enumerable
   end
 
   def minmax_by(&block)
-    raise NotImplementedError
+    return enum_for(:minmax_by) { enumerator_size } unless block
+
+    %x{
+      var min_result = nil,
+          max_result = nil,
+          min_by,
+          max_by;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = Opal.yield1(block, param);
+
+        if ((min_by === undefined) || #{`value` <=> `min_by`} < 0) {
+          min_result = param;
+          min_by     = value;
+        }
+
+        if ((max_by === undefined) || #{`value` <=> `max_by`} > 0) {
+          max_result = param;
+          max_by     = value;
+        }
+      };
+
+      self.$each();
+
+      return [min_result, max_result];
+    }
   end
 
   def none?(pattern = undefined, &block)
@@ -922,7 +953,7 @@ module Enumerable
         var param = #{Opal.destructure(`arguments`)},
             value = Opal.yield1(block, param);
 
-        if (#{Opal.truthy?(`value`)}) {
+        if ($truthy(value)) {
           truthy.push(param);
         }
         else {
@@ -948,7 +979,7 @@ module Enumerable
         var param = #{Opal.destructure(`arguments`)},
             value = Opal.yield1(block, param);
 
-        if (#{Opal.falsy?(`value`)}) {
+        if ($falsy(value)) {
           result.push(param);
         }
       };
@@ -1000,7 +1031,7 @@ module Enumerable
               var param = #{Opal.destructure(`arguments`)},
                   value = Opal.yield1(block, param);
 
-              if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+              if ($truthy(value) && slice.length > 0) {
                 #{e << `slice`};
                 slice = [];
               }
@@ -1013,7 +1044,7 @@ module Enumerable
               var param = #{Opal.destructure(`arguments`)},
                   value = block(param, #{pattern.dup});
 
-              if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+              if ($truthy(value) && slice.length > 0) {
                 #{e << `slice`};
                 slice = [];
               }
@@ -1027,7 +1058,7 @@ module Enumerable
             var param = #{Opal.destructure(`arguments`)},
                 value = #{pattern === `param`};
 
-            if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+            if ($truthy(value) && slice.length > 0) {
               #{e << `slice`};
               slice = [];
             }
@@ -1070,7 +1101,7 @@ module Enumerable
             accumulate = [];
           }
 
-          if (#{Opal.truthy?(`end_chunk`)}) {
+          if ($truthy(end_chunk)) {
             accumulate.push(element);
             #{yielder.yield(`accumulate`)};
             accumulate = null;
@@ -1107,7 +1138,7 @@ module Enumerable
             slice = [];
           }
 
-          if (#{Opal.truthy?(`match`)}) {
+          if ($truthy(match)) {
             slice.push(before);
             #{yielder.yield(`slice`)};
             slice = [];
@@ -1198,8 +1229,39 @@ module Enumerable
     hash.values
   end
 
+  def tally
+    group_by(&:itself).transform_values(&:count)
+  end
+
   alias to_a entries
 
+  def to_h(*args, &block)
+    return map(&block).to_h(*args) if block_given?
+
+    %x{
+      var hash = #{{}};
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)};
+        var ary = #{Opal.coerce_to?(`param`, Array, :to_ary)}, key, val;
+        if (!ary.$$is_array) {
+          #{raise TypeError, "wrong element type #{`ary`.class} (expected array)"}
+        }
+        if (ary.length !== 2) {
+          #{raise ArgumentError, "wrong array length (expected 2, was #{`ary`.length})"}
+        }
+        key = ary[0];
+        val = ary[1];
+
+        Opal.hash_put(hash, key, val);
+      };
+
+      self.$each.apply(self, args);
+
+      return hash;
+    }
+  end
+
   def zip(*others, &block)
     to_a.zip(*others)
   end