opal 0.10.0 → 0.11.0

data/opal/corelib/number.rb

@@ -2,8 +2,16 @@ require 'corelib/numeric'
 
 class Number < Numeric
   Opal.bridge(self, `Number`)
-
   `Number.prototype.$$is_number = true`
+  `self.$$is_number_class = true`
+
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+  end
 
   def coerce(other)
     %x{
@@ -261,10 +269,24 @@ class Number < Numeric
     end
   end
 
+  def ===(other)
+    %x{
+      if (other.$$is_number) {
+        return self.valueOf() === other.valueOf();
+      }
+      else if (#{other.respond_to? :==}) {
+        return #{other == self};
+      }
+      else {
+        return false;
+      }
+    }
+  end
+
   def ==(other)
     %x{
       if (other.$$is_number) {
-        return self == Number(other);
+        return self.valueOf() === other.valueOf();
       }
       else if (#{other.respond_to? :==}) {
         return #{other == self};
@@ -567,34 +589,182 @@ class Number < Numeric
     end
   end
 
-  def step(limit, step = 1, &block)
-    return enum_for :step, limit, step unless block
+  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"}
+      }
 
-    raise ArgumentError, 'step cannot be 0' if `step == 0`
+      function validateParameters() {
+        if (to !== undefined) {
+          limit = to;
+        }
 
-    %x{
-      var value = self;
+        if (limit === undefined) {
+          limit = nil;
+        }
 
-      if (limit === Infinity || limit === -Infinity) {
-        block(value);
-        return self;
+        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 TypeError, "0 can't be coerced into #{step.class}"}
+        }
+
+        if (limit === nil || limit == null) {
+          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
+        }
+
+        #{Opal.compare(self, limit)}
       }
 
-      if (step > 0) {
-        while (value <= limit) {
-          block(value);
-          value += step;
+      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
+          }
         }
       }
-      else {
-        while (value >= limit) {
-          block(value);
-          value += step;
+
+      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);
         }
       }
     }
 
-    self
+    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.empty?}) {
+          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
@@ -705,7 +875,7 @@ class Number < Numeric
   end
 
   def positive?
-    `self == Infinity || 1 / self > 0`
+    `self != 0 && (self == Infinity || 1 / self > 0)`
   end
 
   def negative?
@@ -716,14 +886,24 @@ end
 Fixnum = Number
 
 class Integer < Numeric
-  def self.===(other)
-    %x{
-      if (!other.$$is_number) {
-        return false;
-      }
+  `self.$$is_number_class = true`
 
-      return (other % 1) === 0;
-    }
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+
+    def ===(other)
+      %x{
+        if (!other.$$is_number) {
+          return false;
+        }
+
+        return (other % 1) === 0;
+      }
+    end
   end
 
   MAX = `Math.pow(2, 30) - 1`
@@ -731,8 +911,18 @@ class Integer < Numeric
 end
 
 class Float < Numeric
-  def self.===(other)
-    `!!other.$$is_number`
+  `self.$$is_number_class = true`
+
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+
+    def ===(other)
+      `!!other.$$is_number`
+    end
   end
 
   INFINITY = `Infinity`
@@ -744,9 +934,5 @@ class Float < Numeric
   MANT_DIG = 53
   RADIX    = 2
 
-  if defined?(`Number.EPSILON`)
-    EPSILON = `Number.EPSILON`
-  else
-    EPSILON = `2.2204460492503130808472633361816E-16`
-  end
+  EPSILON = `Number.EPSILON || 2.2204460492503130808472633361816E-16`
 end

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
@@ -180,10 +172,10 @@ class Numeric
   end
 
   def dup
-    raise TypeError, "can't dup #{self.class}"
+    self
   end
 
-  def clone
-    raise TypeError, "can't clone #{self.class}"
+  def clone(freeze: true)
+    self
   end
 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/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/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.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();
+      }
+    }
+  end
+end