opal 1.1.0 → 1.2.0

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/pattern_matching.rb

@@ -0,0 +1,159 @@
+# A "userland" implementation of pattern matching for Opal
+
+class PatternMatching
+  def self.call(from, pattern)
+    pm = new(from, pattern)
+    pm.match || (return nil)
+    pm.returns
+  end
+
+  def initialize(from, pattern)
+    @from, @pattern = from, pattern
+    @returns = []
+  end
+
+  attr_reader :returns
+
+  def match(from = @from, pattern = @pattern)
+    if pattern == :var
+      @returns << from
+      true
+    else # Pattern is otherwise an Array
+      type, *args = *pattern
+
+      case type
+      when :save # from =>
+        @returns << from
+        match(from, args[0])
+      when :lit # 3, 4, :a, (1..), ... (but also ^a)
+        args[0] === from
+      when :any # a | b
+        args.any? { |arg| match(from, arg) }
+      when :all # Array(1) which works as Array & [1] (& doesn't exist though...)
+        args.all? { |arg| match(from, arg) }
+      when :array # [...]
+        fixed_size, array_size, array_match = *args
+        return false unless from.respond_to? :deconstruct
+        a = from.deconstruct
+        return false if fixed_size && a.length != array_size
+        return false if a.length < array_size
+
+        skip_elems = 0
+        skip_rests = 0
+
+        array_match.each_with_index.all? do |elem, i|
+          type, *args = elem
+          case type
+          when :rest
+            skip_elems = a.size - array_size
+            skip_rests = 1
+            match(a[i...i + skip_elems], args[0]) if args[0] # :save?
+            true
+          else
+            match(a[i + skip_elems - skip_rests], elem)
+          end
+        end
+      when :find # [*, a, b, *]
+        find_match, = *args
+        first, *find_match, last = *find_match
+        pattern_length = find_match.length
+
+        return false unless from.respond_to? :deconstruct
+        a = from.deconstruct
+        a_length = a.length
+        return false if a_length < pattern_length
+
+        # We will save the backup of returns, to be restored
+        # on each iteration to try again.
+        returns_backup = @returns.dup
+
+        # Extract the capture info from first and last.
+        # Both are of a form [:rest], or [:rest, :var].
+        # So our new variables will be either :var, or nil.
+        first, last = first[1], last[1]
+
+        # Let's try to match each possibility...
+        # [A, B, c, d], [a, B, C, d], [a, b, C, D]
+        iterations = a_length - pattern_length + 1
+
+        iterations.times.any? do |skip|
+          first_part = a[0, skip]
+          content = a[skip, pattern_length]
+          last_part = a[skip + pattern_length..-1]
+
+          match(first_part, first) if first
+          success = content.each_with_index.all? do |e, i|
+            match(e, find_match[i])
+          end
+          match(last_part, last) if last
+
+          # Match failed. Let's not return anything.
+          @returns = returns_backup.dup unless success
+
+          success
+        end
+      when :hash # {...}
+        any_size, hash_match = *args
+
+        hash_match = hash_match.to_h
+
+        return false unless from.respond_to? :deconstruct_keys
+
+        if any_size && any_size != true # a => {a:, **other}
+          a = from.deconstruct_keys(nil) #          ^^^^^^^
+        else
+          a = from.deconstruct_keys(hash_match.keys)
+        end
+
+        hash_match.all? do |k, v|
+          return false unless a.key? k
+          match(a[k], v)
+        end || (return false)
+
+        if any_size && any_size != true
+          match(a.except(*hash_match.keys), args[0])
+        elsif !any_size
+          return false unless a.except(*hash_match.keys).empty?
+        end
+
+        true
+      end
+    end
+  end
+end
+
+class Array
+  def deconstruct
+    self
+  end
+end
+
+class Hash
+  def deconstruct_keys(_)
+    self
+  end
+end
+
+class Struct
+  alias deconstruct to_a
+  # This function is specified in a very weird way...
+  def deconstruct_keys(keys)
+    return to_h if keys.nil?
+    raise TypeError, 'expected Array or nil' unless Array === keys
+    return {} if keys.length > values.length
+    out = {}
+    keys.each do |key|
+      should_break = case key
+                     when Integer
+                       values.length < key
+                     when Symbol # Or String? Doesn't matter, we're in Opal.
+                       !members.include?(key)
+                     end
+      break if should_break
+      out[key] = self[key]
+    end
+    out
+  end
+end
+
+class NoMatchingPatternError < StandardError; 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