opal 1.1.0 → 1.2.0

data/opal/corelib/array/pack.rb

@@ -442,7 +442,12 @@ class Array
         output = output.concat(part);
       });
 
-      return output;
+      if (format.match(/^(U\*?)+$/)) {
+        return output;
+      }
+      else {
+        return Opal.enc(output, "binary");
+      }
     }
   end
 end

data/opal/corelib/complex.rb

@@ -245,6 +245,8 @@ class Complex < Numeric
 
   alias rectangular rect
 
+  undef step
+
   def to_f
     unless @imag == 0
       raise RangeError, "can't convert #{self} into Float"

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '3.0.0'
-RUBY_ENGINE_VERSION = '1.1.0'
-RUBY_RELEASE_DATE   = '2021-02-19'
+RUBY_VERSION        = '3.0.2'
+RUBY_ENGINE_VERSION = '1.2.0'
+RUBY_RELEASE_DATE   = '2021-07-28'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = '0'
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'

data/opal/corelib/hash.rb

@@ -476,6 +476,15 @@ class Hash
 
   alias eql? ==
 
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+
   def fetch(key, defaults = undefined, &block)
     %x{
       var value = Opal.hash_get(self, key);
@@ -762,53 +771,51 @@ class Hash
 
   alias member? has_key?
 
-  def merge(other, &block)
-    dup.merge!(other, &block)
+  def merge(*others, &block)
+    dup.merge!(*others, &block)
   end
 
-  def merge!(other, &block)
+  def merge!(*others, &block)
     %x{
-      if (!other.$$is_hash) {
-        other = #{Opal.coerce_to!(other, Hash, :to_hash)};
-      }
-
-      var i, other_keys = other.$$keys, length = other_keys.length, key, value, other_value;
-
-      if (block === nil) {
-        for (i = 0; i < length; i++) {
-          key = other_keys[i];
-
-          if (key.$$is_string) {
-            other_value = other.$$smap[key];
-          } else {
-            other_value = key.value;
-            key = key.key;
+      var i, j, other, other_keys, length, key, value, other_value;
+      for (i = 0; i < others.length; ++i) {
+        other = #{Opal.coerce_to!(`others[i]`, Hash, :to_hash)};
+        other_keys = other.$$keys, length = other_keys.length;
+
+        if (block === nil) {
+          for (j = 0; j < length; j++) {
+            key = other_keys[j];
+
+            if (key.$$is_string) {
+              other_value = other.$$smap[key];
+            } else {
+              other_value = key.value;
+              key = key.key;
+            }
+
+            Opal.hash_put(self, key, other_value);
           }
+        } else {
+          for (j = 0; j < length; j++) {
+            key = other_keys[j];
 
-          Opal.hash_put(self, key, other_value);
-        }
-
-        return self;
-      }
-
-      for (i = 0; i < length; i++) {
-        key = other_keys[i];
+            if (key.$$is_string) {
+              other_value = other.$$smap[key];
+            } else {
+              other_value = key.value;
+              key = key.key;
+            }
 
-        if (key.$$is_string) {
-          other_value = other.$$smap[key];
-        } else {
-          other_value = key.value;
-          key = key.key;
-        }
+            value = Opal.hash_get(self, key);
 
-        value = Opal.hash_get(self, key);
+            if (value === undefined) {
+              Opal.hash_put(self, key, other_value);
+              continue;
+            }
 
-        if (value === undefined) {
-          Opal.hash_put(self, key, other_value);
-          continue;
+            Opal.hash_put(self, key, block(key, value, other_value));
+          }
         }
-
-        Opal.hash_put(self, key, block(key, value, other_value));
       }
 
       return self;

data/opal/corelib/module.rb

@@ -204,13 +204,8 @@ class Module
 
   def class_variable_get(name)
     name = Opal.class_variable_name!(name)
-    %x{
-      var value = Opal.class_variables(self)[name];
-      if (value == null) {
-        #{raise NameError.new("uninitialized class variable #{name} in #{self}", name)}
-      }
-      return value;
-    }
+
+    `Opal.class_variable_get(self, name, false)`
   end
 
   def class_variable_set(name, value)

data/opal/corelib/number.rb

@@ -379,7 +379,7 @@ class Number < Numeric
   end
 
   def chr(encoding = undefined)
-    `String.fromCharCode(self)`
+    `Opal.enc(String.fromCharCode(self), encoding || "BINARY")`
   end
 
   def denominator
@@ -668,184 +668,6 @@ class Number < Numeric
     end
   end
 
-  def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
-    %x{
-      if (limit !== undefined && to !== undefined) {
-        #{raise ArgumentError, 'to is given twice'}
-      }
-
-      if (step !== undefined && by !== undefined) {
-        #{raise ArgumentError, 'step is given twice'}
-      }
-
-      function validateParameters() {
-        if (to !== undefined) {
-          limit = to;
-        }
-
-        if (limit === undefined) {
-          limit = nil;
-        }
-
-        if (step === nil) {
-          #{raise TypeError, 'step must be numeric'}
-        }
-
-        if (step === 0) {
-          #{raise ArgumentError, "step can't be 0"}
-        }
-
-        if (by !== undefined) {
-          step = by;
-        }
-
-        if (step === nil || step == null) {
-          step = 1;
-        }
-
-        var sign = #{step <=> 0};
-
-        if (sign === nil) {
-          #{raise ArgumentError, "0 can't be coerced into #{step.class}"}
-        }
-
-        if (limit === nil || limit == null) {
-          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
-        }
-
-        #{Opal.compare(self, limit)}
-      }
-
-      function stepFloatSize() {
-        if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
-          return 0;
-        } else if (step === Infinity || step === -Infinity) {
-          return 1;
-        } else {
-          var abs = Math.abs, floor = Math.floor,
-              err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{Float::EPSILON};
-
-          if (err === Infinity || err === -Infinity) {
-            return 0;
-          } else {
-            if (err > 0.5) {
-              err = 0.5;
-            }
-
-            return floor((limit - self) / step + err) + 1
-          }
-        }
-      }
-
-      function stepSize() {
-        validateParameters();
-
-        if (step === 0) {
-          return Infinity;
-        }
-
-        if (step % 1 !== 0) {
-          return stepFloatSize();
-        } else if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
-          return 0;
-        } else {
-          var ceil = Math.ceil, abs = Math.abs,
-              lhs = abs(self - limit) + 1,
-              rhs = abs(step);
-
-          return ceil(lhs / rhs);
-        }
-      }
-    }
-
-    unless block_given?
-      positional_args = []
-      keyword_args = {}
-
-      %x{
-        if (limit !== undefined) {
-          positional_args.push(limit);
-        }
-
-        if (step !== undefined) {
-          positional_args.push(step);
-        }
-
-        if (to !== undefined) {
-          Opal.hash_put(keyword_args, "to", to);
-        }
-
-        if (by !== undefined) {
-          Opal.hash_put(keyword_args, "by", by);
-        }
-
-        if (#{keyword_args.any?}) {
-          positional_args.push(keyword_args);
-        }
-      }
-
-      return enum_for(:step, *positional_args) { `stepSize()` }
-    end
-
-    %x{
-      validateParameters();
-
-      if (step === 0) {
-        while (true) {
-          block(self);
-        }
-      }
-
-      if (self % 1 !== 0 || limit % 1 !== 0 || step % 1 !== 0) {
-        var n = stepFloatSize();
-
-        if (n > 0) {
-          if (step === Infinity || step === -Infinity) {
-            block(self);
-          } else {
-            var i = 0, d;
-
-            if (step > 0) {
-              while (i < n) {
-                d = i * step + self;
-                if (limit < d) {
-                  d = limit;
-                }
-                block(d);
-                i += 1;
-              }
-            } else {
-              while (i < n) {
-                d = i * step + self;
-                if (limit > d) {
-                  d = limit;
-                }
-                block(d);
-                i += 1
-              }
-            }
-          }
-        }
-      } else {
-        var value = self;
-
-        if (step > 0) {
-          while (value <= limit) {
-            block(value);
-            value += step;
-          }
-        } else {
-          while (value >= limit) {
-            block(value);
-            value += step
-          }
-        }
-      }
-
-      return self;
-    }
-  end
-
   alias succ next
 
   def times(&block)
@@ -865,7 +687,7 @@ class Number < Numeric
   end
 
   def to_i
-    `parseInt(self, 10)`
+    `self < 0 ? Math.ceil(self) : Math.floor(self)`
   end
 
   alias to_int to_i

data/opal/corelib/numeric.rb

@@ -145,6 +145,162 @@ class Numeric
     to_f.round(digits)
   end
 
+  def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
+    %x{
+      if (limit !== undefined && to !== undefined) {
+        #{raise ArgumentError, 'to is given twice'}
+      }
+
+      if (step !== undefined && by !== undefined) {
+        #{raise ArgumentError, 'step is given twice'}
+      }
+
+      if (to !== undefined) {
+        limit = to;
+      }
+
+      if (by !== undefined) {
+        step = by;
+      }
+
+      if (limit === undefined) {
+        limit = nil;
+      }
+
+      function validateParameters() {
+        if (step === nil) {
+          #{raise TypeError, 'step must be numeric'}
+        }
+
+        if (step != null && #{step == 0}) {
+          #{raise ArgumentError, "step can't be 0"}
+        }
+
+        if (step === nil || step == null) {
+          step = 1;
+        }
+
+        var sign = #{step <=> 0};
+
+        if (sign === nil) {
+          #{raise ArgumentError, "0 can't be coerced into #{step.class}"}
+        }
+
+        if (limit === nil || limit == null) {
+          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
+        }
+
+        #{Opal.compare(self, limit)}
+      }
+
+      function stepFloatSize() {
+        if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
+          return 0;
+        } else if (step === Infinity || step === -Infinity) {
+          return 1;
+        } else {
+          var abs = Math.abs, floor = Math.floor,
+              err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{Float::EPSILON};
+
+          if (err === Infinity || err === -Infinity) {
+            return 0;
+          } else {
+            if (err > 0.5) {
+              err = 0.5;
+            }
+
+            return floor((limit - self) / step + err) + 1
+          }
+        }
+      }
+
+      function stepSize() {
+        validateParameters();
+
+        if (step === 0) {
+          return Infinity;
+        }
+
+        if (step % 1 !== 0) {
+          return stepFloatSize();
+        } else if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
+          return 0;
+        } else {
+          var ceil = Math.ceil, abs = Math.abs,
+              lhs = abs(self - limit) + 1,
+              rhs = abs(step);
+
+          return ceil(lhs / rhs);
+        }
+      }
+
+    }
+
+    return enum_for(:step, limit, step, &`stepSize`) unless block_given?
+
+    %x{
+      validateParameters();
+
+      var isDesc = #{step.negative?},
+          isInf = #{step == 0} ||
+                  (limit === Infinity && !isDesc) ||
+                  (limit === -Infinity && isDesc);
+
+      if (self.$$is_number && step.$$is_number && limit.$$is_number) {
+        if (self % 1 === 0 && (isInf || limit % 1 === 0) && step % 1 === 0) {
+          var value = self;
+
+          if (isInf) {
+            for (;; value += step) {
+              block(value);
+            }
+          } else if (isDesc) {
+            for (; value >= limit; value += step) {
+              block(value);
+            }
+          } else {
+            for (; value <= limit; value += step) {
+              block(value);
+            }
+          }
+
+          return self;
+        } else {
+          var begin = #{to_f}.valueOf();
+          step = #{step.to_f}.valueOf();
+          limit = #{limit.to_f}.valueOf();
+
+          var n = stepFloatSize();
+
+          if (!isFinite(step)) {
+            if (n !== 0) block(begin);
+          } else if (step === 0) {
+            while (true) {
+              block(begin);
+            }
+          } else {
+            for (var i = 0; i < n; i++) {
+              var d = i * step + self;
+              if (step >= 0 ? limit < d : limit > d) {
+                d = limit;
+              }
+              block(d);
+            }
+          }
+
+          return self;
+        }
+      }
+    }
+
+    counter = self
+
+    while `isDesc ? #{counter >= limit} : #{counter <= limit}`
+      yield counter
+      counter += step
+    end
+  end
+
   def to_c
     Complex(self, 0)
   end