opal 0.6.3 → 0.7.0.beta1

data/opal/corelib/nil_class.rb

@@ -54,7 +54,7 @@ class NilClass
   end
 
   def object_id
-    `#{NilClass}._id || (#{NilClass}._id = $opal.uid())`
+    `#{NilClass}.$$id || (#{NilClass}.$$id = $opal.uid())`
   end
   alias hash object_id
 end

data/opal/corelib/numeric.rb

@@ -3,11 +3,11 @@ require 'corelib/comparable'
 class Numeric
   include Comparable
 
-  `def._isNumber = true`
+  `def.$$is_number = true`
 
   def coerce(other, type = :operation)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return [self, other];
       }
       else {
@@ -17,7 +17,7 @@ class Numeric
   rescue
     case type
     when :operation
-      raise TypeError, "#{other.class} can't be coerce into Numeric"
+      raise TypeError, "#{other.class} can't be coerced into Numeric"
 
     when :comparison
       raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
@@ -39,7 +39,7 @@ class Numeric
 
   def +(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self + other;
       }
       else {
@@ -50,7 +50,7 @@ class Numeric
 
   def -(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self - other;
       }
       else {
@@ -61,7 +61,7 @@ class Numeric
 
   def *(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self * other;
       }
       else {
@@ -72,7 +72,7 @@ class Numeric
 
   def /(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self / other;
       }
       else {
@@ -83,7 +83,7 @@ class Numeric
 
   def %(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         if (other < 0 || self < 0) {
           return (self % other + other) % other;
         }
@@ -99,7 +99,7 @@ class Numeric
 
   def &(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self & other;
       }
       else {
@@ -110,7 +110,7 @@ class Numeric
 
   def |(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self | other;
       }
       else {
@@ -121,7 +121,7 @@ class Numeric
 
   def ^(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self ^ other;
       }
       else {
@@ -132,7 +132,7 @@ class Numeric
 
   def <(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self < other;
       }
       else {
@@ -143,7 +143,7 @@ class Numeric
 
   def <=(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self <= other;
       }
       else {
@@ -154,7 +154,7 @@ class Numeric
 
   def >(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self > other;
       }
       else {
@@ -165,7 +165,7 @@ class Numeric
 
   def >=(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self >= other;
       }
       else {
@@ -176,7 +176,7 @@ class Numeric
 
   def <=>(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self > other ? 1 : (self < other ? -1 : 0);
       }
       else {
@@ -188,11 +188,15 @@ class Numeric
   end
 
   def <<(count)
-    `self << #{count.to_int}`
+    count = Opal.coerce_to! count, Integer, :to_int
+
+    `#{count} > 0 ? self << #{count} : self >> -#{count}`
   end
 
   def >>(count)
-    `self >> #{count.to_int}`
+    count = Opal.coerce_to! count, Integer, :to_int
+
+    `#{count} > 0 ? self >> #{count} : self << -#{count}`
   end
 
   def [](bit)
@@ -217,7 +221,7 @@ class Numeric
 
   def **(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return Math.pow(self, other);
       }
       else {
@@ -228,7 +232,7 @@ class Numeric
 
   def ==(other)
     %x{
-      if (other._isNumber) {
+      if (other.$$is_number) {
         return self == Number(other);
       }
       else if (#{other.respond_to? :==}) {
@@ -248,7 +252,7 @@ class Numeric
     `Math.ceil(self)`
   end
 
-  def chr
+  def chr(encoding=undefined)
     `String.fromCharCode(self)`
   end
 
@@ -503,7 +507,7 @@ Fixnum = Numeric
 class Integer < Numeric
   def self.===(other)
     %x{
-      if (!other._isNumber) {
+      if (!other.$$is_number) {
         return false;
       }
 
@@ -514,7 +518,7 @@ end
 
 class Float < Numeric
   def self.===(other)
-    `!!other._isNumber`
+    `!!other.$$is_number`
   end
 
   INFINITY = `Infinity`

data/opal/corelib/proc.rb

@@ -1,6 +1,6 @@
 class Proc
-  `def._isProc = true`
-  `def.is_lambda = false`
+  `def.$$is_proc = true`
+  `def.$$is_lambda = false`
 
   def self.new(&block)
     unless block
@@ -13,12 +13,12 @@ class Proc
   def call(*args, &block)
     %x{
       if (block !== nil) {
-        self._p = block;
+        self.$$p = block;
       }
 
       var result;
 
-      if (self.is_lambda) {
+      if (self.$$is_lambda) {
         result = self.apply(null, args);
       }
       else {
@@ -42,7 +42,7 @@ class Proc
   def lambda?
     # This method should tell the user if the proc tricks are unavailable,
     # (see Proc#lambda? on ruby docs to find out more).
-    `!!self.is_lambda`
+    `!!self.$$is_lambda`
   end
 
   # FIXME: this should support the various splats and optional arguments

data/opal/corelib/range.rb

@@ -3,11 +3,13 @@ require 'corelib/enumerable'
 class Range
   include Enumerable
 
-  `def._isRange = true;`
+  `def.$$is_range = true;`
 
   attr_reader :begin, :end
 
   def initialize(first, last, exclude = false)
+    raise ArgumentError unless first <=> last
+
     @begin   = first
     @end     = last
     @exclude = exclude
@@ -15,7 +17,7 @@ class Range
 
   def ==(other)
     %x{
-      if (!other._isRange) {
+      if (!other.$$is_range) {
         return false;
       }
 
@@ -26,10 +28,12 @@ class Range
   end
 
   def ===(value)
-    @begin <= value && (@exclude ? value < @end : value <= @end)
+    include? value
   end
 
-  alias :cover? :===
+  def cover?(value)
+    @begin <= value && (@exclude ? value < @end : value <= @end)
+  end
 
   def each(&block)
     return enum_for :each unless block_given?

data/opal/corelib/regexp.rb

@@ -1,10 +1,10 @@
 class Regexp
-  `def._isRegexp = true`
+  `def.$$is_regexp = true`
 
   class << self
     def escape(string)
       %x{
-        return string.replace(/([-[\]\/{}()*+?.^$\\| ])/g, '\\$1')
+        return string.replace(/([-[\]/{}()*+?.^$\\| ])/g, '\\$1')
                      .replace(/[\n]/g, '\\n')
                      .replace(/[\r]/g, '\\r')
                      .replace(/[\f]/g, '\\f')
@@ -29,11 +29,11 @@ class Regexp
 
   def ===(str)
     %x{
-      if (!str._isString && #{str.respond_to?(:to_str)}) {
+      if (!str.$$is_string && #{str.respond_to?(:to_str)}) {
         #{str = str.to_str};
       }
 
-      if (!str._isString) {
+      if (!str.$$is_string) {
         return false;
       }
 
@@ -88,7 +88,7 @@ class Regexp
       return
     end
 
-    if `string._isString == null`
+    if `string.$$is_string == null`
       unless string.respond_to? :to_str
         raise TypeError, "no implicit conversion of #{string.class} into String"
       end

data/opal/corelib/runtime.js

@@ -1,36 +1,14 @@
 (function(undefined) {
-  // The Opal object that is exposed globally
-  var Opal = this.Opal = {};
-
-  // The actual class for BasicObject
-  var RubyBasicObject;
-
-  // The actual Object class
-  var RubyObject;
-
-  // The actual Module class
-  var RubyModule;
-
-  // The actual Class class
-  var RubyClass;
-
-  // Constructor for instances of BasicObject
-  function BasicObject(){}
-
-  // Constructor for instances of Object
-  function Object(){}
-
-  // Constructor for instances of Class
-  function Class(){}
-
-  // Constructor for instances of Module
-  function Module(){}
+  if (typeof(this.Opal) !== 'undefined') {
+    console.warn('Opal already loaded. Loading twice can cause troubles, please fix your setup.');
+    return this.Opal;
+  }
 
-  // Constructor for instances of NilClass (nil)
-  function NilClass(){}
+  // The Opal object that is exposed globally
+  var Opal = this.Opal = {}, $opal = Opal;
 
   // All bridged classes - keep track to donate methods from Object
-  var bridged_classes = [];
+  var bridged_classes = Opal.bridged_classes = [];
 
   // TopScope is used for inheriting constants from the top scope
   var TopScope = function(){};
@@ -39,8 +17,9 @@
   TopScope.prototype = Opal;
 
   // To inherit scopes
-  Opal.constructor  = TopScope;
+  Opal.constructor = TopScope;
 
+  // List top scope constants
   Opal.constants = [];
 
   // This is a useful reference to global object inside ruby files
@@ -64,22 +43,35 @@
   // Globals table
   Opal.gvars = {};
 
+  // Get constants
+  Opal.get = function(name) {
+    var constant = this[name];
+
+    if (constant == null) {
+      return this.base.$const_missing(name);
+    }
+
+    return constant;
+  };
+
   /*
    * Create a new constants scope for the given class with the given
    * base. Constants are looked up through their parents, so the base
    * scope will be the outer scope of the new klass.
    */
   function create_scope(base, klass, id) {
-    var const_alloc   = function() {};
-    var const_scope   = const_alloc.prototype = new base.constructor();
-    klass._scope      = const_scope;
-    const_scope.base  = klass;
-    klass._base_module = base.base;
+    var const_alloc = function() {};
+    var const_scope = const_alloc.prototype = new base.constructor();
+
+    klass.$$scope       = const_scope;
+    klass.$$base_module = base.base;
+
+    const_scope.base        = klass;
     const_scope.constructor = const_alloc;
-    const_scope.constants = [];
+    const_scope.constants   = [];
 
     if (id) {
-      klass._orig_scope = base;
+      klass.$$orig_scope = base;
       base[id] = base.constructor[id] = klass;
       base.constants.push(id);
     }
@@ -113,29 +105,27 @@
    * @return [Class] new or existing ruby class
    */
   Opal.klass = function(base, superklass, id, constructor) {
-
     // If base is an object, use its class
-    if (!base._isClass) {
-      base = base._klass;
+    if (!base.$$is_class) {
+      base = base.$$class;
     }
 
     // Not specifying a superclass means we can assume it to be Object
     if (superklass === null) {
-      superklass = RubyObject;
+      superklass = ObjectClass;
     }
 
-    var klass = base._scope[id];
+    var klass = base.$$scope[id];
 
     // If a constant exists in the scope, then we must use that
-    if ($hasOwn.call(base._scope, id) && klass._orig_scope === base._scope) {
-
+    if ($hasOwn.call(base.$$scope, id) && klass.$$orig_scope === base.$$scope) {
       // Make sure the existing constant is a class, or raise error
-      if (!klass._isClass) {
+      if (!klass.$$is_class) {
         throw Opal.TypeError.$new(id + " is not a class");
       }
 
       // Make sure existing class has same superclass
-      if (superklass !== klass._super && superklass !== RubyObject) {
+      if (superklass !== klass.$$super && superklass !== ObjectClass) {
         throw Opal.TypeError.$new("superclass mismatch for class " + id);
       }
     }
@@ -148,16 +138,16 @@
       klass = boot_class(superklass, constructor);
 
       // name class using base (e.g. Foo or Foo::Baz)
-      klass._name = id;
+      klass.$$name = id;
 
       // every class gets its own constant scope, inherited from current scope
-      create_scope(base._scope, klass, id);
+      create_scope(base.$$scope, klass, id);
 
       // Name new class directly onto current scope (Opal.Foo.Baz = klass)
-      base[id] = base._scope[id] = klass;
+      base[id] = base.$$scope[id] = klass;
 
       // Copy all parent constants to child, unless parent is Object
-      if (superklass !== RubyObject && superklass !== RubyBasicObject) {
+      if (superklass !== ObjectClass && superklass !== BasicObjectClass) {
         Opal.donate_constants(superklass, klass);
       }
 
@@ -171,66 +161,121 @@
   };
 
   // Create generic class with given superclass.
-  var boot_class = Opal.boot = function(superklass, constructor) {
-    // instances
-    var ctor = function() {};
-        ctor.prototype = superklass._proto;
+  function boot_class(superklass, constructor) {
+    var alloc = boot_class_alloc(null, constructor, superklass)
 
-    constructor.prototype = new ctor();
-
-    constructor.prototype.constructor = constructor;
+    return boot_class_object(superklass, alloc);
+  }
 
-    return boot_class_meta(superklass, constructor);
-  };
+  // Make `boot_class` available to the JS-API
+  Opal.boot = boot_class;
 
-  // class itself
-  function boot_class_meta(superklass, constructor) {
-    var mtor = function() {};
-    mtor.prototype = superklass.constructor.prototype;
+  /*
+   * The class object itself (as in `Class.new`)
+   *
+   * @param [(Opal) Class] superklass Another class object (as in `Class.new`)
+   * @param [constructor]  alloc      The constructor that holds the prototype
+   *                                  that will be used for instances of the
+   *                                  newly constructed class.
+   */
+  function boot_class_object(superklass, alloc) {
+    var singleton_class = function() {};
+    singleton_class.prototype = superklass.constructor.prototype;
 
-    function OpalClass() {};
-    OpalClass.prototype = new mtor();
+    function OpalClass() {}
+    OpalClass.prototype = new singleton_class();
 
     var klass = new OpalClass();
 
-    klass._id         = unique_id++;
-    klass._alloc      = constructor;
-    klass._isClass    = true;
-    klass.constructor = OpalClass;
-    klass._super      = superklass;
-    klass._methods    = [];
-    klass.__inc__     = [];
-    klass.__parent    = superklass;
-    klass._proto      = constructor.prototype;
+    setup_module_or_class_object(klass, OpalClass, superklass, alloc.prototype);
+
+    // @property $$alloc This is the constructor of instances of the current
+    //                   class. Its prototype will be used for method lookup
+    klass.$$alloc = alloc;
 
-    constructor.prototype._klass = klass;
+    // @property $$proto.$$class Make available to instances a reference to the
+    //                           class they belong to.
+    klass.$$proto.$$class = klass;
 
     return klass;
   }
 
+  /*
+   * Adds common/required properties to a module or class object
+   * (as in `Module.new` / `Class.new`)
+   *
+   * @param module      The module or class that needs to be prepared
+   *
+   * @param constructor The constructor of the module or class itself,
+   *                    usually it's already assigned by using `new`. Some
+   *                    ipothesis on why it's needed can be found below.
+   *
+   * @param superklass  The superclass of the class/module object, for modules
+   *                    is `Module` (of `ModuleClass` in JS context)
+   *
+   * @param prototype   The prototype on which the class/module methods will
+   *                    be stored.
+   */
+  function setup_module_or_class_object(module, constructor, superklass, prototype) {
+    // @property $$id Each class is assigned a unique `id` that helps
+    //                comparation and implementation of `#object_id`
+    module.$$id = unique_id++;
+
+    // @property $$proto This is the prototype on which methods will be defined
+    module.$$proto = prototype;
+
+    // @property constructor keeps a ref to the constructor, but apparently the
+    //                       constructor is already set on:
+    //
+    //                          `var module = new constructor` is called.
+    //
+    //                       Maybe there are some browsers not abiding (IE6?)
+    module.constructor = constructor;
+
+    // @property $$is_class Clearly mark this as a class-like
+    module.$$is_class = true;
+
+    // @property $$super the superclass, doesn't get changed by module inclusions
+    module.$$super = superklass;
+
+    // @property $$parent direct parent class or module
+    //                    starts with the superclass, after module inclusion is
+    //                    the last included module
+    module.$$parent = superklass;
+
+    // @property $$methods keeps track of methods defined on the class
+    //                     but seems to be used just by `define_basic_object_method`
+    //                     and for donating (Ruby) Object methods to bridged classes
+    //                     TODO: check if it can be removed
+    module.$$methods = [];
+
+    // @property $$inc included modules
+    module.$$inc = [];
+  }
+
   // Define new module (or return existing module)
   Opal.module = function(base, id) {
     var module;
 
-    if (!base._isClass) {
-      base = base._klass;
+    if (!base.$$is_class) {
+      base = base.$$class;
     }
 
-    if ($hasOwn.call(base._scope, id)) {
-      module = base._scope[id];
+    if ($hasOwn.call(base.$$scope, id)) {
+      module = base.$$scope[id];
 
-      if (!module.__mod__ && module !== RubyObject) {
-        throw Opal.TypeError.$new(id + " is not a module")
+      if (!module.$$is_mod && module !== ObjectClass) {
+        throw Opal.TypeError.$new(id + " is not a module");
       }
     }
     else {
-      module = boot_module()
-      module._name = id;
+      module = boot_module_object();
+      module.$$name = id;
 
-      create_scope(base._scope, module, id);
+      create_scope(base.$$scope, module, id);
 
       // Name new module directly onto current scope (Opal.Foo.Baz = module)
-      base[id] = base._scope[id] = module;
+      base[id] = base.$$scope[id] = module;
     }
 
     return module;
@@ -240,34 +285,143 @@
    * Internal function to create a new module instance. This simply sets up
    * the prototype hierarchy and method tables.
    */
-  function boot_module() {
+  function boot_module_object() {
     var mtor = function() {};
-    mtor.prototype = RubyModule.constructor.prototype;
+    mtor.prototype = ModuleClass.constructor.prototype;
 
-    function OpalModule() {};
-    OpalModule.prototype = new mtor();
+    function module_constructor() {}
+    module_constructor.prototype = new mtor();
 
-    var module = new OpalModule();
+    var module = new module_constructor();
+    var module_prototype = {};
 
-    module._id         = unique_id++;
-    module._isClass    = true;
-    module.constructor = OpalModule;
-    module._super      = RubyModule;
-    module._methods    = [];
-    module.__inc__     = [];
-    module.__parent    = RubyModule;
-    module._proto      = {};
-    module.__mod__     = true;
-    module.__dep__     = [];
+    setup_module_or_class_object(module, module_constructor, ModuleClass, module_prototype);
+
+    module.$$is_mod = true;
+    module.$$dep    = [];
 
     return module;
   }
 
+  /*
+   * Get (or prepare) the singleton class for the passed object.
+   *
+   * @param object [Ruby Object]
+   */
+  Opal.get_singleton_class = function(object) {
+    if (object.$$meta) {
+      return object.$$meta;
+    }
+
+    if (object.$$is_class) {
+      return build_class_singleton_class(object);
+    }
+
+    return build_object_singleton_class(object);
+  };
+
+  /*
+   * Build the singleton class for an existing class.
+   *
+   * NOTE: Actually in MRI a class' singleton class inherits from its
+   * superclass' singleton class which in turn inherits from Class;
+   */
+  function build_class_singleton_class(klass) {
+    var meta = new $opal.Class.$$alloc;
+
+    meta.$$class = $opal.Class;
+    meta.$$proto = klass.constructor.prototype;
+
+    meta.$$is_singleton = true;
+    meta.$$inc          = [];
+    meta.$$methods      = [];
+    meta.$$scope        = klass.$$scope;
+
+    return klass.$$meta = meta;
+  }
+
+  /*
+   * Build the singleton class for a Ruby (non class) Object.
+   */
+  function build_object_singleton_class(object) {
+    var orig_class = object.$$class,
+        class_id   = "#<Class:#<" + orig_class.$$name + ":" + orig_class.$$id + ">>";
+
+    var Singleton = function () {};
+    var meta = Opal.boot(orig_class, Singleton);
+    meta.$$name   = class_id;
+
+    meta.$$proto  = object;
+    meta.$$class  = orig_class.$$class;
+    meta.$$scope  = orig_class.$$scope;
+    meta.$$parent = orig_class;
+    return object.$$meta = meta;
+  }
+
+  /*
+   * The actual inclusion of a module into a class.
+   */
+  Opal.append_features = function(module, klass) {
+    var included = klass.$$inc;
+
+    // check if this module is already included in the klass
+    for (var j = 0, jj = included.length; j < jj; j++) {
+      if (included[j] === module) {
+        return;
+      }
+    }
+
+    included.push(module);
+    module.$$dep.push(klass);
+
+    // iclass
+    var iclass = {
+      $$name:   module.$$name,
+      $$proto:  module.$$proto,
+      $$parent: klass.$$parent,
+      $$module: module,
+      $$iclass: true
+    };
+
+    klass.$$parent = iclass;
+
+    var donator   = module.$$proto,
+        prototype = klass.$$proto,
+        methods   = module.$$methods;
+
+    for (var i = 0, length = methods.length; i < length; i++) {
+      var method = methods[i], current;
+
+
+      if ( prototype.hasOwnProperty(method) &&
+          !(current = prototype[method]).$$donated && !current.$$stub ) {
+        // if the target class already has a method of the same name defined
+        // and that method was NOT donated, then it must be a method defined
+        // by the class so we do not want to override it
+      }
+      else {
+        prototype[method] = donator[method];
+        prototype[method].$$donated = true;
+      }
+    }
+
+    if (klass.$$dep) {
+      $opal.donate(klass, methods.slice(), true);
+    }
+
+    $opal.donate_constants(module, klass);
+  };
+
+
   // Boot a base class (makes instances).
-  var boot_defclass = function(id, constructor, superklass) {
+  function boot_class_alloc(id, constructor, superklass) {
     if (superklass) {
-      var ctor           = function() {};
-          ctor.prototype = superklass.prototype;
+      var ctor = function() {};
+          ctor.prototype   = superklass.$$proto || superklass.prototype;
+
+      if (id) {
+        ctor.displayName = id;
+      }
 
       constructor.prototype = new ctor();
     }
@@ -275,37 +429,42 @@
     constructor.prototype.constructor = constructor;
 
     return constructor;
-  };
+  }
 
-  // Boot the actual (meta?) classes of core classes
-  var boot_makemeta = function(id, constructor, superklass) {
+  /*
+   * Builds the class object for core classes:
+   * - make the class object have a singleton class
+   * - make the singleton class inherit from its parent singleton class
+   *
+   * @param id         [String]      the name of the class
+   * @param alloc      [Function]    the constructor for the core class instances
+   * @param superclass [Class alloc] the constructor of the superclass
+   */
+  function boot_core_class_object(id, alloc, superclass) {
+    var superclass_constructor = function() {};
+        superclass_constructor.prototype = superclass.prototype;
 
-    var mtor = function() {};
-    mtor.prototype  = superklass.prototype;
+    var singleton_class = function() {};
+        singleton_class.prototype = new superclass_constructor();
 
-    function OpalClass() {};
-    OpalClass.prototype = new mtor();
+    singleton_class.displayName = "#<Class:"+id+">";
 
-    var klass = new OpalClass();
+    // the singleton_class acts as the class object constructor
+    var klass = new singleton_class();
 
-    klass._id         = unique_id++;
-    klass._alloc      = constructor;
-    klass._isClass    = true;
-    klass._name       = id;
-    klass._super      = superklass;
-    klass.constructor = OpalClass;
-    klass._methods    = [];
-    klass.__inc__     = [];
-    klass.__parent    = superklass;
-    klass._proto      = constructor.prototype;
+    setup_module_or_class_object(klass, singleton_class, superclass, alloc.prototype);
 
-    constructor.prototype._klass = klass;
+    klass.$$alloc = alloc;
+    klass.$$name  = id;
+
+    // Give all instances a ref to their class
+    alloc.prototype.$$class = klass;
 
     Opal[id] = klass;
     Opal.constants.push(id);
 
     return klass;
-  };
+  }
 
   /*
    * For performance, some core ruby classes are toll-free bridged to their
@@ -331,35 +490,37 @@
    * @return [Class] returns new ruby class
    */
   function bridge_class(name, constructor) {
-    var klass = boot_class_meta(RubyObject, constructor);
+    var klass = boot_class_object(ObjectClass, constructor);
 
-    klass._name = name;
+    klass.$$name = name;
 
     create_scope(Opal, klass, name);
     bridged_classes.push(klass);
 
-    var object_methods = RubyBasicObject._methods.concat(RubyObject._methods);
+    var object_methods = BasicObjectClass.$$methods.concat(ObjectClass.$$methods);
 
     for (var i = 0, len = object_methods.length; i < len; i++) {
       var meth = object_methods[i];
-      constructor.prototype[meth] = RubyObject._proto[meth];
+      constructor.prototype[meth] = ObjectClass.$$proto[meth];
     }
 
+    add_stubs_subscriber(constructor.prototype);
+
     return klass;
-  };
+  }
 
   /*
    * constant assign
    */
   Opal.casgn = function(base_module, name, value) {
-    var scope = base_module._scope;
+    var scope = base_module.$$scope;
 
-    if (value._isClass && value._name === nil) {
-      value._name = name;
+    if (value.$$is_class && value.$$name === nil) {
+      value.$$name = name;
     }
 
-    if (value._isClass) {
-      value._base_module = base_module;
+    if (value.$$is_class) {
+      value.$$base_module = base_module;
     }
 
     scope.constants.push(name);
@@ -386,25 +547,25 @@
     var result = base_scope;
 
     path = path.split('::');
-    while (path.length != 0) {
+    while (path.length !== 0) {
       result = result.$const_get(path.shift());
     }
 
     return result;
-  }
+  };
 
   /*
    * When a source module is included into the target module, we must also copy
    * its constants to the target.
    */
   Opal.donate_constants = function(source_mod, target_mod) {
-    var source_constants = source_mod._scope.constants,
-        target_scope     = target_mod._scope,
+    var source_constants = source_mod.$$scope.constants,
+        target_scope     = target_mod.$$scope,
         target_constants = target_scope.constants;
 
     for (var i = 0, length = source_constants.length; i < length; i++) {
       target_constants.push(source_constants[i]);
-      target_scope[source_constants[i]] = source_mod._scope[source_constants[i]];
+      target_scope[source_constants[i]] = source_mod.$$scope[source_constants[i]];
     }
   };
 
@@ -430,57 +591,86 @@
    *
    *    Opal.add_stubs(["$foo", "$bar", "$baz="]);
    *
-   * All stub functions will have a private `rb_stub` property set to true so
+   * All stub functions will have a private `$$stub` property set to true so
    * that other internal methods can detect if a method is just a stub or not.
    * `Kernel#respond_to?` uses this property to detect a methods presence.
    *
    * @param [Array] stubs an array of method stubs to add
    */
   Opal.add_stubs = function(stubs) {
+    var subscribers = Opal.stub_subscribers;
+    var subscriber;
+
     for (var i = 0, length = stubs.length; i < length; i++) {
-      var stub = stubs[i];
+      var method_name = stubs[i], stub = stub_for(method_name);
 
-      if (!BasicObject.prototype[stub]) {
-        BasicObject.prototype[stub] = true;
-        add_stub_for(BasicObject.prototype, stub);
+      for (var j = 0; j < subscribers.length; j++) {
+        subscriber = subscribers[j];
+        if (!(method_name in subscriber)) {
+          subscriber[method_name] = stub;
+        }
       }
     }
   };
 
   /*
-   * Actuall add a method_missing stub function to the given prototype for the
+   * Add a prototype to the subscribers list, and (TODO) add previously stubbed
+   * methods.
+   *
+   * @param [Prototype]
+   */
+  function add_stubs_subscriber(prototype) {
+    // TODO: Add previously stubbed methods too.
+    Opal.stub_subscribers.push(prototype);
+  }
+
+  /*
+   * Keep a list of prototypes that want method_missing stubs to be added.
+   *
+   * @default [Prototype List] BasicObject.prototype
+   */
+  Opal.stub_subscribers = [BasicObject.prototype];
+
+  /*
+   * Add a method_missing stub function to the given prototype for the
    * given name.
    *
    * @param [Prototype] prototype the target prototype
    * @param [String] stub stub name to add (e.g. "$foo")
    */
   function add_stub_for(prototype, stub) {
+    var method_missing_stub = stub_for(stub);
+    prototype[stub] = method_missing_stub;
+  }
+
+  /*
+   * Generate the method_missing stub for a given method name.
+   *
+   * @param [String] method_name The js-name of the method to stub (e.g. "$foo")
+   */
+  function stub_for(method_name) {
     function method_missing_stub() {
       // Copy any given block onto the method_missing dispatcher
-      this.$method_missing._p = method_missing_stub._p;
+      this.$method_missing.$$p = method_missing_stub.$$p;
 
       // Set block property to null ready for the next call (stop false-positives)
-      method_missing_stub._p = null;
+      method_missing_stub.$$p = null;
 
       // call method missing with correct args (remove '$' prefix on method name)
-      return this.$method_missing.apply(this, [stub.slice(1)].concat($slice.call(arguments)));
+      return this.$method_missing.apply(this, [method_name.slice(1)].concat($slice.call(arguments)));
     }
 
-    method_missing_stub.rb_stub = true;
-    prototype[stub] = method_missing_stub;
+    method_missing_stub.$$stub = true;
+
+    return method_missing_stub;
   }
 
   // Expose for other parts of Opal to use
   Opal.add_stub_for = add_stub_for;
 
-  // Const missing dispatcher
-  Opal.cm = function(name) {
-    return this.base.$const_missing(name);
-  };
-
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, meth) {
-    var inspect = (object._isClass ? object._name + '.' : object._klass._name + '#') + meth;
+    var inspect = (object.$$is_class ? object.$$name + '.' : object.$$class.$$name + '#') + meth;
     var msg = '[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')';
     throw Opal.ArgumentError.$new(msg);
   };
@@ -490,11 +680,11 @@
     var dispatcher;
 
     if (defs) {
-      dispatcher = obj._isClass ? defs._super : obj._klass._proto;
+      dispatcher = obj.$$is_class ? defs.$$super : obj.$$class.$$proto;
     }
     else {
-      if (obj._isClass) {
-        dispatcher = obj._super;
+      if (obj.$$is_class) {
+        dispatcher = obj.$$super;
       }
       else {
         dispatcher = find_obj_super_dispatcher(obj, jsid, current_func);
@@ -502,31 +692,32 @@
     }
 
     dispatcher = dispatcher['$' + jsid];
-    dispatcher._p = iter;
+    dispatcher.$$p = iter;
 
     return dispatcher;
   };
 
   // Iter dispatcher for super in a block
   Opal.find_iter_super_dispatcher = function(obj, jsid, current_func, iter, defs) {
-    if (current_func._def) {
-      return Opal.find_super_dispatcher(obj, current_func._jsid, current_func, iter, defs);
+    if (current_func.$$def) {
+      return Opal.find_super_dispatcher(obj, current_func.$$jsid, current_func, iter, defs);
     }
     else {
       return Opal.find_super_dispatcher(obj, jsid, current_func, iter, defs);
     }
   };
 
-  var find_obj_super_dispatcher = function(obj, jsid, current_func) {
-    var klass = obj.__meta__ || obj._klass;
+  function find_obj_super_dispatcher(obj, jsid, current_func) {
+    var klass = obj.$$meta || obj.$$class;
+    jsid = '$' + jsid;
 
     while (klass) {
-      if (klass._proto['$' + jsid] === current_func) {
+      if (klass.$$proto[jsid] === current_func) {
         // ok
         break;
       }
 
-      klass = klass.__parent;
+      klass = klass.$$parent;
     }
 
     // if we arent in a class, we couldnt find current?
@@ -534,21 +725,21 @@
       throw new Error("could not find current class for super()");
     }
 
-    klass = klass.__parent;
+    klass = klass.$$parent;
 
     // else, let's find the next one
     while (klass) {
-      var working = klass._proto['$' + jsid];
+      var working = klass.$$proto[jsid];
 
       if (working && working !== current_func) {
         // ok
         break;
       }
 
-      klass = klass.__parent;
+      klass = klass.$$parent;
     }
 
-    return klass._proto;
+    return klass.$$proto;
   };
 
   /*
@@ -570,13 +761,8 @@
       throw Opal.LocalJumpError.$new("no block given");
     }
 
-    if (block.length > 1) {
-      if (arg._isArray) {
-        return block.apply(null, arg);
-      }
-      else {
-        return block(arg);
-      }
+    if (block.length > 1 && arg.$$is_array) {
+      return block.apply(null, arg);
     }
     else {
       return block(arg);
@@ -590,12 +776,12 @@
     }
 
     if (block.length > 1 && args.length == 1) {
-      if (args[0]._isArray) {
+      if (args[0].$$is_array) {
         return block.apply(null, args[0]);
       }
     }
 
-    if (!args._isArray) {
+    if (!args.$$is_array) {
       args = $slice.call(args);
     }
 
@@ -607,9 +793,9 @@
   Opal.$rescue = function(exception, candidates) {
     for (var i = 0; i != candidates.length; i++) {
       var candidate = candidates[i];
-      if (candidate._isArray) {
-        var subresult;
-        if (subresult = Opal.$rescue(exception, candidate)) {
+      if (candidate.$$is_array) {
+        var subresult = Opal.$rescue(exception, candidate);
+        if (subresult) {
           return subresult;
         }
       }
@@ -621,35 +807,35 @@
   };
 
   Opal.is_a = function(object, klass) {
-    if (object.__meta__ === klass) {
+    if (object.$$meta === klass) {
       return true;
     }
 
-    var search = object._klass;
+    var search = object.$$class;
 
     while (search) {
       if (search === klass) {
         return true;
       }
 
-      for (var i = 0, length = search.__inc__.length; i < length; i++) {
-        if (search.__inc__[i] == klass) {
+      for (var i = 0, length = search.$$inc.length; i < length; i++) {
+        if (search.$$inc[i] == klass) {
           return true;
         }
       }
 
-      search = search._super;
+      search = search.$$super;
     }
 
     return false;
-  }
+  };
 
   // Helper to convert the given object to an array
   Opal.to_ary = function(value) {
-    if (value._isArray) {
+    if (value.$$is_array) {
       return value;
     }
-    else if (value.$to_ary && !value.$to_ary.rb_stub) {
+    else if (value.$to_ary && !value.$to_ary.$$stub) {
       return value.$to_ary();
     }
 
@@ -657,20 +843,20 @@
   };
 
   /*
-    Call a ruby method on a ruby object with some arguments:
-
-      var my_array = [1, 2, 3, 4]
-      Opal.send(my_array, 'length')     # => 4
-      Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
-
-    A missing method will be forwarded to the object via
-    method_missing.
-
-    The result of either call with be returned.
-
-    @param [Object] recv the ruby object
-    @param [String] mid ruby method to call
-  */
+   * Call a ruby method on a ruby object with some arguments:
+   *
+   *   var my_array = [1, 2, 3, 4]
+   *   Opal.send(my_array, 'length')     # => 4
+   *   Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
+   *
+   * A missing method will be forwarded to the object via
+   * method_missing.
+   *
+   * The result of either call with be returned.
+   *
+   * @param [Object] recv the ruby object
+   * @param [String] mid ruby method to call
+   */
   Opal.send = function(recv, mid) {
     var args = $slice.call(arguments, 2),
         func = recv['$' + mid];
@@ -687,35 +873,36 @@
         func = recv['$' + mid];
 
     if (func) {
-      func._p = block;
+      func.$$p = block;
       return func.apply(recv, args);
     }
 
     return recv.$method_missing.apply(recv, [mid].concat(args));
   };
 
-  /**
+  /*
    * Donate methods for a class/module
    */
   Opal.donate = function(klass, defined, indirect) {
-    var methods = klass._methods, included_in = klass.__dep__;
+    var methods = klass.$$methods, included_in = klass.$$dep;
 
     // if (!indirect) {
-      klass._methods = methods.concat(defined);
+      klass.$$methods = methods.concat(defined);
     // }
 
     if (included_in) {
       for (var i = 0, length = included_in.length; i < length; i++) {
         var includee = included_in[i];
-        var dest = includee._proto;
+        var dest     = includee.$$proto;
 
         for (var j = 0, jj = defined.length; j < jj; j++) {
           var method = defined[j];
-          dest[method] = klass._proto[method];
-          dest[method]._donated = true;
+
+          dest[method] = klass.$$proto[method];
+          dest[method].$$donated = true;
         }
 
-        if (includee.__dep__) {
+        if (includee.$$dep) {
           Opal.donate(includee, defined, true);
         }
       }
@@ -723,17 +910,17 @@
   };
 
   Opal.defn = function(obj, jsid, body) {
-    if (obj.__mod__) {
-      obj._proto[jsid] = body;
+    if (obj.$$is_mod) {
+      obj.$$proto[jsid] = body;
       Opal.donate(obj, [jsid]);
     }
-    else if (obj._isClass) {
-      obj._proto[jsid] = body;
+    else if (obj.$$is_class) {
+      obj.$$proto[jsid] = body;
 
-      if (obj === RubyBasicObject) {
+      if (obj === BasicObjectClass) {
         define_basic_object_method(jsid, body);
       }
-      else if (obj === RubyObject) {
+      else if (obj === ObjectClass) {
         Opal.donate(obj, [jsid]);
       }
     }
@@ -748,7 +935,7 @@
    * Define a singleton method on the given object.
    */
   Opal.defs = function(obj, jsid, body) {
-    if (obj._isClass || obj.__mod__) {
+    if (obj.$$is_class || obj.$$is_mod) {
       obj.constructor.prototype[jsid] = body;
     }
     else {
@@ -757,37 +944,38 @@
   };
 
   function define_basic_object_method(jsid, body) {
-    RubyBasicObject._methods.push(jsid);
+    BasicObjectClass.$$methods.push(jsid);
     for (var i = 0, len = bridged_classes.length; i < len; i++) {
-      bridged_classes[i]._proto[jsid] = body;
+      bridged_classes[i].$$proto[jsid] = body;
     }
   }
 
   Opal.hash = function() {
-    if (arguments.length == 1 && arguments[0]._klass == Opal.Hash) {
+    if (arguments.length == 1 && arguments[0].$$class == Opal.Hash) {
       return arguments[0];
     }
 
-    var hash   = new Opal.Hash._alloc,
+    var hash   = new Opal.Hash.$$alloc(),
         keys   = [],
-        assocs = {};
+        assocs = {},
+        key, obj, length;
 
     hash.map   = assocs;
     hash.keys  = keys;
 
     if (arguments.length == 1) {
-      if (arguments[0]._isArray) {
+      if (arguments[0].$$is_array) {
         var args = arguments[0];
 
-        for (var i = 0, length = args.length; i < length; i++) {
+        for (var i = 0, ii = args.length; i < ii; i++) {
           var pair = args[i];
 
           if (pair.length !== 2) {
             throw Opal.ArgumentError.$new("value not of length 2: " + pair.$inspect());
           }
 
-          var key = pair[0],
-              obj = pair[1];
+          key = pair[0];
+          obj = pair[1];
 
           if (assocs[key] == null) {
             keys.push(key);
@@ -797,22 +985,22 @@
         }
       }
       else {
-        var obj = arguments[0];
-        for (var key in obj) {
+        obj = arguments[0];
+        for (key in obj) {
           assocs[key] = obj[key];
           keys.push(key);
         }
       }
     }
     else {
-      var length = arguments.length;
+      length = arguments.length;
       if (length % 2 !== 0) {
         throw Opal.ArgumentError.$new("odd number of arguments for Hash");
       }
 
-      for (var i = 0; i < length; i++) {
-        var key = arguments[i],
-            obj = arguments[++i];
+      for (var j = 0; j < length; j++) {
+        key = arguments[j];
+        obj = arguments[++j];
 
         if (assocs[key] == null) {
           keys.push(key);
@@ -832,7 +1020,7 @@
    * function
    */
   Opal.hash2 = function(keys, map) {
-    var hash = new Opal.Hash._alloc;
+    var hash = new Opal.Hash.$$alloc();
 
     hash.keys = keys;
     hash.map  = map;
@@ -845,7 +1033,7 @@
    * range excludes the last value.
    */
   Opal.range = function(first, last, exc) {
-    var range         = new Opal.Range._alloc;
+    var range         = new Opal.Range.$$alloc();
         range.begin   = first;
         range.end     = last;
         range.exclude = exc;
@@ -853,71 +1041,200 @@
     return range;
   };
 
+  // Require system
+  // --------------
+  (function(Opal) {
+    var loaded_features = ['corelib/runtime.js'],
+        require_table   = {'corelib/runtime.js': true},
+        modules         = {};
+
+    var current_dir  = '.',
+        current_file = '.';
+
+    function mark_as_loaded(filename) {
+      if (require_table[filename]) {
+        return false;
+      }
+
+      loaded_features.push(filename);
+      require_table[filename] = true;
+
+      return true;
+    }
+
+    function normalize_loadable_path(path) {
+      var parts, part, new_parts = [], SEPARATOR = '/';
+
+      if (current_dir !== '.') {
+        path = current_dir.replace(/\/*$/, '/') + path;
+      }
+
+      parts = path.split(SEPARATOR);
+
+      for (var i = 0, ii = parts.length; i < ii; i++) {
+        part = parts[i];
+        (part === '..') ? new_parts.pop() : new_parts.push(part)
+      }
+
+      return new_parts.join(SEPARATOR);
+    }
+
+    function load(path) {
+      mark_as_loaded(path);
+
+      var module = modules[path];
+
+      if (module) {
+        var tmp          = current_file;
+            current_file = path;
+
+        module(Opal);
+
+        current_file = tmp;
+      }
+      else {
+        var severity = Opal.dynamic_require_severity || 'warning';
+        var message  = 'cannot load such file -- ' + path;
+
+        if (severity === "error") {
+          Opal.LoadError ? Opal.LoadError.$new(message) : function(){throw message}();
+        }
+        else if (severity === "warning") {
+          Opal.gvars.stderr.$puts('WARNING: LoadError: ' + message);
+        }
+      }
+
+      return true;
+    }
+
+    function require(path) {
+      if (require_table[path]) {
+        return false;
+      }
+
+      return load(path);
+    }
+
+    Opal.modules         = modules;
+    Opal.loaded_features = loaded_features;
+
+    Opal.normalize_loadable_path = normalize_loadable_path;
+    Opal.mark_as_loaded          = mark_as_loaded;
+
+    Opal.load    = load;
+    Opal.require = require;
+
+    Opal.current_file = current_file;
+  })(Opal);
+
   // Initialization
   // --------------
 
+  // The actual class for BasicObject
+  var BasicObjectClass;
+
+  // The actual Object class
+  var ObjectClass;
+
+  // The actual Module class
+  var ModuleClass;
+
+  // The actual Class class
+  var ClassClass;
+
+  // Constructor for instances of BasicObject
+  function BasicObject(){}
+
+  // Constructor for instances of Object
+  function Object(){}
+
+  // Constructor for instances of Class
+  function Class(){}
+
+  // Constructor for instances of Module
+  function Module(){}
+
+  // Constructor for instances of NilClass (nil)
+  function NilClass(){}
+
   // Constructors for *instances* of core objects
-  boot_defclass('BasicObject', BasicObject);
-  boot_defclass('Object', Object, BasicObject);
-  boot_defclass('Module', Module, Object);
-  boot_defclass('Class', Class, Module);
+  boot_class_alloc('BasicObject', BasicObject);
+  boot_class_alloc('Object',      Object,       BasicObject);
+  boot_class_alloc('Module',      Module,       Object);
+  boot_class_alloc('Class',       Class,        Module);
 
   // Constructors for *classes* of core objects
-  RubyBasicObject = boot_makemeta('BasicObject', BasicObject, Class);
-  RubyObject      = boot_makemeta('Object', Object, RubyBasicObject.constructor);
-  RubyModule      = boot_makemeta('Module', Module, RubyObject.constructor);
-  RubyClass       = boot_makemeta('Class', Class, RubyModule.constructor);
+  BasicObjectClass = boot_core_class_object('BasicObject', BasicObject, Class);
+  ObjectClass      = boot_core_class_object('Object',      Object,      BasicObjectClass.constructor);
+  ModuleClass      = boot_core_class_object('Module',      Module,      ObjectClass.constructor);
+  ClassClass       = boot_core_class_object('Class',       Class,       ModuleClass.constructor);
 
   // Fix booted classes to use their metaclass
-  RubyBasicObject._klass = RubyClass;
-  RubyObject._klass = RubyClass;
-  RubyModule._klass = RubyClass;
-  RubyClass._klass = RubyClass;
+  BasicObjectClass.$$class = ClassClass;
+  ObjectClass.$$class      = ClassClass;
+  ModuleClass.$$class      = ClassClass;
+  ClassClass.$$class       = ClassClass;
 
   // Fix superclasses of booted classes
-  RubyBasicObject._super = null;
-  RubyObject._super = RubyBasicObject;
-  RubyModule._super = RubyObject;
-  RubyClass._super = RubyModule;
+  BasicObjectClass.$$super = null;
+  ObjectClass.$$super      = BasicObjectClass;
+  ModuleClass.$$super      = ObjectClass;
+  ClassClass.$$super       = ModuleClass;
+
+  BasicObjectClass.$$parent = null;
+  ObjectClass.$$parent      = BasicObjectClass;
+  ModuleClass.$$parent      = ObjectClass;
+  ClassClass.$$parent       = ModuleClass;
 
   // Internally, Object acts like a module as it is "included" into bridged
   // classes. In other words, we donate methods from Object into our bridged
   // classes as their prototypes don't inherit from our root Object, so they
   // act like module includes.
-  RubyObject.__dep__ = bridged_classes;
+  ObjectClass.$$dep = bridged_classes;
 
-  Opal.base = RubyObject;
-  RubyBasicObject._scope = RubyObject._scope = Opal;
-  RubyBasicObject._orig_scope = RubyObject._orig_scope = Opal;
-  Opal.Kernel = RubyObject;
+  Opal.base                     = ObjectClass;
+  BasicObjectClass.$$scope      = ObjectClass.$$scope = Opal;
+  BasicObjectClass.$$orig_scope = ObjectClass.$$orig_scope = Opal;
+  Opal.Kernel                   = ObjectClass;
 
-  RubyModule._scope = RubyObject._scope;
-  RubyClass._scope = RubyObject._scope;
-  RubyModule._orig_scope = RubyObject._orig_scope;
-  RubyClass._orig_scope = RubyObject._orig_scope;
+  ModuleClass.$$scope      = ObjectClass.$$scope;
+  ModuleClass.$$orig_scope = ObjectClass.$$orig_scope;
+  ClassClass.$$scope       = ObjectClass.$$scope;
+  ClassClass.$$orig_scope  = ObjectClass.$$orig_scope;
 
-  RubyObject._proto.toString = function() {
+  ObjectClass.$$proto.toString = function() {
     return this.$to_s();
   };
 
-  Opal.top = new RubyObject._alloc();
+  ObjectClass.$$proto.$require = Opal.require;
+
+  Opal.top = new ObjectClass.$$alloc();
 
-  Opal.klass(RubyObject, RubyObject, 'NilClass', NilClass);
+  Opal.klass(ObjectClass, ObjectClass, 'NilClass', NilClass);
 
-  var nil = Opal.nil = new NilClass;
+  var nil = Opal.nil = new NilClass();
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };
 
   Opal.breaker  = new Error('unexpected break');
   Opal.returner = new Error('unexpected return');
 
-  bridge_class('Array', Array);
-  bridge_class('Boolean', Boolean);
-  bridge_class('Numeric', Number);
-  bridge_class('String', String);
-  bridge_class('Proc', Function);
+  bridge_class('Array',     Array);
+  bridge_class('Boolean',   Boolean);
+  bridge_class('Numeric',   Number);
+  bridge_class('String',    String);
+  bridge_class('Proc',      Function);
   bridge_class('Exception', Error);
-  bridge_class('Regexp', RegExp);
-  bridge_class('Time', Date);
+  bridge_class('Regexp',    RegExp);
+  bridge_class('Time',      Date);
 
-  TypeError._super = Error;
+  TypeError.$$super = Error;
 }).call(this);
+
+if (typeof(global) !== 'undefined') {
+  global.Opal = this.Opal;
+  Opal.global = global;
+}
+if (typeof(window) !== 'undefined') {
+  window.Opal = this.Opal;
+  Opal.global = window;
+}