opal 1.4.1 → 1.5.0.rc1

data/opal/corelib/math.rb

@@ -36,124 +36,6 @@ module ::Math
 
   module_function
 
-  def acos(x)
-    ::Math.checked :acos, ::Math.float!(x)
-  end
-
-  unless defined?(`Math.acosh`)
-    %x{
-      Math.acosh = function(x) {
-        return Math.log(x + Math.sqrt(x * x - 1));
-      }
-    }
-  end
-
-  def acosh(x)
-    ::Math.checked :acosh, ::Math.float!(x)
-  end
-
-  def asin(x)
-    ::Math.checked :asin, ::Math.float!(x)
-  end
-
-  unless defined?(`Math.asinh`)
-    %x{
-      Math.asinh = function(x) {
-        return Math.log(x + Math.sqrt(x * x + 1))
-      }
-    }
-  end
-
-  def asinh(x)
-    ::Math.checked :asinh, ::Math.float!(x)
-  end
-
-  def atan(x)
-    ::Math.checked :atan, ::Math.float!(x)
-  end
-
-  def atan2(y, x)
-    ::Math.checked :atan2, ::Math.float!(y), ::Math.float!(x)
-  end
-
-  unless defined?(`Math.atanh`)
-    %x{
-      Math.atanh = function(x) {
-        return 0.5 * Math.log((1 + x) / (1 - x));
-      }
-    }
-  end
-
-  def atanh(x)
-    ::Math.checked :atanh, ::Math.float!(x)
-  end
-
-  unless defined?(`Math.cbrt`)
-    %x{
-      Math.cbrt = function(x) {
-        if (x == 0) {
-          return 0;
-        }
-
-        if (x < 0) {
-          return -Math.cbrt(-x);
-        }
-
-        var r  = x,
-            ex = 0;
-
-        while (r < 0.125) {
-          r *= 8;
-          ex--;
-        }
-
-        while (r > 1.0) {
-          r *= 0.125;
-          ex++;
-        }
-
-        r = (-0.46946116 * r + 1.072302) * r + 0.3812513;
-
-        while (ex < 0) {
-          r *= 0.5;
-          ex++;
-        }
-
-        while (ex > 0) {
-          r *= 2;
-          ex--;
-        }
-
-        r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
-        r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
-        r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
-        r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
-
-        return r;
-      }
-    }
-  end
-
-  def cbrt(x)
-    ::Math.checked :cbrt, ::Math.float!(x)
-  end
-
-  def cos(x)
-    ::Math.checked :cos, ::Math.float!(x)
-  end
-
-  unless defined?(`Math.cosh`)
-    %x{
-      Math.cosh = function(x) {
-        return (Math.exp(x) + Math.exp(-x)) / 2;
-      }
-    }
-  end
-
-  def cosh(x)
-    ::Math.checked :cosh, ::Math.float!(x)
-  end
-
   unless defined?(`Math.erf`)
     %x{
       Opal.prop(Math, 'erf', function(x) {
@@ -180,10 +62,6 @@ module ::Math
     }
   end
 
-  def erf(x)
-    ::Math.checked :erf, ::Math.float!(x)
-  end
-
   unless defined?(`Math.erfc`)
     %x{
       Opal.prop(Math, 'erfc', function(x) {
@@ -213,12 +91,22 @@ module ::Math
     }
   end
 
-  def erfc(x)
-    ::Math.checked :erfc, ::Math.float!(x)
+  # Single argument equivalent functions
+  %i[
+    acos acosh asin asinh atan atanh cbrt
+    cos cosh erf erfc exp sin sinh sqrt tanh
+  ].each do |method|
+    define_method method do |x|
+      ::Math.checked method, ::Math.float!(x)
+    end
   end
 
-  def exp(x)
-    ::Math.checked :exp, ::Math.float!(x)
+  def atan2(y, x)
+    ::Math.checked :atan2, ::Math.float!(y), ::Math.float!(x)
+  end
+
+  def hypot(x, y)
+    ::Math.checked :hypot, ::Math.float!(x), ::Math.float!(y)
   end
 
   def frexp(x)
@@ -332,18 +220,6 @@ module ::Math
     }
   end
 
-  unless defined?(`Math.hypot`)
-    %x{
-      Math.hypot = function(x, y) {
-        return Math.sqrt(x * x + y * y)
-      }
-    }
-  end
-
-  def hypot(x, y)
-    ::Math.checked :hypot, ::Math.float!(x), ::Math.float!(y)
-  end
-
   def ldexp(mantissa, exponent)
     mantissa = Math.float!(mantissa)
     exponent = Math.integer!(exponent)
@@ -384,14 +260,6 @@ module ::Math
     end
   end
 
-  unless defined?(`Math.log10`)
-    %x{
-      Math.log10 = function(x) {
-        return Math.log(x) / Math.LN10;
-      }
-    }
-  end
-
   def log10(x)
     if ::String === x
       ::Kernel.raise `$type_error(x, #{::Float})`
@@ -400,14 +268,6 @@ module ::Math
     ::Math.checked :log10, ::Math.float!(x)
   end
 
-  unless defined?(`Math.log2`)
-    %x{
-      Math.log2 = function(x) {
-        return Math.log(x) / Math.LN2;
-      }
-    }
-  end
-
   def log2(x)
     if ::String === x
       ::Kernel.raise `$type_error(x, #{::Float})`
@@ -416,26 +276,6 @@ module ::Math
     ::Math.checked :log2, ::Math.float!(x)
   end
 
-  def sin(x)
-    ::Math.checked :sin, ::Math.float!(x)
-  end
-
-  unless defined?(`Math.sinh`)
-    %x{
-      Math.sinh = function(x) {
-        return (Math.exp(x) - Math.exp(-x)) / 2;
-      }
-    }
-  end
-
-  def sinh(x)
-    ::Math.checked :sinh, ::Math.float!(x)
-  end
-
-  def sqrt(x)
-    ::Math.checked :sqrt, ::Math.float!(x)
-  end
-
   def tan(x)
     x = ::Math.float!(x)
 
@@ -445,24 +285,4 @@ module ::Math
 
     ::Math.checked :tan, ::Math.float!(x)
   end
-
-  unless defined?(`Math.tanh`)
-    %x{
-      Math.tanh = function(x) {
-        if (x == Infinity) {
-          return 1;
-        }
-        else if (x == -Infinity) {
-          return -1;
-        }
-        else {
-          return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
-        }
-      }
-    }
-  end
-
-  def tanh(x)
-    ::Math.checked :tanh, ::Math.float!(x)
-  end
 end

data/opal/corelib/module.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, coerce_to, const_set, Object
+# helpers: truthy, coerce_to, const_set, Object, return_ivar, assign_ivar, ivar
 
 class ::Module
   def self.allocate
@@ -131,20 +131,9 @@ class ::Module
       for (var i = names.length - 1; i >= 0; i--) {
         var name = names[i],
             id   = '$' + name,
-            ivar = Opal.ivar(name);
-
-        // the closure here is needed because name will change at the next
-        // cycle, I wish we could use let.
-        var body = (function(ivar) {
-          return function() {
-            if (this[ivar] == null) {
-              return nil;
-            }
-            else {
-              return this[ivar];
-            }
-          };
-        })(ivar);
+            ivar = $ivar(name);
+
+        var body = $return_ivar(ivar);
 
         // initialize the instance variable as nil
         Opal.prop(proto, ivar, nil);
@@ -166,15 +155,9 @@ class ::Module
       for (var i = names.length - 1; i >= 0; i--) {
         var name = names[i],
             id   = '$' + name + '=',
-            ivar = Opal.ivar(name);
+            ivar = $ivar(name);
 
-        // the closure here is needed because name will change at the next
-        // cycle, I wish we could use let.
-        var body = (function(ivar){
-          return function(value) {
-            return this[ivar] = value;
-          }
-        })(ivar);
+        var body = $assign_ivar(ivar)
 
         body.$$parameters = [['req']];
         body.$$arity = 1;
@@ -396,14 +379,29 @@ class ::Module
               end
 
     %x{
-      var id = '$' + name;
+      if (typeof(Proxy) !== 'undefined') {
+        var meta = Object.create(null)
+
+        block.$$proxy_target = block
+        block = new Proxy(block, {
+          apply: function(target, self, args) {
+            var old_name = target.$$jsid
+            target.$$jsid = name;
+            try {
+              return target.apply(self, args);
+            } finally {
+              target.$$jsid = old_name
+            }
+          }
+        })
+      }
 
       block.$$jsid        = name;
       block.$$s           = null;
       block.$$def         = block;
       block.$$define_meth = true;
 
-      return Opal.defn(self, id, block);
+      return Opal.defn(self, '$' + name, block);
     }
   end
 

data/opal/corelib/number.rb

@@ -263,20 +263,6 @@ 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) {
@@ -291,6 +277,8 @@ class ::Number < ::Numeric
     }
   end
 
+  alias === ==
+
   def abs
     `Math.abs(self)`
   end
@@ -817,6 +805,67 @@ class ::Number < ::Numeric
     `self == -Infinity || 1 / self < 0`
   end
 
+  %x{
+    function numberToUint8Array(num) {
+      var uint8array = new Uint8Array(8);
+      new DataView(uint8array.buffer).setFloat64(0, num, true);
+      return uint8array;
+    }
+
+    function uint8ArrayToNumber(arr) {
+      return new DataView(arr.buffer).getFloat64(0, true);
+    }
+
+    function incrementNumberBit(num) {
+      var arr = numberToUint8Array(num);
+      for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === 0xff) {
+          arr[i] = 0;
+        } else {
+          arr[i]++;
+          break;
+        }
+      }
+      return uint8ArrayToNumber(arr);
+    }
+
+    function decrementNumberBit(num) {
+      var arr = numberToUint8Array(num);
+      for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === 0) {
+          arr[i] = 0xff;
+        } else {
+          arr[i]--;
+          break;
+        }
+      }
+      return uint8ArrayToNumber(arr);
+    }
+  }
+
+  def next_float
+    return ::Float::INFINITY if self == ::Float::INFINITY
+    return ::Float::NAN if nan?
+
+    if self >= 0
+      # Math.abs() is needed to handle -0.0
+      `incrementNumberBit(Math.abs(self))`
+    else
+      `decrementNumberBit(self)`
+    end
+  end
+
+  def prev_float
+    return -::Float::INFINITY if self == -::Float::INFINITY
+    return ::Float::NAN if nan?
+
+    if self > 0
+      `decrementNumberBit(self)`
+    else
+      `-incrementNumberBit(Math.abs(self))`
+    end
+  end
+
   alias arg angle
   alias eql? ==
   alias fdiv /

data/opal/corelib/regexp.rb

@@ -83,6 +83,8 @@ class ::Regexp < `RegExp`
           #{::Kernel.raise ::RegexpError, "too short escape sequence: /#{regexp}/"}
         }
 
+        regexp = regexp.replace('\\A', '^').replace('\\z', '$')
+
         if (options === undefined || #{!options}) {
           return new RegExp(regexp);
         }

data/opal/corelib/runtime.js

@@ -184,7 +184,22 @@
   };
 
   Opal.coerce_to = function(object, type, method, args) {
-    if (type['$==='](object)) return object;
+    var body;
+
+    if (method === 'to_int' && type === Opal.Integer && object.$$is_number)
+      return object < 0 ? Math.ceil(object) : Math.floor(object);
+
+    if (method === 'to_str' && type === Opal.String && object.$$is_string)
+      return object;
+
+    if (Opal.is_a(object, type)) return object;
+
+    // Fast path for the most common situation
+    if (object['$respond_to?'].$$pristine && object.$method_missing.$$pristine) {
+      body = object['$' + method];
+      if (body == null || body.$$stub) throw Opal.type_error(object, type);
+      return body.apply(object, args);
+    }
 
     if (!object['$respond_to?'](method)) {
       throw Opal.type_error(object, type);
@@ -1592,7 +1607,10 @@
     }
 
     if (implicit && current_func.$$define_meth) {
-      throw Opal.RuntimeError.$new("implicit argument passing of super from method defined by define_method() is not supported. Specify all arguments explicitly");
+      throw Opal.RuntimeError.$new(
+        "implicit argument passing of super from method defined by define_method() is not supported. " +
+        "Specify all arguments explicitly"
+      );
     }
 
     if (current_func.$$def) {
@@ -1708,15 +1726,9 @@
       return (klass.$$is_integer_class) ? (object % 1) === 0 : true;
     }
 
-    var i, length, ancestors = Opal.ancestors(object.$$is_class ? Opal.get_singleton_class(object) : (object.$$meta || object.$$class));
+    var ancestors = Opal.ancestors(object.$$is_class ? Opal.get_singleton_class(object) : (object.$$meta || object.$$class));
 
-    for (i = 0, length = ancestors.length; i < length; i++) {
-      if (ancestors[i] === klass) {
-        return true;
-      }
-    }
-
-    return false;
+    return ancestors.indexOf(klass) !== -1;
   };
 
   // Helpers for extracting kwsplats
@@ -1874,8 +1886,6 @@
   Opal.send = function(recv, method, args, block, blockopts) {
     var body;
 
-    apply_blockopts(block, blockopts);
-
     if (typeof(method) === 'function') {
       body = method;
       method = null;
@@ -1885,7 +1895,7 @@
       throw Opal.NameError.$new("Passed method should be a string or a function");
     }
 
-    return Opal.send2(recv, body, method, args, block);
+    return Opal.send2(recv, body, method, args, block, blockopts);
   };
 
   Opal.send2 = function(recv, body, method, args, block, blockopts) {
@@ -1909,8 +1919,6 @@
       ancestors = Opal.ancestors(recv.$$class);
     }
 
-    apply_blockopts(block, blockopts);
-
     // For all ancestors that there are, starting from the closest to the furthest...
     for (i = 0; i < ancestors.length; i++) {
       ancestor = Opal.id(ancestors[i]);
@@ -1930,14 +1938,14 @@
             // Does this module define a method we want to call?
             if (typeof refine_module.$$prototype['$'+method] !== 'undefined') {
               body = refine_module.$$prototype['$'+method];
-              return Opal.send2(recv, body, method, args, block);
+              return Opal.send2(recv, body, method, args, block, blockopts);
             }
           }
         }
       }
     }
 
-    return Opal.send(recv, method, args, block);
+    return Opal.send(recv, method, args, block, blockopts);
   };
 
   Opal.lambda = function(block, blockopts) {
@@ -2654,7 +2662,7 @@
       if (typeof Promise !== 'undefined' && retval instanceof Promise) {
         // A special case of require having an async top:
         // We will need to await it.
-        return retval.then(function() { return true; });
+        return retval.then($return_val(true));
       }
     }
     else {
@@ -2777,13 +2785,15 @@
   Opal.rb_ge     = function(l,r) { return (typeof(l) === 'number' && typeof(r) === 'number') ? l >= r : l['$>='](r); }
 
   // Optimized helpers for calls like $truthy((a)['$==='](b)) -> $eqeqeq(a, b)
-  Opal.eqeq = function(lhs, rhs) {
+  function $eqeq(lhs, rhs) {
     if ((typeof lhs === 'number' && typeof rhs === 'number') ||
         (typeof lhs === 'string' && typeof rhs === 'string')) {
       return lhs === rhs;
     }
     return $truthy((lhs)['$=='](rhs));
   };
+  Opal.eqeq = $eqeq;
+
   Opal.eqeqeq = function(lhs, rhs) {
     if ((typeof lhs === 'number' && typeof rhs === 'number') ||
         (typeof lhs === 'string' && typeof rhs === 'string')) {
@@ -2804,7 +2814,33 @@
     return $truthy(arg['$!']());
   }
 
+  // Shortcuts - optimized function generators for simple kinds of functions
+  function $return_val(arg) {
+    return function() {
+      return arg;
+    }
+  }
+  Opal.return_val = $return_val;
 
+  Opal.return_self = function() {
+    return this;
+  }
+  Opal.return_ivar = function(ivar) {
+    return function() {
+      if (this[ivar] == null) this[ivar] = nil;
+      return this[ivar];
+    }
+  }
+  Opal.assign_ivar = function(ivar) {
+    return function(val) {
+      return this[ivar] = val;
+    }
+  }
+  Opal.assign_ivar_val = function(ivar, static_val) {
+    return function() {
+      return this[ivar] = static_val;
+    }
+  }
 
   // Initialization
   // --------------
@@ -2856,7 +2892,7 @@
 
   // Instantiate the main object
   Opal.top = new _Object();
-  Opal.top.$to_s = Opal.top.$inspect = function() { return 'main' };
+  Opal.top.$to_s = Opal.top.$inspect = $return_val('main');
   Opal.top.$define_method = top_define_method;
 
   // Foward calls to define_method on the top object to Object