opal 0.3.18 → 0.3.19

data/core/regexp.rb

@@ -1,4 +1,4 @@
-class Regexp
+class Regexp < `RegExp`
   def self.escape(string)
     `string.replace(/([.*+?^=!:${}()|[\]\\/\\])/g, '\\$1')`
   end
@@ -20,7 +20,7 @@ class Regexp
       var result = this.exec(string);
 
       if (result) {
-        var match       = new RubyMatch._alloc();
+        var match       = new #{MatchData}._alloc();
             match.$data = result;
 
         #{$~ = `match`};
@@ -44,7 +44,7 @@ class Regexp
       var result  = this.exec(pattern);
 
       if (result) {
-        var match   = new RubyMatch._alloc();
+        var match   = new #{MatchData}._alloc();
         match.$data = result;
 
         return #{$~ = `match`};

data/core/runtime.js

@@ -1,243 +1,134 @@
-var Opal = this.Opal = {};
+// Top level Object scope (used by object and top_self).
+var top_const_alloc     = function(){};
+var top_const_scope     = top_const_alloc.prototype;
+top_const_scope.alloc   = top_const_alloc; 
+
+var Opal = this.Opal = top_const_scope;
 
 Opal.global = this;
 
 // Minify common function calls
-var __hasOwn = Object.prototype.hasOwnProperty,
-    __slice  = Array.prototype.slice;
-
-// Types - also added to bridged objects
-var T_CLASS      = 0x0001,
-    T_MODULE     = 0x0002,
-    T_OBJECT     = 0x0004,
-    T_BOOLEAN    = 0x0008,
-    T_STRING     = 0x0010,
-    T_ARRAY      = 0x0020,
-    T_NUMBER     = 0x0040,
-    T_PROC       = 0x0080,
-    T_HASH       = 0x0100,
-    T_RANGE      = 0x0200,
-    T_ICLASS     = 0x0400,
-    FL_SINGLETON = 0x0800;
+var __hasOwn = Object.prototype.hasOwnProperty;
+var __slice  = Opal.slice = Array.prototype.slice;
 
 // Generates unique id for every ruby object
 var unique_id = 0;
 
-// Jump return - return in proc body
-Opal.jump = function(value, func) {
-  throw new Error('jump return');
-};
-
-// Get constant with given id
-Opal.const_get = function(const_table, id) {
-  if (const_table[id]) {
-    return const_table[id];
-  }
-
-  throw RubyNameError.$new('uninitialized constant ' + id);
-};
-
 // Table holds all class variables
 Opal.cvars = {};
 
 // Globals table
 Opal.gvars = {};
 
-// Define a method alias
-Opal.alias = function(klass, new_name, old_name) {
-  new_name = mid_to_jsid(new_name);
-  old_name = mid_to_jsid(old_name);
-
-  var body = klass._proto[old_name];
-
-  if (!body) {
-    // throw RubyNameError.$new(null, "undefined method `" + old_name + "' for class `" + klass._name + "'");
-    throw new Error("undefined method `" + old_name + "' for class `" + klass._name + "'");
+Opal.klass = function(base, superklass, id, body) {
+  var klass;
+  if (base._isObject) {
+    base = base._real;
   }
 
-  define_method(klass, new_name, body);
-  return null;
-};
-
-// Actually define methods
-var define_method = Opal.defn = function(klass, id, body) {
-  // If an object, make sure to use its class
-  if (klass._flags & T_OBJECT) {
-    klass = klass._klass;
+  if (superklass === null) {
+    superklass = RubyObject;
   }
 
-  klass._alloc.prototype[id] = body;
-
-  var included_in = klass.$included_in, includee;
-
-  if (included_in) {
-    for (var i = 0, ii = included_in.length; i < ii; i++) {
-      includee = included_in[i];
-
-      define_method(includee, id, body);
-    }
+  if (__hasOwn.call(base._scope, id)) {
+    klass = base._scope[id];
   }
-
-  if (klass._bridge) {
-    klass._bridge[id] = body;
+  else if (!superklass._klass || !superklass._proto) {
+    klass = bridge_class(superklass, id);
   }
-
-
-  return null;
-}
-
-function define_module(base, id) {
-  var module;
-
-  module             = boot_module();
-  module._name = (base === RubyObject ? id : base._name + '::' + id)
-
-  make_metaclass(module, RubyModule);
-
-  module._flags           = T_MODULE;
-  module.$included_in = [];
-
-  var const_alloc   = function() {};
-  var const_scope   = const_alloc.prototype = new base._scope.alloc();
-  module._scope     = const_scope;
-  const_scope.alloc = const_alloc;
-
-  base._scope[id]    = module;
-
-  return module;
-}
-
-// Opal define class. 0: regular, 1: module, 2: shift class.
-Opal.klass = function(base, superklass, id, body, type) {
-  var klass;
-
-  switch (type) {
-    case 0:
-      if (base._flags & T_OBJECT) {
-        base = class_real(base._klass);
-      }
-
-      if (superklass === null) {
-        superklass = RubyObject;
-      }
-
-      if (__hasOwn.call(base._scope, id)) {
-        klass = base._scope[id];
-      }
-      else {
-        klass = define_class(base, id, superklass);
-      }
-
-      break;
-
-    case 1:
-      if (base._flags & T_OBJECT) {
-        base = class_real(base._klass);
-      }
-
-      if (__hasOwn.call(base._scope, id)) {
-        klass = base._scope[id];
-      }
-      else {
-        klass = define_module(base, id);
-      }
-
-      break;
-
-    case 2:
-      klass = base.$singleton_class();
-      break;
+  else {
+    klass = define_class(base, id, superklass);
   }
 
   return body.call(klass);
 };
 
-Opal.slice = __slice;
-
-Opal.defs = function(base, id, body) {
-  return define_method(base.$singleton_class(), id, body);
-};
-
-// Undefine one or more methods
-Opal.undef = function(klass) {
-  var args = __slice.call(arguments, 1);
-
-  for (var i = 0, length = args.length; i < length; i++) {
-    var mid = args[i], id = mid_to_jsid[mid];
+Opal.sklass = function(shift, body) {
+  var klass = shift.$singleton_class();
+  return body.call(klass);
+}
 
-    delete klass._proto[id];
+Opal.module = function(base, id, body) {
+  var klass;
+  if (base._isObject) {
+    base = base._real;
   }
-};
 
-// Calls a super method.
-Opal.zuper = function(callee, jsid, self, args) {
-  var func = find_super(self._klass, callee, jsid);
-
-  if (!func) {
-    throw RubyNoMethodError.$new(null, "super: no superclass method `" +
-            jsid_to_mid(jsid) + "'" + " for " + self.$inspect());
+  if (__hasOwn.call(base._scope, id)) {
+    klass = base._scope[id];
   }
+  else {
+    klass = boot_module();
+    klass._name = (base === RubyObject ? id : base._name + '::' + id);
 
-  return func.apply(self, args);
-};
+    make_metaclass(klass, RubyModule);
 
-// dynamic super (inside block)
-Opal.dsuper = function(scopes, defn, jsid, self, args) {
-  var method, scope = scopes[0];
+    klass._isModule = true;
+    klass.$included_in = [];
 
-  for (var i = 0, length = scopes.length; i < length; i++) {
-    if (scope.o$jsid) {
-      jsid = scope.o$jsid;
-      method = scope;
-      break;
-    }
-  }
+    var const_alloc   = function() {};
+    var const_scope   = const_alloc.prototype = new base._scope.alloc();
+    klass._scope      = const_scope;
+    const_scope.alloc = const_alloc;
 
-  if (method) {
-    // one of the nested blocks was define_method'd
-    return Opal.zuper(method, jsid, self, args);
-  }
-  else if (defn) {
-    // blocks not define_method'd, but they were enclosed by a real method
-    return Opal.zuper(defn, jsid, self, args);
+    base._scope[id]    = klass;
   }
 
-  // if we get here then we were inside a nest of just blocks, and none have
-  // been defined as a method
-  throw RubyNoMethodError.$new(null, "super: cannot call super when not in method");
+  return body.call(klass);
 }
 
-// Find function body for the super call
-function find_super(klass, callee, mid) {
-  var cur_method;
-
-  while (klass) {
-    if (klass._proto.hasOwnProperty(mid)) {
-      if (klass._proto[mid] === callee) {
-        cur_method = klass._proto[mid];
-        break;
-      }
-    }
-    klass = klass._super;
+/**
+  This function serves two purposes. The first is to allow methods
+  defined in modules to be included into classes that have included
+  them. This is done at the end of a module body by calling this
+  method will all the defined methods. They are then passed onto
+  the includee classes.
+
+  The second purpose is to store an array of all the methods defined
+  directly in this class or module. This makes features such as
+  #methods and #instance_methods work. It is also used internally to
+  create subclasses of Arrays, as an annoyance with javascript is that
+  arrays cannot be subclassed (or they can't without problems arrising
+  with tracking the array length). Therefore, when a new instance of a
+  subclass is created, behind the scenes we copy all the methods from
+  the subclass onto an array prototype.
+
+  If the includee is also included into other modules or classes, then
+  this method will also set up donations for that module. If this is
+  the case, then 'indirect' will be set to true as we don't want those
+  modules/classes to think they had that method set on themselves. This
+  stops `Object` thinking it defines `#sprintf` when it is actually
+  `Kernel` that defines that method. Indirect is false by default when
+  called by generated code in the compiler output.
+
+  @param [RubyClass] klass the class or module that defined methods
+  @param [Array<String>] methods an array of jsid method names defined
+  @param [Boolean] indirect whether this is an indirect method define
+*/
+Opal.donate = function(klass, methods, indirect) {
+  var included_in = klass.$included_in, includee, method,
+      table = klass._proto, dest;
+
+  if (!indirect) {
+    klass._methods = klass._methods.concat(methods);
   }
 
-  if (!(klass && cur_method)) { return null; }
+  if (included_in) {
+    for (var i = 0, length = included_in.length; i < length; i++) {
+      includee = included_in[i];
+      dest = includee._proto;
 
-  klass = klass._super;
+      for (var j = 0, jj = methods.length; j < jj; j++) {
+        method = methods[j];
+          dest[method] = table[method];
+      }
 
-  while (klass) {
-    if (klass._proto.hasOwnProperty(mid)) {
-      // make sure our found method isnt the same - this can happen if this
-      // newly found method is from a module and we are now looking at the
-      // module it came from.
-      if (klass._proto[mid] !== callee) {
-        return klass._proto[mid];
+      if (includee.$included_in) {
+        Opal.donate(includee, methods, true);
       }
     }
-
-    klass = klass._super;
   }
-}
+};
 
 var mid_to_jsid = Opal.mid_to_jsid = function(mid) {
   if (method_names[mid]) {
@@ -245,7 +136,7 @@ var mid_to_jsid = Opal.mid_to_jsid = function(mid) {
   }
 
   return '$' + mid.replace('!', '$b').replace('?', '$p').replace('=', '$e');
-}
+};
 
 var jsid_to_mid = Opal.jsid_to_mid = function(jsid) {
   if (reverse_method_names[jsid]) {
@@ -255,18 +146,16 @@ var jsid_to_mid = Opal.jsid_to_mid = function(jsid) {
   jsid = jsid.substr(1); // remove '$'
 
   return jsid.replace('$b', '!').replace('$p', '?').replace('$e', '=');
-}
+};
 
-Opal.arg_error = function(given, expected) {
-  throw RubyArgError.$new(null, 'wrong number of arguments(' + given + ' for ' + expected + ')');
+var no_block_given = function() {
+  throw new Error('no block given');
 };
 
 // Boot a base class (makes instances).
 function boot_defclass(superklass) {
   var cls = function() {
     this._id = unique_id++;
-
-    return this;
   };
 
   if (superklass) {
@@ -277,7 +166,7 @@ function boot_defclass(superklass) {
   }
 
   cls.prototype.constructor = cls;
-  cls.prototype._flags          = T_OBJECT;
+  cls.prototype._isObject   = true;
 
   return cls;
 }
@@ -286,8 +175,6 @@ function boot_defclass(superklass) {
 function boot_makemeta(id, klass, superklass) {
   var meta = function() {
     this._id = unique_id++;
-
-    return this;
   };
 
   var ctor           = function() {};
@@ -297,16 +184,22 @@ function boot_makemeta(id, klass, superklass) {
 
   var proto              = meta.prototype;
       proto.$included_in = [];
-      proto._alloc   = klass;
-      proto._flags       = T_CLASS;
-      proto._name  = id;
-      proto._super           = superklass;
+      proto._alloc       = klass;
+      proto._isClass     = true;
+      proto._name        = id;
+      proto._super       = superklass;
       proto.constructor  = meta;
+      proto._methods     = [];
+      proto._isObject    = false;
 
   var result = new meta();
   klass.prototype._klass = result;
+  klass.prototype._real  = result;
+
   result._proto = klass.prototype;
 
+  top_const_scope[id] = result;
+
   return result;
 }
 
@@ -315,8 +208,6 @@ function boot_class(superklass) {
   // instances
   var cls = function() {
     this._id = unique_id++;
-
-    return this;
   };
 
   var ctor = function() {};
@@ -326,13 +217,11 @@ function boot_class(superklass) {
 
   var proto             = cls.prototype;
       proto.constructor = cls;
-      proto._flags          = T_OBJECT;
+      proto._isObject   = true;
 
   // class itself
   var meta = function() {
     this._id = unique_id++;
-
-    return this;
   };
 
   var mtor = function() {};
@@ -340,14 +229,16 @@ function boot_class(superklass) {
 
   meta.prototype = new mtor();
 
-  proto                            = meta.prototype;
-  proto._alloc                 = cls;
-  proto._flags                     = T_CLASS;
-  proto.constructor                = meta;
-  proto._super                         = superklass;
+  proto             = meta.prototype;
+  proto._alloc      = cls;
+  proto._isClass    = true;
+  proto.constructor = meta;
+  proto._super      = superklass;
+  proto._methods    = [];
 
   var result = new meta();
   cls.prototype._klass = result;
+  cls.prototype._real  = result;
 
   result._proto = cls.prototype;
 
@@ -363,7 +254,6 @@ function boot_module() {
   // Module itself
   var meta = function() {
     this._id = unique_id++;
-    return this;
   };
 
   var mtor = function(){};
@@ -371,30 +261,23 @@ function boot_module() {
   meta.prototype = new mtor();
 
   var proto = meta.prototype;
-  proto._alloc  = module_cons;
-  proto._flags      = T_MODULE;
+
+  proto._alloc      = module_cons;
+  proto._isModule   = true;
   proto.constructor = meta;
-  proto._super          = null;
+  proto._super      = null;
+  proto._methods    = [];
 
-  var module          = new meta();
-  module._proto       = module_inst;
+  var module        = new meta();
+  module._proto     = module_inst;
 
   return module;
 }
 
-// Get actual class ignoring singleton classes and iclasses.
-function class_real(klass) {
-  while (klass._flags & FL_SINGLETON) {
-    klass = klass._super;
-  }
-
-  return klass;
-}
-
 // Make metaclass for the given class
 function make_metaclass(klass, superklass) {
-  if (klass._flags & T_CLASS) {
-    if ((klass._flags & T_CLASS) && (klass._flags & FL_SINGLETON)) {
+  if (klass._isClass) {
+    if (klass._isSingleton) {
       throw RubyException.$new('too much meta: return klass?');
     }
     else {
@@ -404,8 +287,9 @@ function make_metaclass(klass, superklass) {
       meta._name = class_id;
       meta._alloc.prototype = klass.constructor.prototype;
       meta._proto = meta._alloc.prototype;
-      meta._flags |= FL_SINGLETON;
+      meta._isSingleton = true;
       meta._klass = RubyClass;
+      meta._real  = RubyClass;
 
       klass._klass = meta;
 
@@ -416,30 +300,25 @@ function make_metaclass(klass, superklass) {
     }
   }
   else {
-    return make_singleton_class(klass);
-  }
-}
-
-function make_singleton_class(obj) {
-  var orig_class = obj._klass,
-      class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
-
-  klass             = boot_class(orig_class);
-  klass._name = class_id;
-
-  klass._flags                |= FL_SINGLETON;
-  klass._bridge  = obj;
-
-  obj._klass = klass;
+    var orig_class = klass._klass,
+        class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
 
-  klass.__attached__ = obj;
+    var meta   = boot_class(orig_class);
+    meta._name = class_id;
 
-  klass._klass = class_real(orig_class)._klass;
+    meta._isSingleton = true;
+    meta._proto  = klass;
+    // FIXME: this should be removed. _proto should always point to this.
+    meta._alloc.prototype = klass;
+    klass._klass = meta;
+    meta.__attached__ = klass;
+    meta._klass = orig_class._real._klass
 
-  return klass;
+    return meta;
+  }
 }
 
-function bridge_class(constructor, flags, id) {
+function bridge_class(constructor, id) {
   var klass     = define_class(RubyObject, id, RubyObject),
       prototype = constructor.prototype;
 
@@ -448,20 +327,69 @@ function bridge_class(constructor, flags, id) {
 
   bridged_classes.push(klass);
 
-  prototype._klass = klass;
-  prototype._flags = flags;
+  prototype._klass    = klass;
+  prototype._real     = klass;
+  prototype._isObject = true;
+
+  var allocator = function(initializer) {
+    var result, kls = this, methods = kls._methods, proto = kls._proto;
+
+    if (initializer == null) {
+      result = new constructor
+    }
+    else {
+      result = new constructor(initializer);
+    }
+
+    if (kls === klass) {
+      return result;
+    }
+
+    result._klass = kls;
+    result._real  = kls;
+
+    for (var i = 0, length = methods.length; i < length; i++) {
+      var method = methods[i];
+      result[method] = proto[method];
+    }
+
+    return result;
+  };
+
+  klass.constructor.prototype.$allocate = allocator;
+
+  var donator = RubyObject, table, methods;
+
+  while (donator) {
+    table = donator._proto;
+    methods = donator._methods;
+
+    for (var i = 0, length = methods.length; i < length; i++) {
+      var method = methods[i];
+      prototype[method] = table[method];
+    }
+
+    donator = donator._super;
+  }
 
   return klass;
 }
 
-// Define new ruby class
+/**
+  Actually define a new class with the name `id`. The superklass is
+  required, and Object is currently the root class. The base is the
+  parent scope of this class. For example, defining a root `Foo`
+  class would have `Object` as the parent. Defining `Foo::Bar` would
+  use `Foo` as the parent.
+
+  @param [RubyClass] base the base class/module for this new class
+  @param [String] id the name for this class
+  @param [RubyClass] superklass the super class
+  @return [RubyClass] returns new class with given attributes
+*/
 function define_class(base, id, superklass) {
-  var klass;
-
-  var class_id = (base === RubyObject ? id : base._name + '::' + id);
-
-  klass             = boot_class(superklass);
-  klass._name = class_id;
+  var klass   = boot_class(superklass);
+  klass._name = (base === RubyObject ? id : base._name + '::' + id);
 
   make_metaclass(klass, superklass._klass);
 
@@ -479,66 +407,118 @@ function define_class(base, id, superklass) {
   return klass;
 }
 
+/**
+  An IClass is a fake class created when a module is included into a
+  class or another module. It is a "copy" of the module that is then
+  injected into the hierarchy so it appears internally that the iclass
+  is the super of the class instead of the old super class. This is
+  actually hidden from the ruby side of things, but allows internal
+  features such as super() etc to work. All useful properties from the
+  module are copied onto this iclass.
+
+  @param [RubyClass] klass the klass which is including the module
+  @param [RubyModule] module the module which is being included
+  @return [RubyIClass] returns newly created iclass
+*/
 function define_iclass(klass, module) {
-  var sup = klass._super;
-
-  var iclass = {};
-  iclass._proto = module._proto;
-  iclass._super = sup;
-  iclass._flags = T_ICLASS;
-  iclass._klass = module;
-  iclass._name  = module._name;
+  var iclass = {
+    _proto:     module._proto,
+    _super:     klass._super,
+    _isIClass:  true,
+    _klass:     module,
+    _name:      module._name,
+    _methods:   module._methods
+  };
 
   klass._super = iclass;
 
   return iclass;
 }
 
-// Handling requires
-function require_handler(path) {
-  throw new Error('Cannot require ' + path);
-}
+/**
+  This is a map of all file ids to their bodies. The file id is the
+  id used to require a file, and it does not have an extension name.
+
+  @type { String: Function }
+*/
+var factories = Opal.factories = {};
+
+/**
+  This holds the name of the current file being executed by opal. This
+  gets set in require() below and it allows the file to get the
+  __FILE__ variable. This should never be accessed manually.
+
+  @type {String}
+*/
+Opal.file = "";
+
+/**
+  Register the body for the given file id name. This will then allow
+  the file to be loaded with require().
+
+  @param [String] id the file id
+  @param [Function] body the body representing the file
+*/
+Opal.define = function(id, body) {
+  factories[id] = body;
+};
+
+/**
+  Require a specific file by id.
+
+  @param [String] id file id to require
+  @return [Boolean] if file has already been required
+*/
+Opal.require = function(id) {
+  var body = factories[id];
+
+  if (!body) {
+    throw new Error("No file: '" + id + "'");
+  }
+
+  if (body._loaded) {
+    return false;
+  }
+
+  Opal.file = id;
+
+  body._loaded = true;
+  body.call(Opal.top);
+
+  return true;
+};
 
 // Initialization
 // --------------
 
 // The *instances* of core objects
-var BootObject = boot_defclass();
-var BootModule = boot_defclass(BootObject);
-var BootClass  = boot_defclass(BootModule);
+var BootBasicObject = boot_defclass();
+var BootObject      = boot_defclass(BootBasicObject);
+var BootModule      = boot_defclass(BootObject);
+var BootClass       = boot_defclass(BootModule);
 
 // The *classes' of core objects
-var RubyObject = boot_makemeta('Object', BootObject, BootClass);
-var RubyModule = boot_makemeta('Module', BootModule, RubyObject.constructor);
-var RubyClass = boot_makemeta('Class', BootClass, RubyModule.constructor);
+var RubyBasicObject = boot_makemeta('BasicObject', BootBasicObject, BootClass); 
+var RubyObject      = boot_makemeta('Object', BootObject, RubyBasicObject.constructor);
+var RubyModule      = boot_makemeta('Module', BootModule, RubyObject.constructor);
+var RubyClass       = boot_makemeta('Class', BootClass, RubyModule.constructor);
 
 // Fix boot classes to use meta class
+RubyBasicObject._klass = RubyClass;
 RubyObject._klass = RubyClass;
 RubyModule._klass = RubyClass;
 RubyClass._klass = RubyClass;
 
 // fix superclasses
-RubyObject._super = null;
+RubyBasicObject._super = null;
+RubyObject._super = RubyBasicObject;
 RubyModule._super = RubyObject;
 RubyClass._super = RubyModule;
 
-Opal.Object = RubyObject;
-Opal.Module = RubyModule;
-Opal.Class  = RubyClass;
-
-// Make object act like a module. Internally, `Object` gets included
-// into all the bridged classes. This is because the native prototypes
-// for these bridged classes need to get all the `Object` methods as
-// well. This allows `Object` to just donate its instance methods to
-// the bridged classes using the exact same method that modules use.
 var bridged_classes = RubyObject.$included_in = [];
+RubyBasicObject.$included_in = bridged_classes;
 
-// Top level Object scope (used by object and top_self).
-var top_const_alloc     = function(){};
-var top_const_scope     = top_const_alloc.prototype;
-top_const_scope.alloc   = top_const_alloc; 
-
-RubyObject._scope = Opal.constants = top_const_scope;
+RubyObject._scope = RubyBasicObject._scope = top_const_scope;
 
 var module_const_alloc = function(){};
 var module_const_scope = new top_const_alloc();
@@ -550,64 +530,15 @@ var class_const_scope = new top_const_alloc();
 class_const_scope.alloc = class_const_alloc;
 RubyClass._scope = class_const_scope;
 
-RubyObject._scope.BasicObject = RubyObject;
-RubyObject._scope.Object = RubyObject;
-RubyObject._scope.Module = RubyModule;
-RubyObject._scope.Class = RubyClass;
-
-// Every ruby object (except natives) will have their #to_s method aliased
-// to the native .toString() function so that accessing ruby objects from
-// javascript will return a nicer string format. This is also used when
-// interpolating objects into strings as the js engine will call toString
-// which in turn calls #to_s.
-//
-// This is also used as the hashing function. In ruby, #hash should return
-// an integer. This is not possible in Opal as strings cannot be mutable
-// and can not therefore have unique integer hashes. Seeing as strings or
-// symbols are used more often as hash keys, this role is changed in Opal
-// so that hash values should be strings, and this function makes the #to_s
-// value for an object the default.
 RubyObject._proto.toString = function() {
   return this.$to_s();
 };
 
-var top_self = Opal.top = new RubyObject._alloc();
+Opal.top = new RubyObject._alloc();
 
 var RubyNilClass  = define_class(RubyObject, 'NilClass', RubyObject);
 Opal.nil = new RubyNilClass._alloc();
-
-bridge_class(Array, T_OBJECT | T_ARRAY, 'Array');
-bridge_class(Number, T_OBJECT | T_NUMBER, 'Numeric');
-
-bridge_class(String, T_OBJECT | T_STRING, 'String');
-bridge_class(Boolean, T_OBJECT | T_BOOLEAN, 'Boolean');
-bridge_class(Function, T_OBJECT | T_PROC, 'Proc');
-bridge_class(RegExp, T_OBJECT, 'Regexp');
-
-var RubyMatch     = define_class(RubyObject, 'MatchData', RubyObject);
-var RubyRange     = define_class(RubyObject, 'Range', RubyObject);
-RubyRange._proto._flags = T_OBJECT | T_RANGE;
-
-var RubyException      = bridge_class(Error, T_OBJECT, 'Exception');
-var RubyStandardError  = define_class(RubyObject, 'StandardError', RubyException);
-var RubyRuntimeError   = define_class(RubyObject, 'RuntimeError', RubyException);
-var RubyLocalJumpError = define_class(RubyObject, 'LocalJumpError', RubyStandardError);
-var RubyTypeError      = define_class(RubyObject, 'TypeError', RubyStandardError);
-var RubyNameError      = define_class(RubyObject, 'NameError', RubyStandardError);
-var RubyNoMethodError  = define_class(RubyObject, 'NoMethodError', RubyNameError);
-var RubyArgError       = define_class(RubyObject, 'ArgumentError', RubyStandardError);
-var RubyScriptError    = define_class(RubyObject, 'ScriptError', RubyException);
-var RubyLoadError      = define_class(RubyObject, 'LoadError', RubyScriptError);
-var RubyIndexError     = define_class(RubyObject, 'IndexError', RubyStandardError);
-var RubyKeyError       = define_class(RubyObject, 'KeyError', RubyIndexError);
-var RubyRangeError     = define_class(RubyObject, 'RangeError', RubyStandardError);
-var RubyNotImplError   = define_class(RubyObject, 'NotImplementedError', RubyException);
-
-RubyException._alloc.prototype.toString = function() {
-  return this._klass._name + ': ' + this.message;
-};
+Opal.nil.call = Opal.nil.apply = no_block_given;
 
 var breaker = Opal.breaker  = new Error('unexpected break');
-    breaker._klass              = RubyLocalJumpError;
     breaker.$t              = function() { throw this; };
-