opal 0.10.6 → 0.11.0.rc1

data/opal/corelib/numeric.rb

@@ -35,14 +35,6 @@ class Numeric
     nil
   end
 
-  def [](bit)
-    bit = Opal.coerce_to! bit, Integer, :to_int
-    min = -(2**30)
-    max =  (2**30) - 1
-
-    `(#{bit} < #{min} || #{bit} > #{max}) ? 0 : (self >> #{bit}) % 2`
-  end
-
   def +@
     self
   end

data/opal/corelib/process.rb

@@ -1,6 +1,33 @@
 class Process
-  CLOCK_REALTIME  = 0
-  CLOCK_MONOTONIC = 1
+  @__clocks__ = []
+  def self.__register_clock__(name, func)
+    const_set name, @__clocks__.size
+    @__clocks__ << func
+  end
+
+  __register_clock__ :CLOCK_REALTIME, `function() { return Date.now() }`
+
+  monotonic = false
+
+  %x{
+    if (Opal.global.performance) {
+      monotonic = function() {
+        return performance.now()
+      };
+    }
+    else if (Opal.global.process && process.hrtime) {
+      // let now be the base to get smaller numbers
+      var hrtime_base = process.hrtime();
+
+      monotonic = function() {
+        var hrtime = process.hrtime(hrtime_base);
+        var us = (hrtime[1] / 1000) | 0; // cut below microsecs;
+        return ((hrtime[0] * 1000) + (us / 1000));
+      };
+    }
+  }
+
+  __register_clock__(:CLOCK_MONOTONIC, monotonic) if monotonic
 
   def self.pid
     0
@@ -11,8 +38,21 @@ class Process
     Benchmark::Tms.new(t, t, t, t, t)
   end
 
-  def self.clock_gettime(clock_id, unit = nil)
-    Time.now.to_f
+  def self.clock_gettime(clock_id, unit = :float_second)
+    clock = @__clocks__[clock_id] or raise Errno::EINVAL, "clock_gettime(#{clock_id}) #{@__clocks__[clock_id]}"
+    %x{
+      var ms = clock();
+      switch (unit) {
+        case 'float_second':      return  (ms / 1000);         // number of seconds as a float (default)
+        case 'float_millisecond': return  (ms / 1);            // number of milliseconds as a float
+        case 'float_microsecond': return  (ms * 1000);         // number of microseconds as a float
+        case 'second':            return ((ms / 1000)    | 0); // number of seconds as an integer
+        case 'millisecond':       return ((ms / 1)       | 0); // number of milliseconds as an integer
+        case 'microsecond':       return ((ms * 1000)    | 0); // number of microseconds as an integer
+        case 'nanosecond':        return ((ms * 1000000) | 0); // number of nanoseconds as an integer
+        default: #{raise ArgumentError, "unexpected unit: #{unit}"}
+      }
+    }
   end
 end
 

data/opal/corelib/random.rb

@@ -0,0 +1,117 @@
+require 'corelib/random/seedrandom.js'
+
+class Random
+  attr_reader :seed, :state
+
+  def initialize(seed = Random.new_seed)
+    seed = Opal.coerce_to!(seed, Integer, :to_int)
+    @state = seed
+    reseed(seed)
+  end
+
+  def reseed(seed)
+    @seed = seed
+    `self.$rng = new Math.seedrandom(seed);`
+  end
+
+  `var $seed_generator = new Math.seedrandom('opal', { entropy: true });`
+
+  def self.new_seed
+    %x{
+      return Math.abs($seed_generator.int32());
+    }
+  end
+
+  def self.rand(limit = undefined)
+    DEFAULT.rand(limit)
+  end
+
+
+  def self.srand(n = Random.new_seed)
+    n = Opal.coerce_to!(n, Integer, :to_int)
+
+    previous_seed = DEFAULT.seed
+    DEFAULT.reseed(n)
+    previous_seed
+  end
+
+  DEFAULT = new(new_seed)
+
+  def ==(other)
+    return false unless Random === other
+
+    seed == other.seed && state == other.state
+  end
+
+  def bytes(length)
+    length = Opal.coerce_to!(length, Integer, :to_int)
+    length
+      .times
+      .map { rand(255).chr }
+      .join
+      .encode(Encoding::ASCII_8BIT)
+  end
+
+  def rand(limit = undefined)
+    %x{
+      function randomFloat() {
+        self.state++;
+        return self.$rng.quick();
+      }
+
+      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.exclude) {
+          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();
+      }
+    }
+  end
+end

data/opal/corelib/random/seedrandom.js.rb

@@ -0,0 +1,15 @@
+class Random
+  %x{
+    /* jshint ignore:start */
+    /*
+    seedrandom.min.js 2.4.1 (original source: https://github.com/davidbau/seedrandom/blob/2.4.1/seedrandom.min.js)
+    How to update:
+     . Chekout the latest release from GitHub: https://github.com/davidbau/seedrandom
+     . Apply the following commits:
+     .. Check for hasOwnProperty in flatten(): https://github.com/iliabylich/seedrandom/commit/06a94f59ae3d3956c8b1a2488334cafab6744b04
+     .. Add a module id for the RequireJS `define` method: https://github.com/Mogztter/seedrandom/commit/e047540c3d81f955cab9a01d17b8141d439fbd7d
+    */
+    !function(a,b){function c(c,j,k){var n=[];j=1==j?{entropy:!0}:j||{};var s=g(f(j.entropy?[c,i(a)]:null==c?h():c,3),n),t=new d(n),u=function(){for(var a=t.g(m),b=p,c=0;a<q;)a=(a+c)*l,b*=l,c=t.g(1);for(;a>=r;)a/=2,b/=2,c>>>=1;return(a+c)/b};return u.int32=function(){return 0|t.g(4)},u.quick=function(){return t.g(4)/4294967296},u.double=u,g(i(t.S),a),(j.pass||k||function(a,c,d,f){return f&&(f.S&&e(f,t),a.state=function(){return e(t,{})}),d?(b[o]=a,c):a})(u,s,"global"in j?j.global:this==b,j.state)}function d(a){var b,c=a.length,d=this,e=0,f=d.i=d.j=0,g=d.S=[];for(c||(a=[c++]);e<l;)g[e]=e++;for(e=0;e<l;e++)g[e]=g[f=s&f+a[e%c]+(b=g[e])],g[f]=b;(d.g=function(a){for(var b,c=0,e=d.i,f=d.j,g=d.S;a--;)b=g[e=s&e+1],c=c*l+g[s&(g[e]=g[f=s&f+b])+(g[f]=b)];return d.i=e,d.j=f,c})(l)}function e(a,b){return b.i=a.i,b.j=a.j,b.S=a.S.slice(),b}function f(a,b){var c,d=[],e=typeof a;if(b&&"object"==e)for(c in a)if(a.hasOwnProperty(c))try{d.push(f(a[c],b-1))}catch(a){}return d.length?d:"string"==e?a:a+"\0"}function g(a,b){for(var c,d=a+"",e=0;e<d.length;)b[s&e]=s&(c^=19*b[s&e])+d.charCodeAt(e++);return i(b)}function h(){try{if(j)return i(j.randomBytes(l));var b=new Uint8Array(l);return(k.crypto||k.msCrypto).getRandomValues(b),i(b)}catch(b){var c=k.navigator,d=c&&c.plugins;return[+new Date,k,d,k.screen,i(a)]}}function i(a){return String.fromCharCode.apply(0,a)}var j,k=this,l=256,m=6,n=52,o="random",p=b.pow(l,m),q=b.pow(2,n),r=2*q,s=l-1;if(b["seed"+o]=c,g(b.random(),a),"object"==typeof module&&module.exports){module.exports=c;try{j=require("crypto")}catch(a){}}else"function"==typeof define&&define.amd&&define('seekrandom',function(){return c})}([],Math);
+    /* jshint ignore:end */
+  }
+end

data/opal/corelib/range.rb

@@ -8,7 +8,8 @@ class Range
   attr_reader :begin, :end
 
   def initialize(first, last, exclude = false)
-    raise ArgumentError unless first <=> last
+    raise NameError, "'initialize' called twice" if @begin
+    raise ArgumentError, "bad value for range" unless first <=> last
 
     @begin   = first
     @end     = last
@@ -32,7 +33,14 @@ class Range
   end
 
   def cover?(value)
-    @begin <= value && (@exclude ? value < @end : value <= @end)
+    beg_cmp = (@begin <=> value)
+    return false unless beg_cmp && beg_cmp <= 0
+    end_cmp = (value <=> @end)
+    if @exclude
+      end_cmp && end_cmp < 0
+    else
+      end_cmp && end_cmp <= 0
+    end
   end
 
   def each(&block)
@@ -62,7 +70,11 @@ class Range
     current = @begin
     last    = @end
 
-    while current < last
+    unless current.respond_to?(:succ)
+      raise TypeError, "can't iterate from #{current.class}"
+    end
+
+    while (current <=> last) < 0
       yield current
 
       current = current.succ
@@ -85,16 +97,26 @@ class Range
     @exclude
   end
 
-  alias :first :begin
+  def first(n = undefined)
+    return @begin if `n == null`
+    super
+  end
 
   alias :include? :cover?
 
-  alias :last :end
+  def last(n = undefined)
+    return @end if `n == null`
+    to_a.last(n)
+  end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def max
     if block_given?
       super
+    elsif @begin > @end
+      nil
+    elsif @exclude && @begin == @end
+      nil
     else
       `#@exclude ? #@end - 1 : #@end`
     end
@@ -105,13 +127,15 @@ class Range
   def min
     if block_given?
       super
+    elsif @begin > @end
+      nil
+    elsif @exclude && @begin == @end
+      nil
     else
       @begin
     end
   end
 
-  alias member? include?
-
   def size
     _begin = @begin
     _end   = @end
@@ -126,18 +150,117 @@ class Range
   end
 
   def step(n = 1)
-    raise NotImplementedError
+    %x{
+      function coerceStepSize() {
+        if (!n.$$is_number) {
+          n = #{Opal.coerce_to!(n, Integer, :to_int)}
+        }
+
+        if (n < 0) {
+          #{raise ArgumentError, "step can't be negative"}
+        } else if (n === 0) {
+          #{raise ArgumentError, "step can't be 0"}
+        }
+      }
+
+      function enumeratorSize() {
+        if (!#{@begin.respond_to?(:succ)}) {
+          return nil;
+        }
+
+        if (#{@begin}.$$is_string && #{@end}.$$is_string) {
+          return nil;
+        }
+
+        if (n % 1 === 0) {
+          return #{(size / n).ceil};
+        } else {
+          // n is a float
+          var begin = self.begin, end = self.end,
+              abs = Math.abs, floor = Math.floor,
+              err = (abs(begin) + abs(end) + abs(end - begin)) / abs(n) * #{Float::EPSILON},
+              size;
+
+          if (err > 0.5) {
+            err = 0.5;
+          }
+
+          if (self.exclude) {
+            size = floor((end - begin) / n - err);
+            if (size * n + begin < end) {
+              size++;
+            }
+          } else {
+            size = floor((end - begin) / n + err) + 1
+          }
+
+          return size;
+        }
+      }
+    }
+
+
+    unless block_given?
+      return enum_for(:step, n) {
+        %x{
+          coerceStepSize();
+          return enumeratorSize();
+        }
+      }
+    end
+
+    `coerceStepSize()`
+
+    if `self.begin.$$is_number && self.end.$$is_number`
+      i = 0
+      loop do
+        current = @begin + i * n
+        if @exclude
+          break if current >= @end
+        else
+          break if current > @end
+        end
+        yield(current)
+        i += 1
+      end
+    else
+      %x{
+        if (#{@begin}.$$is_string && #{@end}.$$is_string && n % 1 !== 0) {
+          #{raise TypeError, "no implicit conversion to float from string"}
+        }
+      }
+      each_with_index do |value, idx|
+        yield(value) if idx % n == 0
+      end
+    end
+    self
+  end
+
+  def bsearch(&block)
+    return enum_for(:bsearch) unless block_given?
+
+    unless `self.begin.$$is_number && self.end.$$is_number`
+      raise TypeError, "can't do binary search for #{@begin.class}"
+    end
+
+    to_a.bsearch(&block)
   end
 
   def to_s
-    `#{@begin.inspect} + (#@exclude ? '...' : '..') + #{@end.inspect}`
+    "#{@begin}#{ @exclude ? '...' : '..' }#{@end}"
   end
 
-  alias inspect to_s
+  def inspect
+    "#{@begin.inspect}#{ @exclude ? '...' : '..' }#{@end.inspect}"
+  end
 
   def marshal_load(args)
     @begin = args[:begin]
     @end = args[:end]
     @exclude = args[:excl]
   end
+
+  def hash
+    [@begin, @end, @exclude].hash
+  end
 end

data/opal/corelib/regexp.rb

@@ -14,13 +14,7 @@ class Regexp < `RegExp`
     end
 
     def escape(string)
-      %x{
-        return string.replace(/([-[\]\/{}()*+?.^$\\| ])/g, '\\$1')
-                     .replace(/[\n]/g, '\\n')
-                     .replace(/[\r]/g, '\\r')
-                     .replace(/[\f]/g, '\\f')
-                     .replace(/[\t]/g, '\\t');
-      }
+      `Opal.escape_regexp(string)`
     end
 
     def last_match(n=nil)
@@ -43,7 +37,7 @@ class Regexp < `RegExp`
         is_first_part_array = parts[0].$$is_array;
         if (parts.length > 1 && is_first_part_array) {
           #{raise TypeError, 'no implicit conversion of Array into String'}
-        }        
+        }
         // deal with splat issues (related to https://github.com/opal/opal/issues/858)
         if (is_first_part_array) {
           parts = parts[0];
@@ -118,7 +112,41 @@ class Regexp < `RegExp`
   alias eql? ==
 
   def inspect
-    `self.toString()`
+    # Use a regexp to extract the regular expression and the optional mode modifiers from the string.
+    # In the regular expression, escape any front slash (not already escaped) with a backslash.
+    %x{
+      var regexp_format = /^\/(.*)\/([^\/]*)$/;
+      var value = self.toString();
+      var matches = regexp_format.exec(value);
+      if (matches) {
+        var regexp_pattern = matches[1];
+        var regexp_flags = matches[2];
+        var chars = regexp_pattern.split('');
+        var chars_length = chars.length;
+        var char_escaped = false;
+        var regexp_pattern_escaped = '';
+        for (var i = 0; i < chars_length; i++) {
+          var current_char = chars[i];
+          if (!char_escaped && current_char == '/') {
+            regexp_pattern_escaped = regexp_pattern_escaped.concat('\\');
+          }
+          regexp_pattern_escaped = regexp_pattern_escaped.concat(current_char);
+          if (current_char == '\\') {
+            if (char_escaped) {
+              // does not over escape
+              char_escaped = false;
+            } else {
+              char_escaped = true;
+            }
+          } else {
+            char_escaped = false;
+          }
+        }
+        return '/' + regexp_pattern_escaped + '/' + regexp_flags;
+      } else {
+        return value;
+      }
+    }
   end
 
   def match(string, pos = undefined, &block)