opal 0.4.4 → 0.5.0

data/corelib/opal.rb

@@ -13,13 +13,17 @@ require 'enumerator'
 require 'array'
 require 'hash'
 require 'string'
+require 'match_data'
+require 'encoding'
 require 'numeric'
 require 'proc'
+require 'method'
 require 'range'
 require 'time'
 require 'struct'
 require 'native'
 require 'io'
+require 'main'
 
 # regexp matches
 $& = $~ = $` = $' = nil
@@ -31,32 +35,9 @@ $:            = []
 $/            = "\n"
 $,            = " "
 
-# native global
-$$ = $global = Native(`Opal.global`)
-
 ARGV          = []
 ARGF          = Object.new
 ENV           = {}
-TRUE          = true
-FALSE         = false
-NIL           = nil
-
-STDERR        = $stderr = IO.new
-STDIN         = $stdin  = IO.new
-STDOUT        = $stdout = IO.new
-
-def $stdout.puts(*strs)
-  %x{
-    for (var i = 0; i < strs.length; i++) {
-      if(strs[i] instanceof Array) {
-        #{ puts(*`strs[i]`) }
-      } else {
-        $opal.puts(#{ `strs[i]`.to_s });
-      }
-    }
-  }
-  nil
-end
 
 RUBY_PLATFORM = 'opal'
 RUBY_ENGINE   = 'opal'
@@ -64,10 +45,44 @@ RUBY_VERSION  = '1.9.3'
 RUBY_ENGINE_VERSION = '0.4.4'
 RUBY_RELEASE_DATE = '2013-08-13'
 
-def self.to_s
-  'main'
-end
+module Opal
+  def self.coerce_to(object, type, method)
+    return object if type === object
+
+    unless object.respond_to? method
+      raise TypeError, "no implicit conversion of #{object.class} into #{type}"
+    end
 
-def self.include(mod)
-  Object.include mod
+    object.__send__ method
+  end
+
+  def self.truthy?(value)
+    if value
+      true
+    else
+      false
+    end
+  end
+
+  def self.falsy?(value)
+    if value
+      false
+    else
+      true
+    end
+  end
+
+  def self.destructure(args)
+    %x{
+      if (args.length == 1) {
+        return args[0];
+      }
+      else if (args._isArray) {
+        return args;
+      }
+      else {
+        return $slice.call(args);
+      }
+    }
+  end
 end

data/corelib/proc.rb

@@ -1,16 +1,29 @@
 class Proc
   `def._isProc = true`
-  `def.is_lambda = true`
+  `def.is_lambda = false`
 
   def self.new(&block)
-    `if (block === nil) { throw new Error("no block given"); }`
-    `block.is_lambda = false`
+    unless block
+      raise ArgumentError, "tried to create a Proc object without a block"
+    end
+
     block
   end
 
-  def call(*args)
+  def call(*args, &block)
     %x{
-      var result = #{self}.apply(null, #{args});
+      if (block !== nil) {
+        self._p = block;
+      }
+
+      var result;
+
+      if (self.is_lambda) {
+        result = self.apply(null, args);
+      }
+      else {
+        result = Opal.$yieldX(self, args);
+      }
 
       if (result === $breaker) {
         return $breaker.$v;
@@ -29,16 +42,15 @@ 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
   def arity
-    `#{self}.length - 1`
+    `self.length`
   end
 
   def to_n
     self
   end
 end
-
-class Method < Proc; end

data/corelib/range.rb

@@ -4,22 +4,21 @@ class Range
   %x{
     Range._proto._isRange = true;
 
-    Opal.range = function(beg, end, exc) {
+    Opal.range = function(first, last, exc) {
       var range         = new Range._alloc;
-          range.begin   = beg;
-          range.end     = end;
+          range.begin   = first;
+          range.end     = last;
           range.exclude = exc;
 
       return range;
     };
   }
 
-  attr_reader :begin
-  attr_reader :end
+  attr_reader :begin, :end
 
-  def initialize(min, max, exclude = false)
-    @begin   = min
-    @end     = max
+  def initialize(first, last, exclude = false)
+    @begin   = first
+    @end     = last
     @exclude = exclude
   end
 
@@ -29,33 +28,36 @@ class Range
         return false;
       }
 
-      return #{self}.exclude === other.exclude && #{self}.begin == other.begin && #{self}.end == other.end;
+      return self.exclude === other.exclude &&
+             self.begin   ==  other.begin &&
+             self.end     ==  other.end;
     }
   end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def ===(obj)
-    `return obj >= #{self}.begin && (#{self}.exclude ? obj < #{self}.end : obj <= #{self}.end)`
+    include?(obj)
   end
 
   def cover?(value)
-    `#{self}.begin` <= value && value <= (exclude_end? ? `#{self}.end` - 1 : `#{self}.end`)
+    @begin <= value && (@exclude ? value < @end : value <= @end)
   end
 
-  def last
-    self.end
-  end
+  alias last end
 
   def each(&block)
-    current = min
+    return enum_for :each unless block_given?
+
+    current = @begin
+    last    = @end
 
-    while current != max
+    while current < last
       yield current
 
       current = current.succ
     end
 
-    yield current unless exclude_end?
+    yield current if !@exclude && current == last
 
     self
   end
@@ -63,21 +65,38 @@ class Range
   def eql?(other)
     return false unless Range === other
 
-    exclude_end? == other.exclude_end? && `#{self}.begin`.eql?(other.begin) && `#{self}.end`.eql?(other.end)
+    @exclude === other.exclude_end? &&
+    @begin.eql?(other.begin) &&
+    @end.eql?(other.end)
   end
 
   def exclude_end?
-    `#{self}.exclude`
+    @exclude
   end
 
+  alias first begin
+
   # FIXME: currently hardcoded to assume range holds numerics
   def include?(obj)
-    `return obj >= #{self}.begin && obj <= #{self}.end`
+    cover?(obj)
   end
 
-  alias max end
+  # FIXME: currently hardcoded to assume range holds numerics
+  def max
+    if block_given?
+      super
+    else
+      `#@exclude ? #@end - 1 : #@end`
+    end
+  end
 
-  alias min begin
+  def min
+    if block_given?
+      super
+    else
+      @begin
+    end
+  end
 
   alias member? include?
 
@@ -86,7 +105,7 @@ class Range
   end
 
   def to_s
-    `#{self}.begin + (#{self}.exclude ? '...' : '..') + #{self}.end`
+    `#{@begin.inspect} + (#@exclude ? '...' : '..') + #{@end.inspect}`
   end
 
   alias inspect to_s

data/corelib/regexp.rb

@@ -5,21 +5,48 @@ class Regexp
     `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\|]/g, '\\\\$&')`
   end
 
+  def self.union(*parts)
+    `new RegExp(parts.join(''))`
+  end
+
   def self.new(regexp, options = undefined)
-    `options? new RegExp(regexp, options) : new RegExp(regexp)`
+    `new RegExp(regexp, options)`
   end
 
   def ==(other)
-    `other.constructor == RegExp && #{self}.toString() === other.toString()`
+    `other.constructor == RegExp && self.toString() === other.toString()`
   end
 
   def ===(str)
-    `#{self}.test(str)`
+    if `str._isString == null` && str.respond_to?(:to_str)
+      str = str.to_str
+    end
+
+    if `str._isString == null`
+      return false
+    end
+
+    `self.test(str)`
   end
 
   def =~(string)
+    if `string === nil`
+      $~ = $` = $' = nil
+
+      return
+    end
+
+    if `string._isString == null`
+      unless string.respond_to? :to_str
+        raise TypeError, "no implicit conversion of #{string.class} into String"
+      end
+
+      string = string.to_str
+    end
+
     %x{
-      var re = #{self};
+      var re = self;
+
       if (re.global) {
         // should we clear it afterwards too?
         re.lastIndex = 0;
@@ -45,18 +72,33 @@ class Regexp
   alias eql? ==
 
   def inspect
-    `#{self}.toString()`
+    `self.toString()`
   end
 
   def match(string, pos = undefined)
+    if `string === nil`
+      $~ = $` = $' = nil
+
+      return
+    end
+
+    if `string._isString == null`
+      unless string.respond_to? :to_str
+        raise TypeError, "no implicit conversion of #{string.class} into String"
+      end
+
+      string = string.to_str
+    end
+
     %x{
-      var re = #{self};
+      var re = self;
+
       if (re.global) {
         // should we clear it afterwards too?
         re.lastIndex = 0;
       }
       else {
-        re = new RegExp(re.source, 'g' + (#{self}.multiline ? 'm' : '') + (#{self}.ignoreCase ? 'i' : ''));
+        re = new RegExp(re.source, 'g' + (re.multiline ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
       }
 
       var result = re.exec(string);
@@ -71,12 +113,12 @@ class Regexp
   end
 
   def source
-    `#{self}.source`
+    `self.source`
   end
 
   alias to_s source
 
   def to_n
-    `#{self}.valueOf()`
+    `self.valueOf()`
   end
 end

data/corelib/runtime.js

@@ -2,21 +2,36 @@
   // The Opal object that is exposed globally
   var Opal = this.Opal = {};
 
-  // Very root class
+  // 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(){}
 
-  // Core Object class
+  // Constructor for instances of Object
   function Object(){}
 
-  // Class' class
+  // Constructor for instances of Class
   function Class(){}
 
-  // Module's class
+  // Constructor for instances of Module
   function Module(){}
 
-  // the class of nil
+  // Constructor for instances of NilClass (nil)
   function NilClass(){}
 
+  // All bridged classes - keep track to donate methods from Object
+  var bridged_classes = [];
+
   // TopScope is used for inheriting constants from the top scope
   var TopScope = function(){};
 
@@ -26,6 +41,8 @@
   // To inherit scopes
   Opal.constructor  = TopScope;
 
+  Opal.constants = [];
+
   // This is a useful reference to global object inside ruby files
   Opal.global = this;
 
@@ -57,44 +74,94 @@
     var const_scope   = const_alloc.prototype = new base.constructor();
     klass._scope      = const_scope;
     const_scope.base  = klass;
+    klass._base_module = base.base;
     const_scope.constructor = const_alloc;
+    const_scope.constants = [];
 
     if (id) {
+      klass._orig_scope = base;
       base[id] = base.constructor[id] = klass;
+      base.constants.push(id);
     }
   }
 
+  Opal.create_scope = create_scope;
+
+  /*
+   * A `class Foo; end` expression in ruby is compiled to call this runtime
+   * method which either returns an existing class of the given name, or creates
+   * a new class in the given `base` scope.
+   *
+   * If a constant with the given name exists, then we check to make sure that
+   * it is a class and also that the superclasses match. If either of these
+   * fail, then we raise a `TypeError`. Note, superklass may be null if one was
+   * not specified in the ruby code.
+   *
+   * We pass a constructor to this method of the form `function ClassName() {}`
+   * simply so that classes show up with nicely formatted names inside debuggers
+   * in the web browser (or node/sprockets).
+   *
+   * The `base` is the current `self` value where the class is being created
+   * from. We use this to get the scope for where the class should be created.
+   * If `base` is an object (not a class/module), we simple get its class and
+   * use that as the base instead.
+   *
+   * @param [Object] base where the class is being created
+   * @param [Class] superklass superclass of the new class (may be null)
+   * @param [String] id the name of the class to be created
+   * @param [Function] constructor function to use as constructor
+   * @return [Class] new or existing ruby class
+   */
   Opal.klass = function(base, superklass, id, constructor) {
-    var klass;
 
+    // If base is an object, use its class
     if (!base._isClass) {
       base = base._klass;
     }
 
+    // Not specifying a superclass means we can assume it to be Object
     if (superklass === null) {
-      superklass = ObjectClass;
+      superklass = RubyObject;
     }
 
-    if ($hasOwn.call(base._scope, id)) {
-      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) {
 
+      // Make sure the existing constant is a class, or raise error
       if (!klass._isClass) {
         throw Opal.TypeError.$new(id + " is not a class");
       }
 
-      if (superklass !== klass._super && superklass !== ObjectClass) {
+      // Make sure existing class has same superclass
+      if (superklass !== klass._super && superklass !== RubyObject) {
         throw Opal.TypeError.$new("superclass mismatch for class " + id);
       }
     }
+    else if (typeof(superklass) === 'function') {
+      // passed native constructor as superklass, so bridge it as ruby class
+      return bridge_class(id, superklass);
+    }
     else {
+      // if class doesnt exist, create a new one with given superclass
       klass = boot_class(superklass, constructor);
 
-      klass._name = (base === ObjectClass ? id : base._name + '::' + id);
+      // name class using base (e.g. Foo or Foo::Baz)
+      klass._name = id;
 
-      create_scope(base._scope, 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;
 
+      // Copy all parent constants to child, unless parent is Object
+      if (superklass !== RubyObject && superklass !== RubyBasicObject) {
+        Opal.donate_constants(superklass, klass);
+      }
+
+      // call .inherited() hook with new class on the superclass
       if (superklass.$inherited) {
         superklass.$inherited(klass);
       }
@@ -103,34 +170,99 @@
     return klass;
   };
 
+  // Create generic class with given superclass.
+  var boot_class = Opal.boot = function(superklass, constructor) {
+    // instances
+    var ctor = function() {};
+        ctor.prototype = superklass._proto;
+
+    constructor.prototype = new ctor();
+
+    constructor.prototype.constructor = constructor;
+
+    return boot_class_meta(superklass, constructor);
+  };
+
+  // class itself
+  function boot_class_meta(superklass, constructor) {
+    var mtor = function() {};
+    mtor.prototype = superklass.constructor.prototype;
+
+    function OpalClass() {};
+    OpalClass.prototype = new mtor();
+
+    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;
+
+    constructor.prototype._klass = klass;
+
+    return klass;
+  }
+
   // Define new module (or return existing module)
-  Opal.module = function(base, id, constructor) {
-    var klass;
+  Opal.module = function(base, id) {
+    var module;
 
     if (!base._isClass) {
       base = base._klass;
     }
 
     if ($hasOwn.call(base._scope, id)) {
-      klass = base._scope[id];
+      module = base._scope[id];
 
-      if (!klass._mod$ && klass !== ObjectClass) {
+      if (!module.__mod__ && module !== RubyObject) {
         throw Opal.TypeError.$new(id + " is not a module")
       }
     }
     else {
-      klass = boot_class(ClassClass, constructor);
-      klass._name = (base === ObjectClass ? id : base._name + '::' + id);
-      klass._mod$ = true;
+      module = boot_module()
+      module._name = id;
 
-      klass._included_in = [];
+      create_scope(base._scope, module, id);
 
-      create_scope(base._scope, klass, id);
+      // Name new module directly onto current scope (Opal.Foo.Baz = module)
+      base[id] = base._scope[id] = module;
     }
 
-    return klass;
+    return module;
   };
 
+  /*
+   * Internal function to create a new module instance. This simply sets up
+   * the prototype hierarchy and method tables.
+   */
+  function boot_module() {
+    var mtor = function() {};
+    mtor.prototype = RubyModule.constructor.prototype;
+
+    function OpalModule() {};
+    OpalModule.prototype = new mtor();
+
+    var module = new OpalModule();
+
+    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__     = [];
+
+    return module;
+  }
+
   // Boot a base class (makes instances).
   var boot_defclass = function(id, constructor, superklass) {
     if (superklass) {
@@ -140,106 +272,170 @@
       constructor.prototype = new ctor();
     }
 
-    var prototype = constructor.prototype;
-
-    prototype.constructor = constructor;
+    constructor.prototype.constructor = constructor;
 
     return constructor;
   };
 
   // Boot the actual (meta?) classes of core classes
-  var boot_makemeta = function(id, klass, superklass) {
-    function RubyClass() {
-      this._id = unique_id++;
-    };
+  var boot_makemeta = function(id, constructor, superklass) {
 
-    var ctor            = function() {};
-        ctor.prototype  = superklass.prototype;
+    var mtor = function() {};
+    mtor.prototype  = superklass.prototype;
 
-    RubyClass.prototype = new ctor();
+    function OpalClass() {};
+    OpalClass.prototype = new mtor();
 
-    var prototype         = RubyClass.prototype;
-    prototype._alloc      = klass;
-    prototype._isClass    = true;
-    prototype._name       = id;
-    prototype._super      = superklass;
-    prototype.constructor = RubyClass;
-    prototype._methods    = [];
+    var klass = new OpalClass();
 
-    var result = new RubyClass();
-    klass.prototype._klass = result;
-    result._proto = klass.prototype;
+    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;
 
-    Opal[id] = result;
+    constructor.prototype._klass = klass;
 
-    return result;
-  };
+    Opal[id] = klass;
+    Opal.constants.push(id);
 
-  // Create generic class with given superclass.
-  var boot_class = Opal.boot = function(superklass, constructor) {
-    // instances
-    var ctor = function() {};
-        ctor.prototype = superklass._proto;
+    return klass;
+  };
 
-    constructor.prototype = new ctor();
-    var prototype = constructor.prototype;
+  /*
+   * 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
+   * 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);
+   *
+   * @param [String] name the name of the ruby class to create
+   * @param [Function] constructor native javascript constructor to use
+   * @return [Class] returns new ruby class
+   */
+  function bridge_class(name, constructor) {
+    var klass = boot_class_meta(RubyObject, constructor);
 
-    prototype.constructor = constructor;
+    klass._name = name;
 
-    // class itself
-    function OpalClass() {
-      this._id = unique_id++;
-    };
+    create_scope(Opal, klass, name);
+    bridged_classes.push(klass);
 
-    var mtor = function() {};
-        mtor.prototype = superklass.constructor.prototype;
+    var object_methods = RubyBasicObject._methods.concat(RubyObject._methods);
 
-    OpalClass.prototype = new mtor();
+    for (var i = 0, len = object_methods.length; i < len; i++) {
+      var meth = object_methods[i];
+      constructor.prototype[meth] = RubyObject._proto[meth];
+    }
 
-    prototype = OpalClass.prototype;
-    prototype._alloc = constructor;
-    prototype._isClass = true;
-    prototype.constructor = OpalClass;
-    prototype._super = superklass;
-    prototype._methods = [];
+    return klass;
+  };
 
-    var result = new OpalClass();
-    constructor.prototype._klass = result;
+  /*
+   * constant assign
+   */
+  Opal.casgn = function(base_module, name, value) {
+    var scope = base_module._scope;
 
-    result._proto = constructor.prototype;
+    if (value._isClass && value._name === nil) {
+      value._name = name;
+    }
 
-    return result;
+    if (value._isClass) {
+      value._base_module = base_module;
+    }
 
-    return constructor;
+    scope.constants.push(name);
+    return scope[name] = value;
   };
 
-  var bridge_class = function(name, constructor) {
-    var klass = boot_class(ObjectClass, constructor);
-    var i, length, m;
-
-    constructor.prototype.constructor = constructor;
-
-    constructor._super        = Object;
-    constructor.constructor   = Class;
-    constructor._methods      = [];
+  /*
+   * constant decl
+   */
+  Opal.cdecl = function(base_scope, name, value) {
+    base_scope.constants.push(name);
+    return base_scope[name] = value;
+  };
 
-    bridged_classes.push(klass);
+  /*
+   * constant get
+   */
+  Opal.cget = function(base_scope, path) {
+    if (path == null) {
+      path       = base_scope;
+      base_scope = Opal.Object;
+    }
 
-    var table = ObjectClass._proto, methods = ObjectClass._methods;
+    var result = base_scope;
 
-    for (i = 0, length = methods.length; i < length; i++) {
-      m = methods[i];
-      constructor.prototype[m] = table[m];
+    path = path.split('::');
+    while (path.length != 0) {
+      result = result.$const_get(path.shift());
     }
 
-    klass._name = name;
-    create_scope(Opal, klass, name);
+    return result;
+  }
 
-    return klass;
+  /*
+   * 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,
+        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]];
+    }
   };
 
-  Opal.puts = function(a) { console.log(a); };
-
+  /*
+   * Methods stubs are used to facilitate method_missing in opal. A stub is a
+   * placeholder function which just calls `method_missing` on the receiver.
+   * If no method with the given name is actually defined on an object, then it
+   * is obvious to say that the stub will be called instead, and then in turn
+   * method_missing will be called.
+   *
+   * When a file in ruby gets compiled to javascript, it includes a call to
+   * this function which adds stubs for every method name in the compiled file.
+   * It should then be safe to assume that method_missing will work for any
+   * method call detected.
+   *
+   * Method stubs are added to the BasicObject prototype, which every other
+   * ruby object inherits, so all objects should handle method missing. A stub
+   * is only added if the given property name (method name) is not already
+   * defined.
+   *
+   * Note: all ruby methods have a `$` prefix in javascript, so all stubs will
+   * have this prefix as well (to make this method more performant).
+   *
+   *    Opal.add_stubs(["$foo", "$bar", "$baz="]);
+   *
+   * All stub functions will have a private `rb_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) {
     for (var i = 0, length = stubs.length; i < length; i++) {
       var stub = stubs[i];
@@ -251,11 +447,22 @@
     }
   };
 
+  /*
+   * Actuall 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) {
     function method_missing_stub() {
+      // Copy any given block onto the method_missing dispatcher
       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;
 
+      // call method missing with correct args (remove '$' prefix on method name)
       return this.$method_missing.apply(this, [stub.slice(1)].concat($slice.call(arguments)));
     }
 
@@ -263,6 +470,7 @@
     prototype[stub] = method_missing_stub;
   }
 
+  // Expose for other parts of Opal to use
   Opal.add_stub_for = add_stub_for;
 
   // Const missing dispatcher
@@ -272,29 +480,85 @@
 
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, meth) {
-    var inspect = ((typeof(object) !== 'function') ? object.constructor._name + '#' : object._name + '.') + meth;
+    var inspect = (object._isClass ? object._name + '.' : object._klass._name + '#') + meth;
     var msg = '[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')';
     throw Opal.ArgumentError.$new(msg);
   };
 
   // Super dispatcher
-  Opal.dispatch_super = function(obj, jsid, args, iter, defs) {
+  Opal.find_super_dispatcher = function(obj, jsid, current_func, iter, defs) {
     var dispatcher;
 
     if (defs) {
       dispatcher = obj._isClass ? defs._super : obj._klass._proto;
     }
     else {
-      dispatcher = obj._isClass ? obj._klass : obj._klass._super._proto;
+      if (obj._isClass) {
+        dispatcher = obj._klass;
+      }
+      else {
+        dispatcher = find_obj_super_dispatcher(obj, jsid, current_func);
+      }
     }
 
     dispatcher = dispatcher['$' + jsid];
     dispatcher._p = iter;
 
-    return dispatcher.apply(obj, args);
+    return dispatcher;
   };
 
-  // return helper
+  // 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);
+    }
+    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;
+
+    while (klass) {
+      if (klass._proto['$' + jsid] === current_func) {
+        // ok
+        break;
+      }
+
+      klass = klass.__parent;
+    }
+
+    // if we arent in a class, we couldnt find current?
+    if (!klass) {
+      throw new Error("could not find current class for super()");
+    }
+
+    klass = klass.__parent;
+
+    // else, let's find the next one
+    while (klass) {
+      var working = klass._proto['$' + jsid];
+
+      if (working && working !== current_func) {
+        // ok
+        break;
+      }
+
+      klass = klass.__parent;
+    }
+
+    return klass._proto;
+  };
+
+  /*
+   * Used to return as an expression. Sometimes, we can't simply return from
+   * a javascript function as if we were a method, as the return is used as
+   * an expression, or even inside a block which must "return" to the outer
+   * method. This helper simply throws an error which is then caught by the
+   * method. This approach is expensive, so it is only used when absolutely
+   * needed.
+   */
   Opal.$return = function(val) {
     Opal.returner.$v = val;
     throw Opal.returner;
@@ -321,15 +585,49 @@
 
   // handles yield for > 1 yielded arg
   Opal.$yieldX = function(block, args) {
+    if (typeof(block) !== "function") {
+      throw Opal.LocalJumpError.$new("no block given");
+    }
+
     if (block.length > 1 && args.length == 1) {
       if (args[0]._isArray) {
         return block.apply(null, args[0]);
       }
     }
 
+    if (!args._isArray) {
+      args = $slice.call(args);
+    }
+
     return block.apply(null, args);
   };
 
+  Opal.is_a = function(object, klass) {
+    var search = object._klass;
+
+    while (search) {
+      if (search === klass) {
+        return true;
+      }
+
+      search = search._super;
+    }
+
+    return false;
+  }
+
+  // Helper to convert the given object to an array
+  Opal.to_ary = function(value) {
+    if (value._isArray) {
+      return value;
+    }
+    else if (value.$to_ary && !value.$to_ary.rb_stub) {
+      return value.$to_ary();
+    }
+
+    return [value];
+  };
+
   /*
     Call a ruby method on a ruby object with some arguments:
 
@@ -372,7 +670,7 @@
    * Donate methods for a class/module
    */
   Opal.donate = function(klass, defined, indirect) {
-    var methods = klass._methods, included_in = klass._included_in;
+    var methods = klass._methods, included_in = klass.__dep__;
 
     // if (!indirect) {
       klass._methods = methods.concat(defined);
@@ -386,15 +684,57 @@
         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._included_in) {
+        if (includee.__dep__) {
           Opal.donate(includee, defined, true);
         }
       }
     }
   };
 
+  Opal.defn = function(obj, jsid, body) {
+    if (obj.__mod__) {
+      obj._proto[jsid] = body;
+      Opal.donate(obj, [jsid]);
+    }
+    else if (obj._isClass) {
+      obj._proto[jsid] = body;
+
+      if (obj === RubyBasicObject) {
+        define_basic_object_method(jsid, body);
+      }
+      else if (obj === RubyObject) {
+        Opal.donate(obj, [jsid]);
+      }
+    }
+    else {
+      obj[jsid] = body;
+    }
+
+    return nil;
+  };
+
+  /*
+   * Define a singleton method on the given object.
+   */
+  Opal.defs = function(obj, jsid, body) {
+    if (obj._isClass || obj.__mod__) {
+      obj.constructor.prototype[jsid] = body;
+    }
+    else {
+      obj[jsid] = body;
+    }
+  };
+
+  function define_basic_object_method(jsid, body) {
+    RubyBasicObject._methods.push(jsid);
+    for (var i = 0, len = bridged_classes.length; i < len; i++) {
+      bridged_classes[i]._proto[jsid] = body;
+    }
+  }
+
   // Initialization
   // --------------
 
@@ -405,47 +745,48 @@
   boot_defclass('Class', Class, Module);
 
   // Constructors for *classes* of core objects
-  var BasicObjectClass = boot_makemeta('BasicObject', BasicObject, Class);
-  var ObjectClass      = boot_makemeta('Object', Object, BasicObjectClass.constructor);
-  var ModuleClass      = boot_makemeta('Module', Module, ObjectClass.constructor);
-  var ClassClass       = boot_makemeta('Class', Class, ModuleClass.constructor);
+  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);
 
   // Fix booted classes to use their metaclass
-  BasicObjectClass._klass = ClassClass;
-  ObjectClass._klass = ClassClass;
-  ModuleClass._klass = ClassClass;
-  ClassClass._klass = ClassClass;
+  RubyBasicObject._klass = RubyClass;
+  RubyObject._klass = RubyClass;
+  RubyModule._klass = RubyClass;
+  RubyClass._klass = RubyClass;
 
   // Fix superclasses of booted classes
-  BasicObjectClass._super = null;
-  ObjectClass._super = BasicObjectClass;
-  ModuleClass._super = ObjectClass;
-  ClassClass._super = ModuleClass;
-
-  // Defines methods onto Object (which are then donated to bridged classes)
-  ObjectClass._defn = function (mid, body) {
-    this._proto[mid] = body;
-    Opal.donate(this, [mid]);
-  };
-
-  var bridged_classes = ObjectClass._included_in = [];
-
-  Opal.base = ObjectClass;
-  BasicObjectClass._scope = ObjectClass._scope = Opal;
-  Opal.Kernel = ObjectClass;
-
-  create_scope(Opal, ModuleClass);
-  create_scope(Opal, ClassClass);
-
-  ObjectClass._proto.toString = function() {
+  RubyBasicObject._super = null;
+  RubyObject._super = RubyBasicObject;
+  RubyModule._super = RubyObject;
+  RubyClass._super = RubyModule;
+
+  // 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;
+
+  Opal.base = RubyObject;
+  RubyBasicObject._scope = RubyObject._scope = Opal;
+  RubyBasicObject._orig_scope = RubyObject._orig_scope = Opal;
+  Opal.Kernel = RubyObject;
+
+  RubyModule._scope = RubyObject._scope;
+  RubyClass._scope = RubyObject._scope;
+  RubyModule._orig_scope = RubyObject._orig_scope;
+  RubyClass._orig_scope = RubyObject._orig_scope;
+
+  RubyObject._proto.toString = function() {
     return this.$to_s();
   };
 
-  ClassClass._proto._defn = function(mid, body) { this._proto[mid] = body; };
+  RubyClass._proto._defn = function(mid, body) { this._proto[mid] = body; };
 
-  Opal.top = new ObjectClass._alloc();
+  Opal.top = new RubyObject._alloc();
 
-  Opal.klass(ObjectClass, ObjectClass, 'NilClass', NilClass);
+  Opal.klass(RubyObject, RubyObject, 'NilClass', NilClass);
 
   var nil = Opal.nil = new NilClass;
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };