opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/regexp.rb

@@ -1,5 +1,6 @@
 class RegexpError < StandardError; end
-class Regexp
+
+class Regexp < `RegExp`
   IGNORECASE = 1
   MULTILINE = 4
   
@@ -67,35 +68,30 @@ class Regexp
 
     def new(regexp, options = undefined)      
       %x{
-        // Play nice with IE8
-        if (regexp.$$is_string && regexp.substr(regexp.length-1, 1) == "\\") {
+        if (regexp.$$is_regexp) {
+          return new RegExp(regexp);
+        }
+
+        regexp = #{Opal.coerce_to!(regexp, String, :to_str)};
+
+        if (regexp.charAt(regexp.length - 1) === '\\') {
           #{raise RegexpError, "too short escape sequence: /#{regexp}/"}
         }
-        
-        if (options == undefined || #{!options}) {
-          options = undefined;
+
+        if (options === undefined || #{!options}) {
+          return new RegExp(regexp);
         }
-        
-        if (options != undefined) {
-          if (regexp.$$is_regexp) {
-            // options are already in regex
-            options = undefined;
-          }
-          else if (options.$$is_number) {
-            var result = '';
-            if (#{IGNORECASE} & options) {
-              result += 'i';
-            }
-            if (#{MULTILINE} & options) {
-              result += 'm';
-            }
-            options = result;
-          }
-          else {
-            options = 'i';
-          }
-        }       
-        
+
+        if (options.$$is_number) {
+          var temp = '';
+          if (#{IGNORECASE} & options) { temp += 'i'; }
+          if (#{MULTILINE}  & options) { temp += 'm'; }
+          options = temp;
+        }
+        else {
+          options = 'i';
+        }
+
         return new RegExp(regexp, options);
       }
     end
@@ -199,6 +195,139 @@ class Regexp
       return result;
     }  
   end
+  
+  def casefold?
+    `self.ignoreCase`
+  end
 
   alias to_s source
 end
+
+class MatchData
+  attr_reader :post_match, :pre_match, :regexp, :string
+
+  def initialize(regexp, match_groups)
+    $~          = self
+    @regexp     = regexp
+    @begin      = `match_groups.index`
+    @string     = `match_groups.input`
+    @pre_match  = `match_groups.input.slice(0, match_groups.index)`
+    @post_match = `match_groups.input.slice(match_groups.index + match_groups[0].length)`
+    @matches    = []
+
+    %x{
+      for (var i = 0, length = match_groups.length; i < length; i++) {
+        var group = match_groups[i];
+
+        if (group == null) {
+          #@matches.push(nil);
+        }
+        else {
+          #@matches.push(group);
+        }
+      }
+    }
+  end
+
+  def [](*args)
+    @matches[*args]
+  end
+
+  def offset(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#offset only supports 0th element'}
+      }
+      return [self.begin, self.begin + self.matches[n].length];
+    }
+  end
+
+  def ==(other)
+    return false unless MatchData === other
+
+    `self.string == other.string` &&
+    `self.regexp.toString() == other.regexp.toString()` &&
+    `self.pre_match == other.pre_match` &&
+    `self.post_match == other.post_match` &&
+    `self.begin == other.begin`
+  end
+
+  alias eql? ==
+
+  def begin(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#begin only supports 0th element'}
+      }
+      return self.begin;
+    }
+  end
+
+  def end(n)
+    %x{
+      if (n !== 0) {
+        #{raise ArgumentError, 'MatchData#end only supports 0th element'}
+      }
+      return self.begin + self.matches[n].length;
+    }
+  end
+
+  def captures
+    `#@matches.slice(1)`
+  end
+
+  def inspect
+    %x{
+      var str = "#<MatchData " + #{`#@matches[0]`.inspect};
+
+      for (var i = 1, length = #@matches.length; i < length; i++) {
+        str += " " + i + ":" + #{`#@matches[i]`.inspect};
+      }
+
+      return str + ">";
+    }
+  end
+
+  def length
+    `#@matches.length`
+  end
+
+  alias size length
+
+  def to_a
+    @matches
+  end
+
+  def to_s
+    `#@matches[0]`
+  end
+
+  def values_at(*args)
+    %x{
+      var i, a, index, values = [];
+
+      for (i = 0; i < args.length; i++) {
+
+        if (args[i].$$is_range) {
+          a = #{`args[i]`.to_a};
+          a.unshift(i, 1);
+          Array.prototype.splice.apply(args, a);
+        }
+
+        index = #{Opal.coerce_to!(`args[i]`, Integer, :to_int)};
+
+        if (index < 0) {
+          index += #@matches.length;
+          if (index < 0) {
+            values.push(nil);
+            continue;
+          }
+        }
+
+        values.push(#@matches[index]);
+      }
+
+      return values;
+    }
+  end
+end

data/opal/corelib/runtime.js

@@ -8,7 +8,7 @@
   var Opal = this.Opal = {};
 
   // All bridged classes - keep track to donate methods from Object
-  var bridged_classes = Opal.bridged_classes = [];
+  var bridges = {};
 
   // TopScope is used for inheriting constants from the top scope
   var TopScope = function(){};
@@ -51,6 +51,9 @@
   // Exit function, this should be replaced by platform specific implementation
   // (See nodejs and phantom for examples)
   Opal.exit = function(status) { if (Opal.gvars.DEBUG) console.log('Exited with status '+status); };
+	
+  // keeps track of exceptions for $!
+  Opal.exceptions = [];
 
   /**
     Get a constant on the given scope. Every class and module in Opal has a
@@ -72,7 +75,7 @@
     var constant = this[name];
 
     if (constant == null) {
-      return this.base.$const_missing(name);
+      return this.base.$const_get(name);
     }
 
     return constant;
@@ -95,9 +98,7 @@
     const_scope.constants   = [];
 
     if (id) {
-      klass.$$orig_scope = base;
-      base[id] = base.constructor[id] = klass;
-      base.constants.push(id);
+      Opal.cdecl(base, id, klass)
     }
   }
 
@@ -130,46 +131,54 @@
    */
   Opal.klass = function(base, superklass, id, constructor) {
     // If base is an object, use its class
-    if (!base.$$is_class) {
+    if (!base.$$is_class && !base.$$is_module) {
       base = base.$$class;
     }
 
-    // Not specifying a superclass means we can assume it to be Object
-    if (superklass === null) {
-      superklass = ObjectClass;
-    }
-
-    var klass = base.$$scope[id];
+    var klass   = base.$$scope[id],
+        bridged = typeof(superklass) === 'function';
 
-    // If a constant exists in the scope, then we must use that
-    if ($hasOwn.call(base.$$scope, id) && klass.$$orig_scope === base.$$scope) {
+    // If the class exists in the scope, then we must use that
+    if (klass && klass.$$orig_scope === base.$$scope) {
       // Make sure the existing constant is a class, or raise error
       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 !== ObjectClass) {
+      if (superklass && klass.$$super !== superklass) {
         throw Opal.TypeError.$new("superclass mismatch for class " + id);
       }
+
+      return klass;
     }
-    else if (typeof(superklass) === 'function') {
-      // passed native constructor as superklass, so bridge it as ruby class
-      return bridge_class(id, superklass, base);
+
+    // Not specifying a superclass means we can assume it to be Object
+    if (superklass === null) {
+      superklass = ObjectClass;
     }
-    else {
-      // if class doesnt exist, create a new one with given superclass
-      klass = boot_class(superklass, constructor);
 
-      // name class using base (e.g. Foo or Foo::Baz)
-      klass.$$name = id;
+    // if class doesnt exist, create a new one with given superclass
+    klass = bridged ?
+      boot_class_object(ObjectClass, superklass) :
+      boot_class(superklass, constructor);
+
+    // name class using base (e.g. Foo or Foo::Baz)
+    klass.$$name = id;
 
-      // every class gets its own constant scope, inherited from current scope
-      create_scope(base.$$scope, klass, id);
+    // mark the object as a class
+    klass.$$is_class = true;
 
-      // Name new class directly onto current scope (Opal.Foo.Baz = klass)
-      base[id] = base.$$scope[id] = klass;
+    // every class gets its own constant scope, inherited from current scope
+    create_scope(base.$$scope, klass, id);
 
+    // Name new class directly onto current scope (Opal.Foo.Baz = klass)
+    base[id] = base.$$scope[id] = klass;
+
+    if (bridged) {
+      Opal.bridge(klass, superklass);
+    }
+    else {
       // Copy all parent constants to child, unless parent is Object
       if (superklass !== ObjectClass && superklass !== BasicObjectClass) {
         donate_constants(superklass, klass);
@@ -256,8 +265,16 @@
     //                       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;
+    if (superklass === ModuleClass) {
+      // @property $$is_module Clearly mark this as a module
+      module.$$is_module = true;
+      module.$$class     = ModuleClass;
+    }
+    else {
+      // @property $$is_class Clearly mark this as a class
+      module.$$is_class = true;
+      module.$$class    = ClassClass;
+    }
 
     // @property $$super the superclass, doesn't get changed by module inclusions
     module.$$super = superklass;
@@ -267,12 +284,6 @@
     //                    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 = [];
   }
@@ -300,21 +311,29 @@
   Opal.module = function(base, id) {
     var module;
 
-    if (!base.$$is_class) {
+    if (!base.$$is_class && !base.$$is_module) {
       base = base.$$class;
     }
 
     if ($hasOwn.call(base.$$scope, id)) {
       module = base.$$scope[id];
 
-      if (!module.$$is_mod && module !== ObjectClass) {
+      if (!module.$$is_module && module !== ObjectClass) {
         throw Opal.TypeError.$new(id + " is not a module");
       }
     }
     else {
       module = boot_module_object();
+
+      // name module using base (e.g. Foo or Foo::Baz)
       module.$$name = id;
 
+      // mark the object as a module
+      module.$$is_module = true;
+
+      // initialize dependency tracking
+      module.$$dep = [];
+
       create_scope(base.$$scope, module, id);
 
       // Name new module directly onto current scope (Opal.Foo.Baz = module)
@@ -340,9 +359,6 @@
 
     setup_module_or_class_object(module, module_constructor, ModuleClass, module_prototype);
 
-    module.$$is_mod = true;
-    module.$$dep    = [];
-
     return module;
   }
 
@@ -364,7 +380,7 @@
       return object.$$meta;
     }
 
-    if (object.$$is_class) {
+    if (object.$$is_class || object.$$is_module) {
       return build_class_singleton_class(object);
     }
 
@@ -381,14 +397,14 @@
     @returns [RubyClass]
    */
   function build_class_singleton_class(klass) {
-    var meta = new Opal.Class.$$alloc;
+    var meta = new Opal.Class.$$alloc();
 
     meta.$$class = Opal.Class;
     meta.$$proto = klass.constructor.prototype;
 
     meta.$$is_singleton = true;
+    meta.$$singleton_of = klass;
     meta.$$inc          = [];
-    meta.$$methods      = [];
     meta.$$scope        = klass.$$scope;
 
     return klass.$$meta = meta;
@@ -412,9 +428,95 @@
     meta.$$class  = orig_class.$$class;
     meta.$$scope  = orig_class.$$scope;
     meta.$$parent = orig_class;
+    meta.$$is_singleton = true;
+    meta.$$singleton_of = object;
+
     return object.$$meta = meta;
   }
 
+  /**
+    The actual inclusion of a module into a class.
+
+    ## Class `$$parent` and `iclass`
+
+    To handle `super` calls, every class has a `$$parent`. This parent is
+    used to resolve the next class for a super call. A normal class would
+    have this point to its superclass. However, if a class includes a module
+    then this would need to take into account the module. The module would
+    also have to then point its `$$parent` to the actual superclass. We
+    cannot modify modules like this, because it might be included in more
+    then one class. To fix this, we actually insert an `iclass` as the class'
+    `$$parent` which can then point to the superclass. The `iclass` acts as
+    a proxy to the actual module, so the `super` chain can then search it for
+    the required method.
+
+    @param [RubyModule] module the module to include
+    @param [RubyClass] klass the target class to include module into
+    @returns [null]
+  */
+  function bridge() {
+    var target, donator, from, name, body, ancestors, id, methods, method, i, ancestor, bridged, length;
+
+    if (arguments.length === 4) {
+      target    = arguments[0];
+      from      = arguments[1];
+      name      = arguments[2];
+      body      = arguments[3];
+      ancestors = target.$$bridge.$ancestors();
+
+      // order important here, we have to check for method presence in
+      // ancestors from the bridged class to the last ancestor
+      for (i = 0, length = ancestors.length; i < length; i++) {
+        ancestor = ancestors[i];
+
+        if ($hasOwn.call(ancestor.$$proto, name) &&
+            ancestor.$$proto[name] &&
+            !ancestor.$$proto[name].$$donated &&
+            !ancestor.$$proto[name].$$stub &&
+            ancestor !== from) {
+          break;
+        }
+
+        if (ancestor === from) {
+          target.prototype[name] = body
+          break;
+        }
+      }
+    }
+    else {
+      target  = arguments[0];
+      donator = arguments[1];
+
+      if (typeof(target) === "function") {
+        id      = donator.$__id__();
+        methods = donator.$instance_methods();
+
+        for (i = methods.length - 1; i >= 0; i--) {
+          method = '$' + methods[i];
+
+          bridge(target, donator, method, donator.$$proto[method]);
+        }
+
+        if (!bridges[id]) {
+          bridges[id] = [];
+        }
+
+        bridges[id].push(target);
+      }
+      else {
+        bridged = bridges[target.$__id__()];
+
+        if (bridged) {
+          for (i = bridged.length - 1; i >= 0; i--) {
+            bridge(bridged[i], donator);
+          }
+
+          bridges[donator.$__id__()] = bridged.slice();
+        }
+      }
+    }
+  }
+
   /**
     The actual inclusion of a module into a class.
 
@@ -436,20 +538,21 @@
     @returns [null]
   */
   Opal.append_features = function(module, klass) {
-    var included = klass.$$inc;
+    var iclass, donator, prototype, methods, id, i;
 
-    // check if this module is already included in the klass
-    for (var j = 0, jj = included.length; j < jj; j++) {
-      if (included[j] === module) {
+    // check if this module is already included in the class
+    for (i = klass.$$inc.length - 1; i >= 0; i--) {
+      if (klass.$$inc[i] === module) {
         return;
       }
     }
 
-    included.push(module);
+    klass.$$inc.push(module);
     module.$$dep.push(klass);
+    bridge(klass, module);
 
     // iclass
-    var iclass = {
+    iclass = {
       $$name:   module.$$name,
       $$proto:  module.$$proto,
       $$parent: klass.$$parent,
@@ -459,28 +562,24 @@
 
     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;
+    donator   = module.$$proto;
+    prototype = klass.$$proto;
+    methods   = module.$instance_methods();
 
+    for (i = methods.length - 1; i >= 0; i--) {
+      id = '$' + methods[i];
 
-      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 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
+      if ( prototype.hasOwnProperty(id) &&
+          !prototype[id].$$donated &&
+          !prototype[id].$$stub) {
+        continue;
       }
-    }
 
-    if (klass.$$dep) {
-      donate_methods(klass, methods.slice(), true);
+      prototype[id] = donator[id];
+      prototype[id].$$donated = module;
     }
 
     donate_constants(module, klass);
@@ -540,68 +639,80 @@
   }
 
   /*
-   * For performance, some core ruby classes are toll-free bridged to their
-   * native javascript counterparts (e.g. a ruby Array is a javascript Array).
+   * For performance, some core Ruby classes are toll-free bridged to their
+   * native JavaScript counterparts (e.g. a Ruby Array is a JavaScript Array).
    *
    * This method is used to setup a native constructor (e.g. Array), to have
-   * its prototype act like a normal ruby class. Firstly, a new ruby class is
+   * its prototype act like a normal Ruby class. Firstly, a new Ruby class is
    * created using the native constructor so that its prototype is set as the
    * target for th new class. Note: all bridged classes are set to inherit
    * from Object.
    *
-   * Bridged classes are tracked in `bridged_classes` array so that methods
-   * defined on Object can be "donated" to all bridged classes. This allows
-   * us to fake the inheritance of a native prototype from our Object
-   * prototype.
-   *
    * Example:
    *
-   *    bridge_class("Proc", Function);
+   *    Opal.bridge(self, Function);
    *
-   * @param [String] name the name of the ruby class to create
-   * @param [Function] constructor native javascript constructor to use
-   * @param [Object] base where the bridge class is being created. If none is supplied, the top level scope (Opal) will be used
-   * @return [Class] returns new ruby class
+   * @param [Class] klass the Ruby class to bridge
+   * @param [Function] constructor native JavaScript constructor to use
+   * @return [Class] returns the passed Ruby class
    */
-  function bridge_class(name, constructor, base) {
-    var klass = boot_class_object(ObjectClass, constructor);
-
-    klass.$$name = name;
-
-    if (base === undefined) {
-      base = Opal;
-    }
-    else {
-      base = base.$$scope;
+  Opal.bridge = function(klass, constructor) {
+    if (constructor.$$bridge) {
+      throw Opal.ArgumentError.$new("already bridged");
     }
 
-    create_scope(base, klass, name);
-    bridged_classes.push(klass);
+    Opal.stub_subscribers.push(constructor.prototype);
+
+    constructor.prototype.$$class = klass;
+    constructor.$$bridge          = klass;
 
-    var object_methods = BasicObjectClass.$$methods.concat(ObjectClass.$$methods);
+    var ancestors = klass.$ancestors();
 
-    for (var i = 0, len = object_methods.length; i < len; i++) {
-      var meth = object_methods[i];
-      constructor.prototype[meth] = ObjectClass.$$proto[meth];
+    // order important here, we have to bridge from the last ancestor to the
+    // bridged class
+    for (var i = ancestors.length - 1; i >= 0; i--) {
+      bridge(constructor, ancestors[i]);
     }
 
-    add_stubs_subscriber(constructor.prototype);
+    for (var name in BasicObject.prototype) {
+      var method = BasicObject.prototype[method];
+
+      if (method && method.$$stub && !(name in constructor.prototype)) {
+        constructor.prototype[name] = method;
+      }
+    }
 
     return klass;
   }
 
+
   /*
    * constant assign
    */
   Opal.casgn = function(base_module, name, value) {
-    var scope = base_module.$$scope;
+    function update(klass, name) {
+      klass.$$name = name;
 
-    if (value.$$is_class && value.$$name === nil) {
-      value.$$name = name;
+      for (name in klass.$$scope) {
+        var value = klass.$$scope[name];
+
+        if (value.$$name === nil && (value.$$is_class || value.$$is_module)) {
+          update(value, name)
+        }
+      }
     }
 
-    if (value.$$is_class) {
-      value.$$base_module = base_module;
+    var scope = base_module.$$scope;
+
+    if (value.$$is_class || value.$$is_module) {
+      // only checking ObjectClass prevents setting a const on an anonymous class that has a superclass that's not Object
+      if (value.$$is_class || value.$$base_module === ObjectClass) {
+        value.$$base_module = base_module;
+      }
+
+      if (value.$$name === nil && value.$$base_module.$$name !== nil) {
+        update(value, name);
+      }
     }
 
     scope.constants.push(name);
@@ -612,6 +723,12 @@
    * constant decl
    */
   Opal.cdecl = function(base_scope, name, value) {
+    if ((value.$$is_class || value.$$is_module) && value.$$orig_scope == null) {
+      value.$$name = name;
+      value.$$orig_scope = base_scope;
+      base_scope.constructor[name] = value;
+    }
+
     base_scope.constants.push(name);
     return base_scope[name] = value;
   };
@@ -631,6 +748,60 @@
     }
   };
 
+  /*
+   * Donate methods for a module.
+   */
+  function donate(module, jsid) {
+    var included_in = module.$$dep,
+        body = module.$$proto[jsid],
+        i, length, includee, dest, current,
+        klass_includees, j, jj, current_owner_index, module_index;
+
+    if (!included_in) {
+      return;
+    }
+
+    for (i = 0, length = included_in.length; i < length; i++) {
+      includee = included_in[i];
+      dest = includee.$$proto;
+      current = dest[jsid];
+
+      if (dest.hasOwnProperty(jsid) && !current.$$donated && !current.$$stub) {
+        // target class has already defined the same method name - do nothing
+      }
+      else if (dest.hasOwnProperty(jsid) && !current.$$stub) {
+        // target class includes another module that has defined this method
+        klass_includees = includee.$$inc;
+
+        for (j = 0, jj = klass_includees.length; j < jj; j++) {
+          if (klass_includees[j] === current.$$donated) {
+            current_owner_index = j;
+          }
+          if (klass_includees[j] === module) {
+            module_index = j;
+          }
+        }
+
+        // only redefine method on class if the module was included AFTER
+        // the module which defined the current method body. Also make sure
+        // a module can overwrite a method it defined before
+        if (current_owner_index <= module_index) {
+          dest[jsid] = body;
+          dest[jsid].$$donated = module;
+        }
+      }
+      else {
+        // neither a class, or module included by class, has defined method
+        dest[jsid] = body;
+        dest[jsid].$$donated = module;
+      }
+
+      if (includee.$$dep) {
+        donate(includee, jsid);
+      }
+    }
+  };
+
   /*
    * Methods stubs are used to facilitate method_missing in opal. A stub is a
    * placeholder function which just calls `method_missing` on the receiver.
@@ -660,14 +831,18 @@
    * @param [Array] stubs an array of method stubs to add
    */
   Opal.add_stubs = function(stubs) {
-    var subscribers = Opal.stub_subscribers;
-    var subscriber;
+    var subscriber, subscribers = Opal.stub_subscribers,
+        i, ilength = stubs.length,
+        j, jlength = subscribers.length,
+        method_name, stub;
 
-    for (var i = 0, length = stubs.length; i < length; i++) {
-      var method_name = stubs[i], stub = stub_for(method_name);
+    for (i = 0; i < ilength; i++) {
+      method_name = stubs[i];
+      stub = stub_for(method_name);
 
-      for (var j = 0; j < subscribers.length; j++) {
+      for (j = 0; j < jlength; j++) {
         subscriber = subscribers[j];
+
         if (!(method_name in subscriber)) {
           subscriber[method_name] = stub;
         }
@@ -675,17 +850,6 @@
     }
   };
 
-  /*
-   * 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.
    *
@@ -732,9 +896,16 @@
 
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, 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);
+    var inspect = '';
+    if (object.$$is_class || object.$$is_module) {
+      inspect += object.$$name + '.';
+    }
+    else {
+      inspect += object.$$class.$$name + '#';
+    }
+    inspect += meth;
+
+    throw Opal.ArgumentError.$new('[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')');
   };
 
   // Super dispatcher
@@ -742,10 +913,15 @@
     var dispatcher;
 
     if (defs) {
-      dispatcher = obj.$$is_class ? defs.$$super : obj.$$class.$$proto;
+      if (obj.$$is_class || obj.$$is_module) {
+        dispatcher = defs.$$super;
+      }
+      else {
+        dispatcher = obj.$$class.$$proto;
+      }
     }
     else {
-      if (obj.$$is_class) {
+      if (obj.$$is_class || obj.$$is_module) {
         dispatcher = obj.$$super;
       }
       else {
@@ -837,7 +1013,7 @@
       throw Opal.LocalJumpError.$new("no block given");
     }
 
-    if (block.length > 1 && args.length == 1) {
+    if (block.length > 1 && args.length === 1) {
       if (args[0].$$is_array) {
         return block.apply(null, args[0]);
       }
@@ -884,7 +1060,7 @@
       }
 
       for (var i = 0, length = search.$$inc.length; i < length; i++) {
-        if (search.$$inc[i] == klass) {
+        if (search.$$inc[i] === klass) {
           return true;
         }
       }
@@ -903,8 +1079,21 @@
     else if (value.$to_ary && !value.$to_ary.$$stub) {
       return value.$to_ary();
     }
+    else {
+      return [value];
+    }
+  };
 
-    return [value];
+  Opal.to_a = function(value) {
+    if (value == null || value === nil) {
+      return [];
+    }
+    else if (value.$to_a && !value.$to_a.$$stub) {
+      return value.$to_a();
+    }
+    else {
+      return [value];
+    }
   };
 
   /**
@@ -973,103 +1162,6 @@
     return recv.$method_missing.apply(recv, [mid].concat(args));
   };
 
-  /*
-   * Donate methods for a class/module
-   */
-  function donate_methods(klass, defined, indirect) {
-    var methods = klass.$$methods, included_in = klass.$$dep;
-
-    // if (!indirect) {
-      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;
-
-        for (var j = 0, jj = defined.length; j < jj; j++) {
-          var method = defined[j];
-
-          dest[method] = klass.$$proto[method];
-          dest[method].$$donated = true;
-        }
-
-        if (includee.$$dep) {
-          donate_methods(includee, defined, true);
-        }
-      }
-    }
-  };
-
-  /**
-    Define the given method on the module.
-
-    This also handles donating methods to all classes that include this
-    module. Method conflicts are also handled here, where a class might already
-    have defined a method of the same name, or another included module defined
-    the same method.
-
-    @param [RubyModule] module the module method defined on
-    @param [String] jsid javascript friendly method name (e.g. "$foo")
-    @param [Function] body method body of actual function
-  */
-  function define_module_method(module, jsid, body) {
-    module.$$proto[jsid] = body;
-    body.$$owner = module;
-
-    module.$$methods.push(jsid);
-
-    if (module.$$module_function) {
-      module[jsid] = body;
-    }
-
-    var included_in = module.$$dep;
-
-    if (included_in) {
-      for (var i = 0, length = included_in.length; i < length; i++) {
-        var includee = included_in[i];
-        var dest = includee.$$proto;
-        var current = dest[jsid];
-
-
-        if (dest.hasOwnProperty(jsid) && !current.$$donated && !current.$$stub) {
-          // target class has already defined the same method name - do nothing
-        }
-        else if (dest.hasOwnProperty(jsid) && !current.$$stub) {
-          // target class includes another module that has defined this method
-          var klass_includees = includee.$$inc;
-
-          for (var j = 0, jj = klass_includees.length; j < jj; j++) {
-            if (klass_includees[j] === current.$$owner) {
-              var current_owner_index = j;
-            }
-            if (klass_includees[j] === module) {
-              var module_index = j;
-            }
-          }
-
-          // only redefine method on class if the module was included AFTER
-          // the module which defined the current method body. Also make sure
-          // a module can overwrite a method it defined before
-          if (current_owner_index <= module_index) {
-            dest[jsid] = body;
-            dest[jsid].$$donated = true;
-          }
-        }
-        else {
-          // neither a class, or module included by class, has defined method
-          dest[jsid] = body;
-          dest[jsid].$$donated = true;
-        }
-
-        if (includee.$$dep) {
-          donate_methods(includee, [jsid], true);
-        }
-      }
-    }
-  }
-
   /**
     Used to define methods on an object. This is a helper method, used by the
     compiled source to define methods on special case objects when the compiler
@@ -1108,21 +1200,33 @@
     @returns [null]
   */
   Opal.defn = function(obj, jsid, body) {
-    if (obj.$$is_mod) {
-      define_module_method(obj, jsid, body);
-    }
-    else if (obj.$$is_class) {
-      obj.$$proto[jsid] = body;
+    obj.$$proto[jsid] = body;
 
-      if (obj === BasicObjectClass) {
-        define_basic_object_method(jsid, body);
+    if (obj.$$is_module) {
+      donate(obj, jsid);
+
+      if (obj.$$module_function) {
+        Opal.defs(obj, jsid, body);
       }
-      else if (obj === ObjectClass) {
-        donate_methods(obj, [jsid]);
+    }
+
+    if (obj.$__id__ && !obj.$__id__.$$stub) {
+      var bridged = bridges[obj.$__id__()];
+
+      if (bridged) {
+        for (var i = bridged.length - 1; i >= 0; i--) {
+          bridge(bridged[i], obj, jsid, body);
+        }
       }
     }
-    else {
-      obj[jsid] = body;
+
+    if (obj.$method_added && !obj.$method_added.$$stub) {
+      obj.$method_added(jsid.substr(1));
+    }
+
+    var singleton_of = obj.$$singleton_of;
+    if (singleton_of && singleton_of.$singleton_method_added && !singleton_of.$singleton_method_added.$$stub) {
+      singleton_of.$singleton_method_added(jsid.substr(1));
     }
 
     return nil;
@@ -1132,105 +1236,381 @@
    * Define a singleton method on the given object.
    */
   Opal.defs = function(obj, jsid, body) {
-    if (obj.$$is_class || obj.$$is_mod) {
-      obj.constructor.prototype[jsid] = body;
+    Opal.defn(Opal.get_singleton_class(obj), jsid, body)
+  };
+
+  Opal.def = function(obj, jsid, body) {
+    // if instance_eval is invoked on a module/class, it sets inst_eval_mod
+    if (!obj.$$eval && (obj.$$is_class || obj.$$is_module)) {
+      Opal.defn(obj, jsid, body);
     }
     else {
-      obj[jsid] = body;
+      Opal.defs(obj, jsid, body);
     }
   };
 
-  function define_basic_object_method(jsid, body) {
-    BasicObjectClass.$$methods.push(jsid);
-    for (var i = 0, len = bridged_classes.length; i < len; i++) {
-      bridged_classes[i].$$proto[jsid] = body;
+  /*
+   * Called from #remove_method.
+   */
+  Opal.rdef = function(obj, jsid) {
+    // TODO: remove from bridges as well
+
+    if (!$hasOwn.call(obj.$$proto, jsid)) {
+      throw Opal.NameError.$new("method '" + jsid.substr(1) + "' not defined in " + obj.$name());
     }
-  }
+
+    delete obj.$$proto[jsid];
+
+    if (obj.$$is_singleton) {
+      if (obj.$$proto.$singleton_method_removed && !obj.$$proto.$singleton_method_removed.$$stub) {
+        obj.$$proto.$singleton_method_removed(jsid.substr(1));
+      }
+    }
+    else {
+      if (obj.$method_removed && !obj.$method_removed.$$stub) {
+        obj.$method_removed(jsid.substr(1));
+      }
+    }
+  };
 
   /*
-   * Called to remove a method.
+   * Called from #undef_method.
    */
-  Opal.undef = function(obj, jsid) {
-    delete obj.$$proto[jsid];
+  Opal.udef = function(obj, jsid) {
+    if (!obj.$$proto[jsid] || obj.$$proto[jsid].$$stub) {
+      throw Opal.NameError.$new("method '" + jsid.substr(1) + "' not defined in " + obj.$name());
+    }
+
+    Opal.add_stub_for(obj.$$proto, jsid);
+
+    if (obj.$$is_singleton) {
+      if (obj.$$proto.$singleton_method_undefined && !obj.$$proto.$singleton_method_undefined.$$stub) {
+        obj.$$proto.$singleton_method_undefined(jsid.substr(1));
+      }
+    }
+    else {
+      if (obj.$method_undefined && !obj.$method_undefined.$$stub) {
+        obj.$method_undefined(jsid.substr(1));
+      }
+    }
   };
 
-  Opal.hash = function() {
-    if (arguments.length == 1 && arguments[0].$$class == Opal.Hash) {
-      return arguments[0];
+  // This black magic is required to avoid clashes of internal special fields,
+  // like $$donated.
+  function wrap(body) {
+    function alias() {
+      body.$$p = alias.$$p;
+      body.$$s = alias.$$s;
+
+      try {
+        return body.apply(this, $slice.call(arguments));
+      }
+      finally {
+        alias.$$s = null;
+        alias.$$p = null;
+      }
     }
 
-    var hash = new Opal.Hash.$$alloc(),
-        keys = [],
-        _map = {},
-        smap = {},
-        key, obj, length, khash, map;
+    alias.$$target = body;
+    alias.$$arity  = body.length;
 
-    hash.map   = _map;
-    hash.smap  = smap;
-    hash.keys  = keys;
+    return alias;
+  }
 
-    if (arguments.length == 1) {
-      if (arguments[0].$$is_array) {
-        var args = arguments[0];
+  Opal.alias = function(obj, name, old) {
+    var id     = '$' + name,
+        old_id = '$' + old,
+        body   = obj.$$proto['$' + old];
+    
+    // instance_eval is being run on a class/module, so that need to alias class methods
+    if (obj.$$eval) {
+      return Opal.alias(Opal.get_singleton_class(obj), name, old);
+    }
 
-        for (var i = 0, ii = args.length; i < ii; i++) {
-          var pair = args[i];
+    if (typeof(body) !== "function" || body.$$stub) {
+      var ancestor = obj.$$super;
 
-          if (pair.length !== 2) {
-            throw Opal.ArgumentError.$new("value not of length 2: " + pair.$inspect());
-          }
+      while (typeof(body) !== "function" && ancestor) {
+        body     = ancestor[old_id];
+        ancestor = ancestor.$$super;
+      }
 
-          key = pair[0];
-          obj = pair[1];
+      if (typeof(body) !== "function" || body.$$stub) {
+        throw Opal.NameError.$new("undefined method `" + old + "' for class `" + obj.$name() + "'")
+      }
+    }
 
-          if (key.$$is_string) {
-            khash = key;
-            map = smap;
-          } else {
-            khash = key.$hash();
-            map = _map;
-          }
+    Opal.defn(obj, id, wrap(body));
 
-          if (map[khash] == null) {
-            keys.push(key);
-          }
+    return obj;
+  };
 
-          map[khash] = obj;
+  Opal.alias_native = function(obj, name, native_name) {
+    var id   = '$' + name,
+        body = obj.$$proto[native_name];
+
+    if (typeof(body) !== "function" || body.$$stub) {
+      throw Opal.NameError.$new("undefined native method `" + native_name + "' for class `" + obj.$name() + "'")
+    }
+
+    Opal.defn(obj, id, wrap(body));
+
+    return obj;
+  };
+
+  Opal.hash_init = function (hash) {
+    hash.map  = {};
+    hash.smap = {};
+    hash.keys = [];
+  };
+
+  Opal.hash_clone = function (from_hash, to_hash) {
+    to_hash.none = from_hash.none;
+    to_hash.proc = from_hash.proc;
+
+    for (var i = 0, keys = from_hash.keys, length = keys.length, key, value; i < length; i++) {
+      key = from_hash.keys[i];
+
+      if (key.$$is_string) {
+        value = from_hash.smap[key];
+      } else {
+        value = key.value;
+        key = key.key;
+      }
+
+      Opal.hash_put(to_hash, key, value);
+    }
+  };
+
+  Opal.hash_put = function (hash, key, value) {
+    if (key.$$is_string) {
+      if (!hash.smap.hasOwnProperty(key)) {
+        hash.keys.push(key);
+      }
+      hash.smap[key] = value;
+      return;
+    }
+
+    var key_hash = key.$hash(), bucket, last_bucket;
+
+    if (!hash.map.hasOwnProperty(key_hash)) {
+      bucket = {key: key, key_hash: key_hash, value: value};
+      hash.keys.push(bucket);
+      hash.map[key_hash] = bucket;
+      return;
+    }
+
+    bucket = hash.map[key_hash];
+
+    while (bucket) {
+      if (key === bucket.key || key['$eql?'](bucket.key)) {
+        last_bucket = undefined;
+        bucket.value = value;
+        break;
+      }
+      last_bucket = bucket;
+      bucket = bucket.next;
+    }
+
+    if (last_bucket) {
+      bucket = {key: key, key_hash: key_hash, value: value};
+      hash.keys.push(bucket);
+      last_bucket.next = bucket;
+    }
+  };
+
+  Opal.hash_get = function (hash, key) {
+    if (key.$$is_string) {
+      if (hash.smap.hasOwnProperty(key)) {
+        return hash.smap[key];
+      }
+      return;
+    }
+
+    var key_hash = key.$hash(), bucket;
+
+    if (hash.map.hasOwnProperty(key_hash)) {
+      bucket = hash.map[key_hash];
+
+      while (bucket) {
+        if (key === bucket.key || key['$eql?'](bucket.key)) {
+          return bucket.value;
         }
+        bucket = bucket.next;
       }
-      else {
-        obj = arguments[0];
-        for (key in obj) {
-          khash = key.$hash();
-          smap[khash] = obj[khash];
-          keys.push(key);
+    }
+  };
+
+  Opal.hash_delete = function (hash, key) {
+    var i, keys = hash.keys, length = keys.length, value;
+
+    if (key.$$is_string) {
+      if (!hash.smap.hasOwnProperty(key)) {
+        return;
+      }
+
+      for (i = 0; i < length; i++) {
+        if (keys[i] === key) {
+          keys.splice(i, 1);
+          break;
         }
       }
+
+      value = hash.smap[key];
+      delete hash.smap[key];
+      return value;
     }
-    else {
-      length = arguments.length;
-      if (length % 2 !== 0) {
-        throw Opal.ArgumentError.$new("odd number of arguments for Hash");
+
+    var key_hash = key.$hash();
+
+    if (!hash.map.hasOwnProperty(key_hash)) {
+      return;
+    }
+
+    var bucket = hash.map[key_hash], last_bucket;
+
+    while (bucket) {
+      if (key === bucket.key || key['$eql?'](bucket.key)) {
+        value = bucket.value;
+
+        for (i = 0; i < length; i++) {
+          if (keys[i] === bucket) {
+            keys.splice(i, 1);
+            break;
+          }
+        }
+
+        if (last_bucket && bucket.next) {
+          last_bucket.next = bucket.next;
+        }
+        else if (last_bucket) {
+          delete last_bucket.next;
+        }
+        else if (bucket.next) {
+          hash.map[key_hash] = bucket.next;
+        }
+        else {
+          delete hash.map[key_hash];
+        }
+
+        return value;
+      }
+      last_bucket = bucket;
+      bucket = bucket.next;
+    }
+  };
+
+  Opal.hash_rehash = function (hash) {
+    for (var i = 0, length = hash.keys.length, key_hash, bucket, last_bucket; i < length; i++) {
+
+      if (hash.keys[i].$$is_string) {
+        continue;
       }
 
-      for (var j = 0; j < length; j++) {
-        key = arguments[j];
-        obj = arguments[++j];
+      key_hash = hash.keys[i].key.$hash();
 
-        if (key.$$is_string) {
-          khash = key;
-          map = smap;
-        } else {
-          khash = key.$hash();
-          map = _map;
+      if (key_hash === hash.keys[i].key_hash) {
+        continue;
+      }
+
+      bucket = hash.map[hash.keys[i].key_hash];
+      last_bucket = undefined;
+
+      while (bucket) {
+        if (bucket === hash.keys[i]) {
+          if (last_bucket && bucket.next) {
+            last_bucket.next = bucket.next;
+          }
+          else if (last_bucket) {
+            delete last_bucket.next;
+          }
+          else if (bucket.next) {
+            hash.map[hash.keys[i].key_hash] = bucket.next;
+          }
+          else {
+            delete hash.map[hash.keys[i].key_hash];
+          }
+          break;
+        }
+        last_bucket = bucket;
+        bucket = bucket.next;
+      }
+
+      hash.keys[i].key_hash = key_hash;
+
+      if (!hash.map.hasOwnProperty(key_hash)) {
+        hash.map[key_hash] = hash.keys[i];
+        continue;
+      }
+
+      bucket = hash.map[key_hash];
+      last_bucket = undefined;
+
+      while (bucket) {
+        if (bucket === hash.keys[i]) {
+          last_bucket = undefined;
+          break;
         }
+        last_bucket = bucket;
+        bucket = bucket.next;
+      }
+
+      if (last_bucket) {
+        last_bucket.next = hash.keys[i];
+      }
+    }
+  };
+
+  Opal.hash = function() {
+    var arguments_length = arguments.length, args, hash, i, length, key, value;
+
+    if (arguments_length === 1 && arguments[0].$$is_hash) {
+      return arguments[0];
+    }
+
+    hash = new Opal.Hash.$$alloc();
+    Opal.hash_init(hash);
 
-        if (map[khash] == null) {
-          keys.push(key);
+    if (arguments_length === 1 && arguments[0].$$is_array) {
+      args = arguments[0];
+      length = args.length;
+
+      for (i = 0; i < length; i++) {
+        if (args[i].length !== 2) {
+          throw Opal.ArgumentError.$new("value not of length 2: " + args[i].$inspect());
         }
 
-        map[khash] = obj;
+        key = args[i][0];
+        value = args[i][1];
+
+        Opal.hash_put(hash, key, value);
+      }
+
+      return hash;
+    }
+
+    if (arguments_length === 1) {
+      args = arguments[0];
+      for (key in args) {
+        if (args.hasOwnProperty(key)) {
+          value = args[key];
+
+          Opal.hash_put(hash, key, value);
+        }
       }
+
+      return hash;
+    }
+
+    if (arguments_length % 2 !== 0) {
+      throw Opal.ArgumentError.$new("odd number of arguments for Hash");
+    }
+
+    for (i = 0; i < arguments_length; i += 2) {
+      key = arguments[i];
+      value = arguments[i + 1];
+
+      Opal.hash_put(hash, key, value);
     }
 
     return hash;
@@ -1242,12 +1622,12 @@
    * compile time, so they are just added here by the constructor
    * function
    */
-  Opal.hash2 = function(keys, map) {
+  Opal.hash2 = function(keys, smap) {
     var hash = new Opal.Hash.$$alloc();
 
-    hash.keys = keys;
     hash.map  = {};
-    hash.smap = map;
+    hash.keys = keys;
+    hash.smap = smap;
 
     return hash;
   };
@@ -1265,6 +1645,25 @@
     return range;
   };
 
+  Opal.ivar = function(name) {
+    if (name === "constructor" ||
+        name === "__proto__" ||
+        name === "__parent__" ||
+        name === "__noSuchMethod__" ||
+        name === "__count__")
+    {
+      return name + "$";
+    }
+
+    if (name === "hasOwnProperty" ||
+        name === "valueOf")
+    {
+      return name + "$";
+    }
+
+    return name;
+  };
+
   // Require system
   // --------------
   (function(Opal) {
@@ -1274,18 +1673,7 @@
 
     var current_dir  = '.';
 
-    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) {
+    function normalize(path) {
       var parts, part, new_parts = [], SEPARATOR = '/';
 
       if (current_dir !== '.') {
@@ -1297,15 +1685,32 @@
 
       for (var i = 0, ii = parts.length; i < ii; i++) {
         part = parts[i];
-        if (part == '') continue;
+        if (part === '') continue;
         (part === '..') ? new_parts.pop() : new_parts.push(part)
       }
 
       return new_parts.join(SEPARATOR);
     }
 
+    function loaded(paths) {
+      var i, l, path;
+
+      for (i = 0, l = paths.length; i < l; i++) {
+        path = normalize(paths[i]);
+
+        if (require_table[path]) {
+          return;
+        }
+
+        loaded_features.push(path);
+        require_table[path] = true;
+      }
+    }
+
     function load(path) {
-      mark_as_loaded(path);
+      path = normalize(path);
+
+      loaded([path]);
 
       var module = modules[path];
 
@@ -1328,6 +1733,8 @@
     }
 
     function require(path) {
+      path = normalize(path);
+
       if (require_table[path]) {
         return false;
       }
@@ -1337,9 +1744,7 @@
 
     Opal.modules         = modules;
     Opal.loaded_features = loaded_features;
-
-    Opal.normalize_loadable_path = normalize_loadable_path;
-    Opal.mark_as_loaded          = mark_as_loaded;
+    Opal.loaded          = loaded;
 
     Opal.load    = load;
     Opal.require = require;
@@ -1404,16 +1809,9 @@
   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.
-  ObjectClass.$$dep = bridged_classes;
-
   Opal.base                     = ObjectClass;
   BasicObjectClass.$$scope      = ObjectClass.$$scope = Opal;
   BasicObjectClass.$$orig_scope = ObjectClass.$$orig_scope = Opal;
-  Opal.Kernel                   = ObjectClass;
 
   ModuleClass.$$scope      = ObjectClass.$$scope;
   ModuleClass.$$orig_scope = ObjectClass.$$orig_scope;
@@ -1437,15 +1835,6 @@
   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('Exception', Error);
-  bridge_class('Regexp',    RegExp);
-  bridge_class('Time',      Date);
-
   TypeError.$$super = Error;
 }).call(this);