opal 1.0.5 → 1.1.0.rc1

data/opal/corelib/method.rb

@@ -34,6 +34,14 @@ class Method
 
   alias [] call
 
+  def >>(other)
+    @method >> other
+  end
+
+  def <<(other)
+    @method << other
+  end
+
   def unbind
     UnboundMethod.new(@receiver.class, @owner, @method, @name)
   end

data/opal/corelib/module.rb

@@ -1,3 +1,5 @@
+# helpers: truthy, coerce_to
+
 class Module
   def self.allocate
     %x{
@@ -82,6 +84,8 @@ class Module
   end
 
   def alias_method(newname, oldname)
+    newname = `$coerce_to(newname, #{String}, 'to_str')`
+    oldname = `$coerce_to(oldname, #{String}, 'to_str')`
     `Opal.alias(self, newname, oldname)`
 
     self
@@ -107,7 +111,18 @@ class Module
     attr_writer(*names)
   end
 
-  alias attr attr_accessor
+  def attr(*args)
+    %x{
+      if (args.length == 2 && (args[1] === true || args[1] === false)) {
+        #{warn 'optional boolean argument is obsoleted', uplevel: 1}
+
+        args[1] ? #{attr_accessor(`args[0]`)} : #{attr_reader(`args[0]`)};
+        return nil;
+      }
+    }
+
+    attr_reader(*args)
+  end
 
   def attr_reader(*names)
     %x{
@@ -443,7 +458,7 @@ class Module
 
   def instance_methods(include_super = true)
     %x{
-      if (#{Opal.truthy?(include_super)}) {
+      if ($truthy(#{include_super})) {
         return Opal.instance_methods(self);
       } else {
         return Opal.own_instance_methods(self);

data/opal/corelib/number.rb

@@ -460,7 +460,7 @@ class Number < Numeric
   end
 
   def gcdlcm(other)
-    [gcd, lcm]
+    [gcd(other), lcm(other)]
   end
 
   def integer?
@@ -631,7 +631,7 @@ class Number < Numeric
         }
 
         var f = Math.pow(10, ndigits),
-            x = Math.floor((Math.abs(x) + f / 2) / f) * f;
+            x = Math.floor((Math.abs(self) + f / 2) / f) * f;
 
         return self < 0 ? -x : x;
       }
@@ -1010,6 +1010,7 @@ Fixnum = Number
 
 class Integer < Numeric
   `self.$$is_number_class = true`
+  `self.$$is_integer_class = true`
 
   class << self
     def allocate
@@ -1018,16 +1019,6 @@ class Integer < Numeric
 
     undef :new
 
-    def ===(other)
-      %x{
-        if (!other.$$is_number) {
-          return false;
-        }
-
-        return (other % 1) === 0;
-      }
-    end
-
     def sqrt(n)
       n = Opal.coerce_to!(n, Integer, :to_int)
       %x{

data/opal/corelib/proc.rb

@@ -1,3 +1,5 @@
+# helpers: slice
+
 class Proc < `Function`
   `Opal.defineProperty(self.$$prototype, '$$is_proc', true)`
   `Opal.defineProperty(self.$$prototype, '$$is_lambda', false)`
@@ -52,6 +54,20 @@ class Proc < `Function`
   alias === call
   alias yield call
 
+  def >>(other)
+    proc do |*args, &block|
+      out = call(*args, &block)
+      other.call(out)
+    end
+  end
+
+  def <<(other)
+    proc do |*args, &block|
+      out = other.call(*args, &block)
+      call(out)
+    end
+  end
+
   def to_proc
     self
   end

data/opal/corelib/random/mersenne_twister.rb

@@ -0,0 +1,147 @@
+# This is based on an adaptation of Makoto Matsumoto and Takuji Nishimura's code
+# done by Sean McCullough <banksean@gmail.com> and Dave Heitzman
+# <daveheitzman@yahoo.com>, subsequently readapted from an updated version of
+# ruby's random.c (rev c38a183032a7826df1adabd8aa0725c713d53e1c).
+#
+# The original copyright notice from random.c follows.
+#
+#   This is based on trimmed version of MT19937.  To get the original version,
+#   contact <http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html>.
+#
+#   The original copyright notice follows.
+#
+#      A C-program for MT19937, with initialization improved 2002/2/10.
+#      Coded by Takuji Nishimura and Makoto Matsumoto.
+#      This is a faster version by taking Shawn Cokus's optimization,
+#      Matthe Bellew's simplification, Isaku Wada's real version.
+#
+#      Before using, initialize the state by using init_genrand(mt, seed)
+#      or init_by_array(mt, init_key, key_length).
+#
+#      Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+#      All rights reserved.
+#
+#      Redistribution and use in source and binary forms, with or without
+#      modification, are permitted provided that the following conditions
+#      are met:
+#
+#        1. Redistributions of source code must retain the above copyright
+#           notice, this list of conditions and the following disclaimer.
+#
+#        2. Redistributions in binary form must reproduce the above copyright
+#           notice, this list of conditions and the following disclaimer in the
+#           documentation and/or other materials provided with the distribution.
+#
+#        3. The names of its contributors may not be used to endorse or promote
+#           products derived from this software without specific prior written
+#           permission.
+#
+#      THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#      "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#      LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#      A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+#      CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#      EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#      PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+#      PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+#      LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+#      NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+#      SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+#      Any feedback is very welcome.
+#      http://www.math.keio.ac.jp/matumoto/emt.html
+#      email: matumoto@math.keio.ac.jp
+mersenne_twister = %x{(function() {
+  /* Period parameters */
+  var N = 624;
+  var M = 397;
+  var MATRIX_A = 0x9908b0df;      /* constant vector a */
+  var UMASK = 0x80000000;         /* most significant w-r bits */
+  var LMASK = 0x7fffffff;         /* least significant r bits */
+  var MIXBITS = function(u,v) { return ( ((u) & UMASK) | ((v) & LMASK) ); };
+  var TWIST = function(u,v) { return (MIXBITS((u),(v)) >>> 1) ^ ((v & 0x1) ? MATRIX_A : 0x0); };
+
+  function init(s) {
+    var mt = {left: 0, next: N, state: new Array(N)};
+    init_genrand(mt, s);
+    return mt;
+  }
+
+  /* initializes mt[N] with a seed */
+  function init_genrand(mt, s) {
+    var j, i;
+    mt.state[0] = s >>> 0;
+    for (j=1; j<N; j++) {
+      mt.state[j] = (1812433253 * ((mt.state[j-1] ^ (mt.state[j-1] >> 30) >>> 0)) + j);
+      /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+      /* In the previous versions, MSBs of the seed affect   */
+      /* only MSBs of the array state[].                     */
+      /* 2002/01/09 modified by Makoto Matsumoto             */
+      mt.state[j] &= 0xffffffff;  /* for >32 bit machines */
+    }
+    mt.left = 1;
+    mt.next = N;
+  }
+
+  /* generate N words at one time */
+  function next_state(mt) {
+    var p = 0, _p = mt.state;
+    var j;
+
+    mt.left = N;
+    mt.next = 0;
+
+    for (j=N-M+1; --j; p++)
+      _p[p] = _p[p+(M)] ^ TWIST(_p[p+(0)], _p[p+(1)]);
+
+    for (j=M; --j; p++)
+      _p[p] = _p[p+(M-N)] ^ TWIST(_p[p+(0)], _p[p+(1)]);
+
+    _p[p] = _p[p+(M-N)] ^ TWIST(_p[p+(0)], _p[0]);
+  }
+
+  /* generates a random number on [0,0xffffffff]-interval */
+  function genrand_int32(mt) {
+    /* mt must be initialized */
+    var y;
+
+    if (--mt.left <= 0) next_state(mt);
+    y = mt.state[mt.next++];
+
+    /* Tempering */
+    y ^= (y >>> 11);
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= (y >>> 18);
+
+    return y >>> 0;
+  }
+
+  function int_pair_to_real_exclusive(a, b) {
+    a >>>= 5;
+    b >>>= 6;
+    return(a*67108864.0+b)*(1.0/9007199254740992.0);
+  }
+
+  // generates a random number on [0,1) with 53-bit resolution
+  function genrand_real(mt) {
+    /* mt must be initialized */
+    var a = genrand_int32(mt), b = genrand_int32(mt);
+    return int_pair_to_real_exclusive(a, b);
+  }
+
+  return { genrand_real: genrand_real, init: init };
+})()}
+
+class Random
+  `var MAX_INT = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1`
+
+  MERSENNE_TWISTER_GENERATOR = `{
+    new_seed: function() { return Math.round(Math.random() * MAX_INT); },
+    reseed: function(seed) { return mersenne_twister.init(seed); },
+    rand: function(mt) { return mersenne_twister.genrand_real(mt); }
+  }`
+
+  self.generator = MERSENNE_TWISTER_GENERATOR
+end

data/opal/corelib/range.rb

@@ -16,18 +16,6 @@ class Range
     @excl  = exclude
   end
 
-  def ==(other)
-    %x{
-      if (!other.$$is_range) {
-        return false;
-      }
-
-      return self.excl  === other.excl &&
-             self.begin ==  other.begin &&
-             self.end   ==  other.end;
-    }
-  end
-
   def ===(value)
     include? value
   end
@@ -44,7 +32,7 @@ class Range
   end
 
   def each(&block)
-    return enum_for :each unless block_given?
+    return enum_for(:each) { size } unless block_given?
 
     %x{
       var i, limit;
@@ -93,6 +81,8 @@ class Range
       @end.eql?(other.end)
   end
 
+  alias == eql?
+
   def exclude_end?
     @excl
   end

data/opal/corelib/regexp.rb

@@ -1,3 +1,5 @@
+# helpers: coerce_to
+
 class RegexpError < StandardError; end
 
 class Regexp < `RegExp`
@@ -100,6 +102,8 @@ class Regexp < `RegExp`
         return new RegExp(regexp, options);
       }
     end
+
+    alias compile new
   end
 
   def ==(other)
@@ -162,7 +166,7 @@ class Regexp < `RegExp`
 
       if (pos === undefined) {
         if (string === nil) return #{$~ = nil};
-        var m = self.exec(#{Opal.coerce_to(string, String, :to_str)});
+        var m = self.exec($coerce_to(string, #{String}, 'to_str'));
         if (m) {
           #{$~ = MatchData.new(`self`, `m`)};
           return block === nil ? #{$~} : #{yield $~};
@@ -171,13 +175,13 @@ class Regexp < `RegExp`
         }
       }
 
-      pos = #{Opal.coerce_to(pos, Integer, :to_int)};
+      pos = $coerce_to(pos, #{Integer}, 'to_int');
 
       if (string === nil) {
         return #{$~ = nil};
       }
 
-      string = #{Opal.coerce_to(string, String, :to_str)};
+      string = $coerce_to(string, #{String}, 'to_str');
 
       if (pos < 0) {
         pos += string.length;
@@ -210,16 +214,16 @@ class Regexp < `RegExp`
       }
 
       if (pos === undefined) {
-        return string === nil ? false : self.test(#{Opal.coerce_to(string, String, :to_str)});
+        return string === nil ? false : self.test($coerce_to(string, #{String}, 'to_str'));
       }
 
-      pos = #{Opal.coerce_to(pos, Integer, :to_int)};
+      pos = $coerce_to(pos, #{Integer}, 'to_int');
 
       if (string === nil) {
         return false;
       }
 
-      string = #{Opal.coerce_to(string, String, :to_str)};
+      string = $coerce_to(string, #{String}, 'to_str');
 
       if (pos < 0) {
         pos += string.length;

data/opal/corelib/runtime.js

@@ -1,4 +1,6 @@
-(function(undefined) {
+(function(global_object) {
+  "use strict";
+
   // @note
   //   A few conventions for the documentation of this file:
   //   1. Always use "//" (in contrast with "/**/")
@@ -13,11 +15,12 @@
   //   The way the code is digested before going through Yardoc is a secret kept
   //   in the docs repo (https://github.com/opal/docs/tree/master).
 
-  var global_object = this, console;
+  var console;
 
   // Detect the global object
-  if (typeof(global) !== 'undefined') { global_object = global; }
-  if (typeof(window) !== 'undefined') { global_object = window; }
+  if (typeof(globalThis) !== 'undefined') { global_object = globalThis; }
+  else if (typeof(global) !== 'undefined') { global_object = global; }
+  else if (typeof(window) !== 'undefined') { global_object = window; }
 
   // Setup a dummy console object if missing
   if (typeof(global_object.console) === 'object') {
@@ -31,9 +34,9 @@
   if (!('log' in console)) { console.log = function () {}; }
   if (!('warn' in console)) { console.warn = console.log; }
 
-  if (typeof(this.Opal) !== 'undefined') {
+  if (typeof(global_object.Opal) !== 'undefined') {
     console.warn('Opal already loaded. Loading twice can cause troubles, please fix your setup.');
-    return this.Opal;
+    return global_object.Opal;
   }
 
   var nil;
@@ -52,13 +55,13 @@
   var Class;
 
   // The Opal object that is exposed globally
-  var Opal = this.Opal = {};
+  var Opal = global_object.Opal = {};
 
   // This is a useful reference to global object inside ruby files
   Opal.global = global_object;
   global_object.Opal = Opal;
 
-  // Configure runtime behavior with regards to require and unsupported fearures
+  // Configure runtime behavior with regards to require and unsupported features
   Opal.config = {
     missing_require_severity: 'error',        // error, warning, ignore
     unsupported_features_severity: 'warning', // error, warning, ignore
@@ -66,11 +69,11 @@
   };
 
   // Minify common function calls
-  var $hasOwn       = Object.hasOwnProperty;
-  var $bind         = Function.prototype.bind;
-  var $setPrototype = Object.setPrototypeOf;
-  var $slice        = Array.prototype.slice;
-  var $splice       = Array.prototype.splice;
+  var $has_own   = Object.hasOwnProperty;
+  var $bind      = Function.prototype.bind;
+  var $set_proto = Object.setPrototypeOf;
+  var $slice     = Array.prototype.slice;
+  var $splice    = Array.prototype.splice;
 
   // Nil object id is always 4
   var nil_id = 4;
@@ -135,7 +138,7 @@
       // String class is the only class that:
       // + compiles to JS primitive
       // + allows method definition directly on instances
-      // numbers, true, false and nil do not support it.
+      // numbers, true, false and null do not support it.
       object[name] = initialValue;
     } else {
       Object.defineProperty(object, name, {
@@ -152,7 +155,7 @@
   Opal.slice = $slice;
 
 
-  // Truth
+  // Helpers
   // -----
 
   Opal.truthy = function(val) {
@@ -163,6 +166,49 @@
     return (val === nil || val == null || (val.$$is_boolean && val == false))
   };
 
+  Opal.type_error = function(object, type, method, coerced) {
+    object = object.$$class;
+
+    if (coerced && method) {
+      coerced = coerced.$$class;
+      return Opal.TypeError.$new(
+        "can't convert " + object + " into " + type +
+        " (" + object + "#" + method + " gives " + coerced + ")"
+      )
+    } else {
+      return Opal.TypeError.$new(
+        "no implicit conversion of " + object + " into " + type
+      )
+    }
+  };
+
+  Opal.coerce_to = function(object, type, method, args) {
+    if (type['$==='](object)) return object;
+
+    if (!object['$respond_to?'](method)) {
+      throw Opal.type_error(object, type);
+    }
+
+    if (args == null) args = [];
+    return Opal.send(object, method, args);
+  }
+
+  Opal.respond_to = function(obj, jsid, include_all) {
+    if (obj == null || !obj.$$class) return false;
+    include_all = !!include_all;
+    var body = obj[jsid];
+
+    if (obj['$respond_to?'].$$pristine) {
+      if (obj['$respond_to_missing?'].$$pristine) {
+        return typeof(body) === "function" && !body.$$stub;
+      } else {
+        return Opal.send(obj, obj['$respond_to_missing?'], [jsid.substr(1), include_all]);
+      }
+    } else {
+      return Opal.send(obj, obj['$respond_to?'], [jsid.substr(1), include_all]);
+    }
+  }
+
 
   // Constants
   // ---------
@@ -183,7 +229,7 @@
 
   // Walk up the nesting array looking for the constant
   function const_lookup_nesting(nesting, name) {
-    var i, ii, result, constant;
+    var i, ii, constant;
 
     if (nesting.length === 0) return;
 
@@ -197,14 +243,14 @@
 
   // Walk up the ancestors chain looking for the constant
   function const_lookup_ancestors(cref, name) {
-    var i, ii, result, ancestors;
+    var i, ii, ancestors;
 
     if (cref == null) return;
 
     ancestors = Opal.ancestors(cref);
 
     for (i = 0, ii = ancestors.length; i < ii; i++) {
-      if (ancestors[i].$$const && $hasOwn.call(ancestors[i].$$const, name)) {
+      if (ancestors[i].$$const && $has_own.call(ancestors[i].$$const, name)) {
         return ancestors[i].$$const[name];
       }
     }
@@ -333,7 +379,7 @@
   Opal.constants = function(cref, inherit) {
     if (inherit == null) inherit = true;
 
-    var module, modules = [cref], module_constants, i, ii, constants = {}, constant;
+    var module, modules = [cref], i, ii, constants = {}, constant;
 
     if (inherit) modules = modules.concat(Opal.ancestors(cref));
     if (inherit && cref.$$is_module) modules = modules.concat([Opal.Object]).concat(Opal.ancestors(Opal.Object));
@@ -341,7 +387,7 @@
     for (i = 0, ii = modules.length; i < ii; i++) {
       module = modules[i];
 
-      // Don not show Objects constants unless we're querying Object itself
+      // Do not show Objects constants unless we're querying Object itself
       if (cref !== _Object && module == _Object) break;
 
       for (constant in module.$$const) {
@@ -370,6 +416,10 @@
     throw Opal.NameError.$new("constant "+cref+"::"+cref.$name()+" not defined");
   };
 
+  // Setup some shortcuts to reduce compiled size
+  Opal.$$ = Opal.const_get_relative;
+  Opal.$$$ = Opal.const_get_qualified;
+
 
   // Modules & Classes
   // -----------------
@@ -410,7 +460,7 @@
             self = new ($bind.apply(superclass.$$constructor, [null].concat(args)))();
 
         // and replacing a __proto__ manually
-        $setPrototype(self, klass.$$prototype);
+        $set_proto(self, klass.$$prototype);
         return self;
       }
     } else {
@@ -443,11 +493,11 @@
     // Later singleton methods generate a singleton_class
     // and inject it into ancestors chain
     if (Opal.Class) {
-      $setPrototype(klass, Opal.Class.prototype);
+      $set_proto(klass, Opal.Class.prototype);
     }
 
     if (superclass != null) {
-      $setPrototype(klass.$$prototype, superclass.$$prototype);
+      $set_proto(klass.$$prototype, superclass.$$prototype);
 
       if (superclass.$$meta) {
         // If superclass has metaclass then we have explicitely inherit it.
@@ -572,7 +622,7 @@
     $defineProperty(module, '$$ancestors', [module]);
     $defineProperty(module, '$$ancestors_cache_version', null);
 
-    $setPrototype(module, Opal.Module.prototype);
+    $set_proto(module, Opal.Module.prototype);
 
     return module;
   };
@@ -633,7 +683,7 @@
     if (object.hasOwnProperty('$$is_class')) {
       return Opal.build_class_singleton_class(object);
     } else if (object.hasOwnProperty('$$is_module')) {
-      return Opal.build_module_singletin_class(object);
+      return Opal.build_module_singleton_class(object);
     } else {
       return Opal.build_object_singleton_class(object);
     }
@@ -665,14 +715,14 @@
     $defineProperty(meta, '$$is_singleton', true);
     $defineProperty(meta, '$$singleton_of', klass);
     $defineProperty(klass, '$$meta', meta);
-    $setPrototype(klass, meta.$$prototype);
+    $set_proto(klass, meta.$$prototype);
     // Restoring ClassName.class
     $defineProperty(klass, '$$class', Opal.Class);
 
     return meta;
   };
 
-  Opal.build_module_singletin_class = function(mod) {
+  Opal.build_module_singleton_class = function(mod) {
     if (mod.$$meta) {
       return mod.$$meta;
     }
@@ -682,7 +732,7 @@
     $defineProperty(meta, '$$is_singleton', true);
     $defineProperty(meta, '$$singleton_of', mod);
     $defineProperty(mod, '$$meta', meta);
-    $setPrototype(mod, meta.$$prototype);
+    $set_proto(mod, meta.$$prototype);
     // Restoring ModuleName.class
     $defineProperty(mod, '$$class', Opal.Module);
 
@@ -704,7 +754,7 @@
 
     $defineProperty(object, '$$meta', klass);
 
-    $setPrototype(object, object.$$meta.$$prototype);
+    $set_proto(object, object.$$meta.$$prototype);
 
     return klass;
   };
@@ -823,7 +873,7 @@
     for (i = length - 2; i >= 0; i--) {
       var ancestor = ancestors[i];
 
-      if ($hasOwn.call(ancestor.$$cvars, name)) {
+      if ($has_own.call(ancestor.$$cvars, name)) {
         ancestor.$$cvars[name] = value;
         return value;
       }
@@ -969,8 +1019,8 @@
       end_chain_on = next_ancestor;
     }
 
-    $setPrototype(start_chain_after, chain.first);
-    $setPrototype(chain.last, end_chain_on);
+    $set_proto(start_chain_after, chain.first);
+    $set_proto(chain.last, end_chain_on);
 
     // recalculate own_included_modules cache
     includer.$$own_included_modules = own_included_modules(includer);
@@ -1029,8 +1079,8 @@
       //   dummy(prepender) -> previous_parent
       // to
       //   dummy(prepender) -> iclass(prepender) -> previous_parent
-      $setPrototype(dummy_prepender, prepender_iclass);
-      $setPrototype(prepender_iclass, previous_parent);
+      $set_proto(dummy_prepender, prepender_iclass);
+      $set_proto(prepender_iclass, previous_parent);
     }
 
     var prepender_ancestors = Opal.ancestors(prepender);
@@ -1057,8 +1107,8 @@
       throw Opal.RuntimeError.$new("Prepending a module multiple times is not supported");
     }
 
-    $setPrototype(start_chain_after, chain.first);
-    $setPrototype(chain.last, end_chain_on);
+    $set_proto(start_chain_after, chain.first);
+    $set_proto(chain.last, end_chain_on);
 
     // recalculate own_prepended_modules cache
     prepender.$$own_prepended_modules = own_prepended_modules(prepender);
@@ -1124,7 +1174,7 @@
 
     for (var i = 1; i < length; i++) {
       var current = iclasses[i];
-      $setPrototype(previous, current);
+      $set_proto(previous, current);
       previous = current;
     }
 
@@ -1154,12 +1204,6 @@
       throw Opal.ArgumentError.$new("already bridged");
     }
 
-    var klass_to_inject, klass_reference;
-
-    klass_to_inject = klass.$$super || Opal.Object;
-    klass_reference = klass;
-    var original_prototype = klass.$$prototype;
-
     // constructor is a JS function with a prototype chain like:
     // - constructor
     //   - super
@@ -1176,7 +1220,7 @@
     //           - null
     //
     $defineProperty(native_klass, '$$bridge', klass);
-    $setPrototype(native_klass.prototype, (klass.$$super || Opal.Object).$$prototype);
+    $set_proto(native_klass.prototype, (klass.$$super || Opal.Object).$$prototype);
     $defineProperty(klass, '$$prototype', native_klass.prototype);
 
     $defineProperty(klass.$$prototype, '$$class', klass);
@@ -1296,7 +1340,10 @@
   // @param method_name [String] The js-name of the method to stub (e.g. "$foo")
   // @return [undefined]
   Opal.stub_for = function(method_name) {
+
     function method_missing_stub() {
+      /* jshint validthis: true */
+
       // Copy any given block onto the method_missing dispatcher
       this.$method_missing.$$p = method_missing_stub.$$p;
 
@@ -1352,7 +1399,7 @@
   };
 
   // Super dispatcher
-  Opal.find_super_dispatcher = function(obj, mid, current_func, defcheck, defs) {
+  Opal.find_super_dispatcher = function(obj, mid, current_func, defcheck, allow_stubs) {
     var jsid = '$' + mid, ancestors, super_method;
 
     if (obj.hasOwnProperty('$$meta')) {
@@ -1372,21 +1419,17 @@
       }
 
       if (proto.hasOwnProperty(jsid)) {
-        var method = proto[jsid];
-
-        if (!method.$$stub) {
-          super_method = method;
-        }
+        super_method = proto[jsid];
         break;
       }
     }
 
-    if (!defcheck && super_method == null && Opal.Kernel.$method_missing === obj.$method_missing) {
+    if (!defcheck && super_method && super_method.$$stub && obj.$method_missing.$$pristine) {
       // method_missing hasn't been explicitly defined
       throw Opal.NoMethodError.$new('super: no superclass method `'+mid+"' for "+obj, mid);
     }
 
-    return super_method;
+    return (super_method.$$stub && !allow_stubs) ? null : super_method;
   };
 
   // Iter dispatcher for super in a block
@@ -1505,7 +1548,7 @@
     }
 
     if (object.$$is_number && klass.$$is_number_class) {
-      return true;
+      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));
@@ -1601,7 +1644,7 @@
   //
   Opal.extract_kwargs = function(parameters) {
     var kwargs = parameters[parameters.length - 1];
-    if (kwargs != null && kwargs['$respond_to?']('to_hash', true)) {
+    if (kwargs != null && Opal.respond_to(kwargs, '$to_hash', true)) {
       $splice.call(parameters, parameters.length - 1, 1);
       return kwargs.$to_hash();
     }
@@ -1662,16 +1705,28 @@
   // @param block [Function] ruby block
   // @return [Object] returning value of the method call
   Opal.send = function(recv, method, args, block) {
-    var body = (typeof(method) === 'string') ? recv['$'+method] : method;
+    var body;
 
-    if (body != null) {
-      if (typeof block === 'function') {
-        body.$$p = block;
-      }
-      return body.apply(recv, args);
+    if (typeof(method) === 'function') {
+      body = method;
+      method = null;
+    } else if (typeof(method) === 'string') {
+      body = recv['$'+method];
+    } else {
+      throw Opal.NameError.$new("Passed method should be a string or a function");
     }
 
-    return recv.$method_missing.apply(recv, [method].concat(args));
+    return Opal.send2(recv, body, method, args, block);
+  };
+
+  Opal.send2 = function(recv, body, method, args, block) {
+    if (body == null && method != null && recv.$method_missing) {
+      body = recv.$method_missing;
+      args = [method].concat(args);
+    }
+
+    if (typeof block === 'function') body.$$p = block;
+    return body.apply(recv, args);
   };
 
   Opal.lambda = function(block) {
@@ -1771,7 +1826,7 @@
 
   // Called from #remove_method.
   Opal.rdef = function(obj, jsid) {
-    if (!$hasOwn.call(obj.$$prototype, jsid)) {
+    if (!$has_own.call(obj.$$prototype, jsid)) {
       throw Opal.NameError.$new("method '" + jsid.substr(1) + "' not defined in " + obj.$name());
     }
 
@@ -1847,7 +1902,7 @@
     if (body.$$alias_of) body = body.$$alias_of;
 
     // We need a wrapper because otherwise properties
-    // would be ovrewritten on the original body.
+    // would be overwritten on the original body.
     alias = function() {
       var block = alias.$$p, args, i, ii;
 
@@ -1861,9 +1916,17 @@
       return Opal.send(this, body, args, block);
     };
 
+    // Assign the 'length' value with defineProperty because
+    // in strict mode the property is not writable.
+    // It doesn't work in older browsers (like Chrome 38), where
+    // an exception is thrown breaking Opal altogether.
+    try {
+      Object.defineProperty(alias, 'length', { value: body.length });
+    } catch (e) {}
+
     // Try to make the browser pick the right name
     alias.displayName       = name;
-    alias.length            = body.length;
+
     alias.$$arity           = body.$$arity;
     alias.$$parameters      = body.$$parameters;
     alias.$$source_location = body.$$source_location;
@@ -1918,7 +1981,7 @@
 
   Opal.hash_put = function(hash, key, value) {
     if (key.$$is_string) {
-      if (!$hasOwn.call(hash.$$smap, key)) {
+      if (!$has_own.call(hash.$$smap, key)) {
         hash.$$keys.push(key);
       }
       hash.$$smap[key] = value;
@@ -1928,7 +1991,7 @@
     var key_hash, bucket, last_bucket;
     key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
 
-    if (!$hasOwn.call(hash.$$map, key_hash)) {
+    if (!$has_own.call(hash.$$map, key_hash)) {
       bucket = {key: key, key_hash: key_hash, value: value};
       hash.$$keys.push(bucket);
       hash.$$map[key_hash] = bucket;
@@ -1956,7 +2019,7 @@
 
   Opal.hash_get = function(hash, key) {
     if (key.$$is_string) {
-      if ($hasOwn.call(hash.$$smap, key)) {
+      if ($has_own.call(hash.$$smap, key)) {
         return hash.$$smap[key];
       }
       return;
@@ -1965,7 +2028,7 @@
     var key_hash, bucket;
     key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
 
-    if ($hasOwn.call(hash.$$map, key_hash)) {
+    if ($has_own.call(hash.$$map, key_hash)) {
       bucket = hash.$$map[key_hash];
 
       while (bucket) {
@@ -1981,7 +2044,9 @@
     var i, keys = hash.$$keys, length = keys.length, value;
 
     if (key.$$is_string) {
-      if (!$hasOwn.call(hash.$$smap, key)) {
+      if (typeof key !== "string") key = key.valueOf();
+
+      if (!$has_own.call(hash.$$smap, key)) {
         return;
       }
 
@@ -1999,7 +2064,7 @@
 
     var key_hash = key.$hash();
 
-    if (!$hasOwn.call(hash.$$map, key_hash)) {
+    if (!$has_own.call(hash.$$map, key_hash)) {
       return;
     }
 
@@ -2074,7 +2139,7 @@
 
       hash.$$keys[i].key_hash = key_hash;
 
-      if (!$hasOwn.call(hash.$$map, key_hash)) {
+      if (!$has_own.call(hash.$$map, key_hash)) {
         hash.$$map[key_hash] = hash.$$keys[i];
         continue;
       }
@@ -2128,7 +2193,7 @@
     if (arguments_length === 1) {
       args = arguments[0];
       for (key in args) {
-        if ($hasOwn.call(args, key)) {
+        if ($has_own.call(args, key)) {
           value = args[key];
 
           Opal.hash_put(hash, key, value);
@@ -2257,6 +2322,33 @@
     return result;
   };
 
+  // Combine multiple regexp parts together
+  Opal.regexp = function(parts, flags) {
+    var part;
+    var ignoreCase = typeof flags !== 'undefined' && flags && flags.indexOf('i') >= 0;
+
+    for (var i = 0, ii = parts.length; i < ii; i++) {
+      part = parts[i];
+      if (part instanceof RegExp) {
+        if (part.ignoreCase !== ignoreCase)
+          Opal.Kernel.$warn(
+            "ignore case doesn't match for " + part.source.$inspect(),
+            Opal.hash({uplevel: 1})
+          )
+
+        part = part.source;
+      }
+      if (part === '') part = '(?:' + part + ')';
+      parts[i] = part;
+    }
+
+    if (flags) {
+      return new RegExp(parts.join(''), flags);
+    } else {
+      return new RegExp(parts.join(''));
+    }
+  };
+
   // Require system
   // --------------
 
@@ -2340,6 +2432,37 @@
   };
 
 
+  // Strings
+  // -------
+
+  Opal.encodings = Object.create(null);
+
+  // Sets the encoding on a string, will treat string literals as frozen strings
+  // raising a FrozenError.
+  // @param str [String] the string on which the encoding should be set.
+  // @param name [String] the canonical name of the encoding
+  Opal.set_encoding = function(str, name) {
+    if (typeof str === 'string')
+      throw Opal.FrozenError.$new("can't modify frozen String");
+
+    var encoding = Opal.encodings[name];
+
+    if (encoding === str.encoding) { return str; }
+
+    str.encoding = encoding;
+
+    return str;
+  };
+
+  // @returns a String object with the encoding set from a string literal
+  Opal.enc = function(str, name) {
+    var dup = new String(str);
+    Opal.set_encoding(dup, name);
+    dup.internal_encoding = dup.encoding;
+    return dup
+  }
+
+
   // Initialization
   // --------------
   function $BasicObject() {}
@@ -2352,10 +2475,10 @@
   Opal.Module      = Module      = Opal.allocate_class('Module', Opal.Object, $Module);
   Opal.Class       = Class       = Opal.allocate_class('Class', Opal.Module, $Class);
 
-  $setPrototype(Opal.BasicObject, Opal.Class.$$prototype);
-  $setPrototype(Opal.Object, Opal.Class.$$prototype);
-  $setPrototype(Opal.Module, Opal.Class.$$prototype);
-  $setPrototype(Opal.Class, Opal.Class.$$prototype);
+  $set_proto(Opal.BasicObject, Opal.Class.$$prototype);
+  $set_proto(Opal.Object, Opal.Class.$$prototype);
+  $set_proto(Opal.Module, Opal.Class.$$prototype);
+  $set_proto(Opal.Class, Opal.Class.$$prototype);
 
   // BasicObject can reach itself, avoid const_set to skip the $$base_module logic
   BasicObject.$$const["BasicObject"] = BasicObject;
@@ -2387,14 +2510,18 @@
   // other corelib files.
   $defineProperty(_Object.$$prototype, '$require', Opal.require);
 
-  // Add a short helper to navigate constants manually.
-  // @example
-  //   Opal.$$.Regexp.$$.IGNORECASE
-  Opal.$$ = _Object.$$;
-
   // Instantiate the main object
   Opal.top = new _Object();
   Opal.top.$to_s = Opal.top.$inspect = function() { return 'main' };
+  Opal.top.$define_method = top_define_method;
+
+  // Foward calls to define_method on the top object to Object
+  function top_define_method() {
+    var args = Opal.slice.call(arguments, 0, arguments.length);
+    var block = top_define_method.$$p;
+    top_define_method.$$p = null;
+    return Opal.send(_Object, 'define_method', args, block)
+  };
 
 
   // Nil