opal 0.3.16 → 0.3.17

data/core/runtime.js

@@ -1,9 +1,10 @@
-var opal = this.opal = {};
-opal.global = this;
+var Opal = this.Opal = {};
+
+Opal.global = this;
 
 // Minify common function calls
-var hasOwnProperty  = Object.prototype.hasOwnProperty,
-    $slice          = Array.prototype.slice;
+var __hasOwn = Object.prototype.hasOwnProperty,
+    __slice  = Array.prototype.slice;
 
 // Types - also added to bridged objects
 var T_CLASS      = 0x0001,
@@ -22,40 +23,13 @@ var T_CLASS      = 0x0001,
 // Generates unique id for every ruby object
 var unique_id = 0;
 
-// Find function body for the super call
-function find_super(klass, callee, mid) {
-  var cur_method;
-
-  while (klass) {
-    if (klass.$m[mid]) {
-      if (klass.$m[mid] == callee) {
-        cur_method = klass.$m[mid];
-        break;
-      }
-    }
-    klass = klass.$s;
-  }
-
-  if (!(klass && cur_method)) { return null; }
-
-  klass = klass.$s;
-
-  while (klass) {
-    if (klass.$m[mid]) {
-      return klass.$m[mid];
-    }
-
-    klass = klass.$s;
-  }
-}
-
 // Jump return - return in proc body
-opal.jump = function(value, func) {
+Opal.jump = function(value, func) {
   throw new Error('jump return');
 };
 
 // Get constant with given id
-opal.const_get = function(const_table, id) {
+Opal.const_get = function(const_table, id) {
   if (const_table[id]) {
     return const_table[id];
   }
@@ -64,56 +38,35 @@ opal.const_get = function(const_table, id) {
 };
 
 // Table holds all class variables
-opal.cvars = {};
-
-// Array of all procs to be called at_exit
-var end_procs = [];
-
-// Call exit blocks in reverse order
-opal.do_at_exit = function() {
-  var proc;
-
-  while (proc = end_procs.pop()) {
-    proc.call(proc.$S);
-  }
-};
+Opal.cvars = {};
 
 // Globals table
-opal.gvars = {};
+Opal.gvars = {};
 
 // Define a method alias
-opal.alias = function(klass, new_name, old_name) {
+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];
+  var body = klass._proto[old_name];
 
   if (!body) {
-    throw RubyNameError.$new("undefined method `" + old_name + "' for class `" + klass.$name + "'");
+    // throw RubyNameError.$new(null, "undefined method `" + old_name + "' for class `" + klass._name + "'");
+    throw new Error("undefined method `" + old_name + "' for class `" + klass._name + "'");
   }
 
   define_method(klass, new_name, body);
-  return nil;
+  return null;
 };
 
-// method missing yielder - used in debug mode to call method_missing.
-opal.mm = function(jsid) {
-  var mid = jsid_to_mid(jsid);
-  return function() {
-    var args = $slice.call(arguments);
-    args.unshift(mid);
-    return this.$method_missing.apply(this, args);
-  };
-}
-
 // Actually define methods
-var define_method = opal.defn = function(klass, id, body) {
+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 (klass._flags & T_OBJECT) {
+    klass = klass._klass;
   }
 
-  klass.$allocator.prototype[id] = body;
+  klass._alloc.prototype[id] = body;
 
   var included_in = klass.$included_in, includee;
 
@@ -125,56 +78,51 @@ var define_method = opal.defn = function(klass, id, body) {
     }
   }
 
-  if (klass.$bridge_prototype) {
-    klass.$bridge_prototype[id] = body;
+  if (klass._bridge) {
+    klass._bridge[id] = body;
   }
 
 
-  return nil;
+  return null;
 }
 
-// Fake yielder used when no block given
-opal.no_proc = function() {
-  throw RubyLocalJumpError.$new('no block given');
-};
-
 function define_module(base, id) {
   var module;
 
   module             = boot_module();
-  module.$name = (base === RubyObject ? id : base.$name + '::' + id)
+  module._name = (base === RubyObject ? id : base._name + '::' + id)
 
   make_metaclass(module, RubyModule);
 
-  module.$flags           = T_MODULE;
+  module._flags           = T_MODULE;
   module.$included_in = [];
 
   var const_alloc   = function() {};
-  var const_scope   = const_alloc.prototype = new base.$const.alloc();
-  module.$const     = const_scope;
+  var const_scope   = const_alloc.prototype = new base._scope.alloc();
+  module._scope     = const_scope;
   const_scope.alloc = const_alloc;
 
-  base.$const[id]    = module;
+  base._scope[id]    = module;
 
   return module;
 }
 
-// opal define class. 0: regular, 1: module, 2: shift class.
-opal.klass = function(base, superklass, id, body, type) {
+// 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 (base._flags & T_OBJECT) {
+        base = class_real(base._klass);
       }
 
-      if (superklass === nil) {
+      if (superklass === null) {
         superklass = RubyObject;
       }
 
-      if (hasOwnProperty.call(base.$const, id)) {
-        klass = base.$const[id];
+      if (__hasOwn.call(base._scope, id)) {
+        klass = base._scope[id];
       }
       else {
         klass = define_class(base, id, superklass);
@@ -183,12 +131,12 @@ opal.klass = function(base, superklass, id, body, type) {
       break;
 
     case 1:
-      if (base.$flags & T_OBJECT) {
-        base = class_real(base.$klass);
+      if (base._flags & T_OBJECT) {
+        base = class_real(base._klass);
       }
 
-      if (hasOwnProperty.call(base.$const, id)) {
-        klass = base.$const[id];
+      if (__hasOwn.call(base._scope, id)) {
+        klass = base._scope[id];
       }
       else {
         klass = define_module(base, id);
@@ -197,22 +145,22 @@ opal.klass = function(base, superklass, id, body, type) {
       break;
 
     case 2:
-      klass = singleton_class(base);
+      klass = base.$singleton_class();
       break;
   }
 
   return body.call(klass);
 };
 
-opal.slice = $slice;
+Opal.slice = __slice;
 
-opal.defs = function(base, id, body) {
-  return define_method(singleton_class(base), id, body);
+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);
+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];
@@ -222,19 +170,76 @@ opal.undef = function(klass) {
 };
 
 // Calls a super method.
-opal.zuper = function(callee, self, args) {
-  var mid  = callee.$rbName,
-      func = find_super(self.$klass, callee, mid);
+Opal.zuper = function(callee, jsid, self, args) {
+  var func = find_super(self._klass, callee, jsid);
 
   if (!func) {
-    throw RubyNoMethodError.$new("super: no superclass method `" + mid + "'"
-             + " for " + self.$inspect());
+    throw RubyNoMethodError.$new(null, "super: no superclass method `" +
+            jsid_to_mid(jsid) + "'" + " for " + self.$inspect());
   }
 
   return func.apply(self, args);
 };
 
-var mid_to_jsid = opal.mid_to_jsid = function(mid) {
+// dynamic super (inside block)
+Opal.dsuper = function(scopes, defn, jsid, self, args) {
+  var method, scope = scopes[0];
+
+  for (var i = 0, length = scopes.length; i < length; i++) {
+    if (scope.o$jsid) {
+      jsid = scope.o$jsid;
+      method = scope;
+      break;
+    }
+  }
+
+  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);
+  }
+
+  // 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");
+}
+
+// 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;
+  }
+
+  if (!(klass && cur_method)) { return null; }
+
+  klass = klass._super;
+
+  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];
+      }
+    }
+
+    klass = klass._super;
+  }
+}
+
+var mid_to_jsid = Opal.mid_to_jsid = function(mid) {
   if (method_names[mid]) {
     return method_names[mid];
   }
@@ -242,7 +247,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) {
+var jsid_to_mid = Opal.jsid_to_mid = function(jsid) {
   if (reverse_method_names[jsid]) {
     return reverse_method_names[jsid];
   }
@@ -252,14 +257,14 @@ var jsid_to_mid = opal.jsid_to_mid = function(jsid) {
   return jsid.replace('$b', '!').replace('$p', '?').replace('$e', '=');
 }
 
-opal.arg_error = function(given, expected) {
-  throw RubyArgError.$new('wrong number of arguments(' + given + ' for ' + expected + ')');
+Opal.arg_error = function(given, expected) {
+  throw RubyArgError.$new(null, 'wrong number of arguments(' + given + ' for ' + expected + ')');
 };
 
 // Boot a base class (makes instances).
 function boot_defclass(superklass) {
   var cls = function() {
-    this.$id = unique_id++;
+    this._id = unique_id++;
 
     return this;
   };
@@ -272,7 +277,7 @@ function boot_defclass(superklass) {
   }
 
   cls.prototype.constructor = cls;
-  cls.prototype.$flags          = T_OBJECT;
+  cls.prototype._flags          = T_OBJECT;
 
   return cls;
 }
@@ -280,7 +285,7 @@ function boot_defclass(superklass) {
 // Boot actual (meta classes) of core objects.
 function boot_makemeta(id, klass, superklass) {
   var meta = function() {
-    this.$id = unique_id++;
+    this._id = unique_id++;
 
     return this;
   };
@@ -292,15 +297,15 @@ function boot_makemeta(id, klass, superklass) {
 
   var proto              = meta.prototype;
       proto.$included_in = [];
-      proto.$allocator   = klass;
-      proto.$flags       = T_CLASS;
-      proto.$name  = id;
-      proto.$s           = superklass;
+      proto._alloc   = klass;
+      proto._flags       = T_CLASS;
+      proto._name  = id;
+      proto._super           = superklass;
       proto.constructor  = meta;
 
   var result = new meta();
-  klass.prototype.$klass = result;
-  result.$proto = klass.prototype;
+  klass.prototype._klass = result;
+  result._proto = klass.prototype;
 
   return result;
 }
@@ -309,23 +314,23 @@ function boot_makemeta(id, klass, superklass) {
 function boot_class(superklass) {
   // instances
   var cls = function() {
-    this.$id = unique_id++;
+    this._id = unique_id++;
 
     return this;
   };
 
   var ctor = function() {};
-      ctor.prototype = superklass.$allocator.prototype;
+      ctor.prototype = superklass._alloc.prototype;
 
   cls.prototype = new ctor();
 
   var proto             = cls.prototype;
       proto.constructor = cls;
-      proto.$flags          = T_OBJECT;
+      proto._flags          = T_OBJECT;
 
   // class itself
   var meta = function() {
-    this.$id = unique_id++;
+    this._id = unique_id++;
 
     return this;
   };
@@ -336,15 +341,15 @@ function boot_class(superklass) {
   meta.prototype = new mtor();
 
   proto                            = meta.prototype;
-  proto.$allocator                 = cls;
-  proto.$flags                     = T_CLASS;
+  proto._alloc                 = cls;
+  proto._flags                     = T_CLASS;
   proto.constructor                = meta;
-  proto.$s                         = superklass;
+  proto._super                         = superklass;
 
   var result = new meta();
-  cls.prototype.$klass = result;
-  
-  result.$proto = cls.prototype;
+  cls.prototype._klass = result;
+
+  result._proto = cls.prototype;
 
   return result;
 }
@@ -354,33 +359,33 @@ function boot_module() {
   // can be a regular object
   var module_cons = function(){};
   var module_inst = module_cons.prototype;
-  
+
   // Module itself
   var meta = function() {
-    this.$id = unique_id++;
+    this._id = unique_id++;
     return this;
   };
-  
+
   var mtor = function(){};
   mtor.prototype = RubyModule.constructor.prototype;
   meta.prototype = new mtor();
-  
+
   var proto = meta.prototype;
-  proto.$allocator  = module_cons;
-  proto.$flags      = T_MODULE;
+  proto._alloc  = module_cons;
+  proto._flags      = T_MODULE;
   proto.constructor = meta;
-  proto.$s          = RubyModule;
-  
+  proto._super          = null;
+
   var module          = new meta();
-  module.$proto       = module_inst;
-  
+  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.$s;
+  while (klass._flags & FL_SINGLETON) {
+    klass = klass._super;
   }
 
   return klass;
@@ -388,21 +393,23 @@ function class_real(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._flags & T_CLASS) {
+    if ((klass._flags & T_CLASS) && (klass._flags & FL_SINGLETON)) {
       throw RubyException.$new('too much meta: return klass?');
     }
     else {
-      var class_id = "#<Class:" + klass.$name + ">",
+      var class_id = "#<Class:" + klass._name + ">",
           meta     = boot_class(superklass);
 
-      meta.$name = class_id;
-      meta.$allocator.prototype = klass.constructor.prototype;
-      meta.$flags |= FL_SINGLETON;
+      meta._name = class_id;
+      meta._alloc.prototype = klass.constructor.prototype;
+      meta._proto = meta._alloc.prototype;
+      meta._flags |= FL_SINGLETON;
+      meta._klass = RubyClass;
 
-      klass.$klass = meta;
+      klass._klass = meta;
 
-      meta.$const = klass.$const;
+      meta._scope = klass._scope;
       meta.__attached__ = klass;
 
       return meta;
@@ -414,20 +421,20 @@ function make_metaclass(klass, superklass) {
 }
 
 function make_singleton_class(obj) {
-  var orig_class = obj.$klass,
-      class_id   = "#<Class:#<" + orig_class.$name + ":" + orig_class.$id + ">>";
+  var orig_class = obj._klass,
+      class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
 
   klass             = boot_class(orig_class);
-  klass.$name = class_id;
+  klass._name = class_id;
 
-  klass.$flags                |= FL_SINGLETON;
-  klass.$bridge_prototype  = obj;
+  klass._flags                |= FL_SINGLETON;
+  klass._bridge  = obj;
 
-  obj.$klass = klass;
+  obj._klass = klass;
 
   klass.__attached__ = obj;
 
-  klass.$klass = class_real(orig_class).$k;
+  klass._klass = class_real(orig_class)._klass;
 
   return klass;
 }
@@ -436,13 +443,13 @@ function bridge_class(constructor, flags, id) {
   var klass     = define_class(RubyObject, id, RubyObject),
       prototype = constructor.prototype;
 
-  klass.$allocator = constructor;
-  klass.$proto = prototype;
+  klass._alloc = constructor;
+  klass._proto = prototype;
 
   bridged_classes.push(klass);
 
-  prototype.$klass = klass;
-  prototype.$flags = flags;
+  prototype._klass = klass;
+  prototype._flags = flags;
 
   return klass;
 }
@@ -451,19 +458,19 @@ function bridge_class(constructor, flags, id) {
 function define_class(base, id, superklass) {
   var klass;
 
-  var class_id = (base === RubyObject ? id : base.$name + '::' + id);
+  var class_id = (base === RubyObject ? id : base._name + '::' + id);
 
   klass             = boot_class(superklass);
-  klass.$name = class_id;
+  klass._name = class_id;
 
-  make_metaclass(klass, superklass.$klass);
+  make_metaclass(klass, superklass._klass);
 
   var const_alloc   = function() {};
-  var const_scope   = const_alloc.prototype = new base.$const.alloc();
-  klass.$const      = const_scope;
+  var const_scope   = const_alloc.prototype = new base._scope.alloc();
+  klass._scope      = const_scope;
   const_scope.alloc = const_alloc;
 
-  base.$const[id] = klass;
+  base._scope[id] = klass;
 
   if (superklass.$inherited) {
     superklass.$inherited(klass);
@@ -472,112 +479,25 @@ function define_class(base, id, superklass) {
   return klass;
 }
 
-// Get singleton class of obj
-function singleton_class(obj) {
-  var klass;
-
-  if (obj.$flags & T_OBJECT) {
-    if ((obj.$flags & T_NUMBER) || (obj.$flags & T_STRING)) {
-      throw RubyTypeError.$new("can't define singleton");
-    }
-  }
+function define_iclass(klass, module) {
+  var sup = klass._super;
 
-  if ((obj.$klass.$flags & FL_SINGLETON) && obj.$klass.__attached__ == obj) {
-    klass = obj.$klass;
-  }
-  else {
-    var class_id = obj.$klass.$name;
+  var iclass = {};
+  iclass._proto = module._proto;
+  iclass._super = sup;
+  iclass._flags = T_ICLASS;
+  iclass._klass = module;
+  iclass._name  = module._name;
 
-    klass = make_metaclass(obj, obj.$klass);
-  }
+  klass._super = iclass;
 
-  return klass;
+  return iclass;
 }
 
-opal.main = function(id) {
-  opal.gvars.$0 = find_lib(id);
-
-  try {
-    top_self.$require(id);
-
-    opal.do_at_exit();
-  }
-  catch (e) {
-    // this is defined in debug.js
-    console.log(e.$klass.$name + ': ' + e.message);
-    console.log("\t" + e.$backtrace().join("\n\t"));
-  }
-};
-
-/**
- * Register a standard file. This can be used to register non-lib files.
- * For example, specs can be registered here so they are available.
- *
- * NOTE: Files should be registered as a full path with given factory.
- *
- * Usage:
- *
- *    opal.file('/spec/foo.rb': function() {
- *      // ...
- *    });
- */
-opal.file = function(file, factory) {
-  FACTORIES[file] = factory;
-};
-
-/**
- * Register a lib.
- *
- * Usage:
- *
- *    opal.lib('my_lib', function() {
- *      // ...
- *    });
- *
- *    opal.lib('my_lib/foo', function() {
- *      // ...
- *    });
- */
-opal.lib = function(lib, factory) {
-  var file        = '/lib/' + lib + '.rb';
-  FACTORIES[file] = factory;
-  LIBS[lib]       = file;
-};
-
-var FACTORIES    = {},
-    FEATURES     = [],
-    LIBS         = {},
-    LOADER_PATHS = ['', '/lib'],
-    LOADER_CACHE = {};
-
-function find_lib(id) {
-  var path;
-
-  // try to load a lib path first - i.e. something in our load path
-  if (path = LIBS[id]) return path;
-
-  // find '/opal/x' style libs
-  if (path = LIBS['opal/' + id]) return path;
-
-  // next, incase our require() has a ruby extension..
-  if (FACTORIES['/lib/' +id]) return '/lib/' + id;
-
-  // check if id is full path..
-  if (FACTORIES[id]) return id;
-
-  // full path without '.rb'
-  if (FACTORIES[id + '.rb']) return id + '.rb';
-
-  // check in current working directory.
-  var in_cwd = FS_CWD + '/' + id;
-
-  if (FACTORIES[in_cwd]) return in_cwd;
-};
-
-// Current working directory
-var FS_CWD = '/';
-
-// Turns a glob string into a regexp
+// Handling requires
+function require_handler(path) {
+  throw new Error('Cannot require ' + path);
+}
 
 // Initialization
 // --------------
@@ -593,20 +513,24 @@ var RubyModule = boot_makemeta('Module', BootModule, RubyObject.constructor);
 var RubyClass = boot_makemeta('Class', BootClass, RubyModule.constructor);
 
 // Fix boot classes to use meta class
-RubyObject.$klass = RubyClass;
-RubyModule.$klass = RubyClass;
-RubyClass.$klass = RubyClass;
+RubyObject._klass = RubyClass;
+RubyModule._klass = RubyClass;
+RubyClass._klass = RubyClass;
 
 // fix superclasses
-RubyObject.$s = null;
-RubyModule.$s = RubyObject;
-RubyClass.$s = RubyModule;
-
-opal.Object = RubyObject;
-opal.Module = RubyModule;
-opal.Class  = RubyClass;
-
-// make object act like a module
+RubyObject._super = null;
+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 = [];
 
 // Top level Object scope (used by object and top_self).
@@ -614,27 +538,43 @@ var top_const_alloc     = function(){};
 var top_const_scope     = top_const_alloc.prototype;
 top_const_scope.alloc   = top_const_alloc; 
 
-RubyObject.$const = opal.constants = top_const_scope;
+RubyObject._scope = Opal.constants = top_const_scope;
 
 var module_const_alloc = function(){};
 var module_const_scope = new top_const_alloc();
 module_const_scope.alloc = module_const_alloc;
-RubyModule.$const = module_const_scope;
+RubyModule._scope = module_const_scope;
 
 var class_const_alloc = function(){};
 var class_const_scope = new top_const_alloc();
 class_const_scope.alloc = class_const_alloc;
-RubyClass.$const = class_const_scope;
-
-RubyObject.$const.BasicObject = RubyObject;
-RubyObject.$const.Object = RubyObject;
-RubyObject.$const.Module = RubyModule;
-RubyObject.$const.Class = RubyClass;
+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.$allocator();
+var top_self = Opal.top = new RubyObject._alloc();
 
 var RubyNilClass  = define_class(RubyObject, 'NilClass', RubyObject);
-var nil = opal.nil = new RubyNilClass.$allocator();
+Opal.nil = new RubyNilClass._alloc();
 
 bridge_class(Array, T_OBJECT | T_ARRAY, 'Array');
 bridge_class(Number, T_OBJECT | T_NUMBER, 'Numeric');
@@ -646,6 +586,7 @@ 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);
@@ -662,11 +603,11 @@ var RubyKeyError       = define_class(RubyObject, 'KeyError', RubyIndexError);
 var RubyRangeError     = define_class(RubyObject, 'RangeError', RubyStandardError);
 var RubyNotImplError   = define_class(RubyObject, 'NotImplementedError', RubyException);
 
-RubyException.$allocator.prototype.toString = function() {
-  return this.$klass.$name + ': ' + this.message;
+RubyException._alloc.prototype.toString = function() {
+  return this._klass._name + ': ' + this.message;
 };
 
-var breaker = opal.breaker  = new Error('unexpected break');
-    breaker.$klass              = RubyLocalJumpError;
+var breaker = Opal.breaker  = new Error('unexpected break');
+    breaker._klass              = RubyLocalJumpError;
     breaker.$t              = function() { throw this; };