opal 1.1.1 → 1.2.0.beta1

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

data/opal/corelib/object_space.rb

@@ -0,0 +1,102 @@
+# helpers: respond_to, falsy, truthy
+
+module ObjectSpace
+  module_function
+
+  %x{
+    var callers = {}, registry, add_caller, delete_callers;
+    if (typeof FinalizationRegistry === "function") {
+      registry = new FinalizationRegistry(function(id) {
+        if (typeof callers[id] !== "undefined") {
+          for (var i = 0; i < callers[id].length; i++) {
+            #{`callers[id][i]`.call(`id`)};
+          }
+          delete callers[id];
+        }
+      });
+      add_caller = function(id, value) {
+        callers[id] = callers[id] || [];
+        callers[id].push(value);
+      }
+      delete_callers = function(id) {
+        delete callers[id];
+      }
+    }
+    else {
+      // A weak polyfill for FinalizationRegistry
+      registry = {
+        register: function(){},
+        unregister: function(){}
+      };
+      add_caller = function(){};
+      delete_callers = function(){};
+    }
+  }
+
+  def define_finalizer(obj, aproc = undefined, &block)
+    %x{
+      if ($truthy(block)) aproc = block;
+      if ($falsy(aproc)) aproc = #{proc};
+      if (!$respond_to(aproc, '$call')) {
+        #{raise ArgumentError, "Wrong type argument #{aproc.class} (should be callable)"};
+      }
+      var id = #{obj.__id__};
+      add_caller(id, aproc);
+      try {
+        registry.register(obj, id, obj);
+      }
+      catch (e) {
+        delete_callers(id);
+        #{raise ArgumentError, "cannot define finalizer for #{obj.class}"};
+      }
+      return [0, aproc];
+    }
+  end
+
+  def undefine_finalizer(obj)
+    %{
+      var id = #{obj.__id__};
+      registry.unregister(obj);
+      delete_callers(id);
+      return obj;
+    }
+  end
+
+  class WeakMap
+    include Enumerable
+
+    def initialize
+      @weak_map = `new WeakMap()`
+      @primitive_map = {}
+    end
+
+    def [](p1)
+      %x{
+        if (typeof p1 !== "function" && typeof p1 !== "object") return #{@primitive_map[p1]};
+        return #{@weak_map}.get(p1);
+      }
+    end
+
+    def []=(p1, p2)
+      %x{
+        if (typeof p1 !== "function" && typeof p1 !== "object") return #{@primitive_map[p1] = p2};
+        return #{@weak_map}.set(p1, p2);
+      }
+    end
+
+    def include?(p1)
+      %x{
+        if (typeof p1 !== "function" && typeof p1 !== "object") return #{@primitive_map.key? p1};
+        return #{@weak_map}.has(p1);
+      }
+    end
+    alias member? include?
+    alias key? include?
+
+    %i[each each_key each_value each_pair keys values size length].each do |i|
+      define_method i do |*|
+        raise NotImplementedError, "##{i} can't be implemented on top of JS interfaces"
+      end
+    end
+  end
+end

data/opal/corelib/random.rb

@@ -1,6 +1,18 @@
+# helpers: falsy
+
 class Random
   attr_reader :seed, :state
 
+  def self._verify_count(count)
+    %x{
+      if ($falsy(count)) count = 16;
+      if (typeof count !== "number") count = #{`count`.to_int};
+      if (count < 0) #{raise ArgumentError, 'negative string size (or size too big)'};
+      count = Math.floor(count);
+      return count;
+    }
+  end
+
   def initialize(seed = Random.new_seed)
     seed = Opal.coerce_to!(seed, Integer, :to_int)
     @state = seed
@@ -29,13 +41,7 @@ class Random
   end
 
   def self.urandom(size)
-    size = Opal.coerce_to!(size, Integer, :to_int)
-
-    if size < 0
-      raise ArgumentError, 'negative string size (or size too big)'
-    end
-
-    Array.new(size) { rand(255).chr }.join.encode('ASCII-8BIT')
+    ::SecureRandom.bytes(size)
   end
 
   def ==(other)
@@ -45,74 +51,33 @@ class Random
   end
 
   def bytes(length)
-    length = Opal.coerce_to!(length, Integer, :to_int)
+    length = Random._verify_count(length)
 
     Array.new(length) { rand(255).chr }.join.encode('ASCII-8BIT')
   end
 
+  def self.bytes(length)
+    DEFAULT.bytes(length)
+  end
+
   def rand(limit = undefined)
+    random_number(limit)
+  end
+
+  # Not part of the Ruby interface (use #random_number for portability), but
+  # used by Random::Formatter as a shortcut, as for Random interface the float
+  # RNG is primary.
+  def random_float
     %x{
-      function randomFloat() {
-        self.state++;
-        return Opal.$$rand.rand(self.$rng);
-      }
-
-      function randomInt() {
-        return Math.floor(randomFloat() * limit);
-      }
-
-      function randomRange() {
-        var min = limit.begin,
-            max = limit.end;
-
-        if (min === nil || max === nil) {
-          return nil;
-        }
-
-        var length = max - min;
-
-        if (length < 0) {
-          return nil;
-        }
-
-        if (length === 0) {
-          return min;
-        }
-
-        if (max % 1 === 0 && min % 1 === 0 && !limit.excl) {
-          length++;
-        }
-
-        return self.$rand(length) + min;
-      }
-
-      if (limit == null) {
-        return randomFloat();
-      } else if (limit.$$is_range) {
-        return randomRange();
-      } else if (limit.$$is_number) {
-        if (limit <= 0) {
-          #{raise ArgumentError, "invalid argument - #{limit}"}
-        }
-
-        if (limit % 1 === 0) {
-          // integer
-          return randomInt();
-        } else {
-          return randomFloat() * limit;
-        }
-      } else {
-        limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
-
-        if (limit <= 0) {
-          #{raise ArgumentError, "invalid argument - #{limit}"}
-        }
-
-        return randomInt();
-      }
+      self.state++;
+      return Opal.$$rand.rand(self.$rng);
     }
   end
 
+  def self.random_float
+    DEFAULT.random_float
+  end
+
   def self.generator=(generator)
     `Opal.$$rand = #{generator}`
 

data/opal/corelib/random/formatter.rb

@@ -0,0 +1,122 @@
+class Random
+  module Formatter
+    def hex(count = nil)
+      count = Random._verify_count(count)
+      %x{
+        var bytes = #{bytes(count)};
+        var out = "";
+        for (var i = 0; i < #{count}; i++) {
+          out += bytes.charCodeAt(i).toString(16).padStart(2, '0');
+        }
+        return #{`out`.encode('US-ASCII')};
+      }
+    end
+
+    def random_bytes(count = nil)
+      bytes(count)
+    end
+
+    def base64(count = nil)
+      Base64.strict_encode64(random_bytes(count)).encode('US-ASCII')
+    end
+
+    def urlsafe_base64(count = nil, padding = false)
+      Base64.urlsafe_encode64(random_bytes(count), padding).encode('US-ASCII')
+    end
+
+    def uuid
+      str = hex(16).split('')
+      str[12] = '4'
+      str[16] = `(parseInt(#{str[16]}, 16) & 3 | 8).toString(16)`
+      str = [str[0...8], str[8...12], str[12...16], str[16...20], str[20...32]]
+      str = str.map(&:join)
+      str.join('-')
+    end
+
+    # Implemented in terms of `#bytes` for SecureRandom, but Random overrides this
+    # method to implement `#bytes` in terms of `#random_float`. Not part of standard
+    # Ruby interface - use random_number for portability.
+    def random_float
+      bs = bytes(4)
+      num = 0
+      4.times do |i|
+        num <<= 8
+        num |= bs[i].ord
+      end
+      num.abs / 0x7fffffff
+    end
+
+    def random_number(limit = undefined)
+      %x{
+        function randomFloat() {
+          return #{random_float};
+        }
+
+        function randomInt(max) {
+          return Math.floor(randomFloat() * max);
+        }
+
+        function randomRange() {
+          var min = limit.begin,
+              max = limit.end;
+
+          if (min === nil || max === nil) {
+            return nil;
+          }
+
+          var length = max - min;
+
+          if (length < 0) {
+            return nil;
+          }
+
+          if (length === 0) {
+            return min;
+          }
+
+          if (max % 1 === 0 && min % 1 === 0 && !limit.excl) {
+            length++;
+          }
+
+          return randomInt(length) + min;
+        }
+
+        if (limit == null) {
+          return randomFloat();
+        } else if (limit.$$is_range) {
+          return randomRange();
+        } else if (limit.$$is_number) {
+          if (limit <= 0) {
+            #{raise ArgumentError, "invalid argument - #{limit}"}
+          }
+
+          if (limit % 1 === 0) {
+            // integer
+            return randomInt(limit);
+          } else {
+            return randomFloat() * limit;
+          }
+        } else {
+          limit = #{Opal.coerce_to!(limit, Integer, :to_int)};
+
+          if (limit <= 0) {
+            #{raise ArgumentError, "invalid argument - #{limit}"}
+          }
+
+          return randomInt(limit);
+        }
+      }
+    end
+
+    def alphanumeric(count = nil)
+      count = Random._verify_count(count)
+      map = ['0'..'9', 'a'..'z', 'A'..'Z'].map(&:to_a).flatten
+      Array.new(count) do |i|
+        map[random_number(map.length)]
+      end.join
+    end
+  end
+
+  include Random::Formatter
+  extend Random::Formatter
+end