opal 0.4.2 → 0.4.3

data/{opal → corelib}/opal/error.rb

@@ -4,7 +4,7 @@ class Exception
   def self.new(message = '')
     %x{
       var err = new Error(message);
-      err.constructor = #{self};
+      err._klass = #{self};
       err.name = #{self}._name;
       return err;
     }
@@ -33,15 +33,19 @@ class Exception
 end
 
 class StandardError < Exception; end
-class RuntimeError < Exception; end
-class LocalJumpError < Exception; end
-class TypeError < Exception; end
-class NameError < Exception; end
-class NoMethodError < Exception; end
-class ArgumentError < Exception; end
-class IndexError < Exception; end
-class KeyError < Exception; end
-class RangeError < Exception; end
-class StopIteration < Exception; end
-class SyntaxError < Exception; end
+  class NameError < StandardError; end
+    class NoMethodError < NameError; end
+  class RuntimeError < StandardError; end
+  class LocalJumpError < StandardError; end
+  class TypeError < StandardError; end
+  class ArgumentError < StandardError; end
+  class IndexError < StandardError; end
+    class StopIteration < IndexError; end
+    class KeyError < IndexError; end
+  class RangeError < StandardError; end
+
+class ScriptError < Exception; end
+  class SyntaxError < ScriptError; end
+  class NotImplementedError < ScriptError; end
+
 class SystemExit < Exception; end

data/{opal → corelib}/opal/hash.rb

@@ -3,7 +3,7 @@ class Hash
 
   %x{
     var __hash = Opal.hash = function() {
-      var hash   = new Hash,
+      var hash   = new Hash._alloc,
           args   = __slice.call(arguments),
           keys   = [],
           assocs = {};
@@ -31,7 +31,7 @@ class Hash
   # function
   %x{
     var __hash2 = Opal.hash2 = function(keys, map) {
-      var hash = new Hash;
+      var hash = new Hash._alloc;
       hash.keys = keys;
       hash.map = map;
       return hash;

data/{opal → corelib}/opal/kernel.rb

@@ -36,7 +36,7 @@ module Kernel
         #{ raise NameError };
       }
 
-      func.constructor = #{Method};
+      func._klass = #{Method};
       return func;
     }
   end
@@ -75,7 +75,7 @@ module Kernel
   end
 
   def class
-    `#{self}.constructor`
+    `#{self}._klass`
   end
 
   def define_singleton_method(name, &body)
@@ -255,7 +255,7 @@ module Kernel
   end
 
   def instance_of?(klass)
-    `#{self}.constructor === klass`
+    `#{self}._klass === klass`
   end
 
   def instance_variable_defined?(name)
@@ -290,7 +290,7 @@ module Kernel
 
   def is_a?(klass)
     %x{
-      var search = #{self}.constructor;
+      var search = #{self}._klass;
 
       while (search) {
         if (search === klass) {
@@ -401,22 +401,24 @@ module Kernel
 
   def singleton_class
     %x{
-      if (typeof(#{self}) === 'function') {
+      if (#{self}._isClass) {
         if (#{self}._singleton) {
           return #{self}._singleton;
         }
 
-        var meta = new __opal.Class;
-        meta.constructor = __opal.Class;
+        var meta = new __opal.Class._alloc;
+        meta._klass = __opal.Class;
         #{self}._singleton = meta;
-        meta.prototype = #{self};
+        // FIXME - is this right? (probably - methods defined on
+        // class' singleton should also go to subclasses?)
+        meta._proto = #{self}.constructor.prototype;
         meta._isSingleton = true;
 
         return meta;
       }
 
-      if (typeof(#{self}) === 'function') {
-        return #{self}.constructor;
+      if (#{self}._isClass) {
+        return #{self}._klass;
       }
 
       if (#{self}._singleton) {
@@ -424,16 +426,16 @@ module Kernel
       }
 
       else {
-        var orig_class = #{self}.constructor,
+        var orig_class = #{self}._klass,
             class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
 
         var Singleton = function () {};
         var meta = Opal.boot(orig_class, Singleton);
         meta._name = class_id;
 
-        meta.prototype = #{self};
+        meta._proto = #{self};
         #{self}._singleton = meta;
-        meta.constructor = orig_class.constructor;
+        meta._klass = orig_class._klass;
 
         return meta;
       }
@@ -460,7 +462,7 @@ module Kernel
   end
 
   def to_s
-    `return "#<" + #{self}.constructor._name + ":" + #{self}._id + ">";`
+    `return "#<" + #{self}._klass._name + ":" + #{self}._id + ">";`
   end
 
   alias to_str to_s

data/{opal → corelib}/opal/nil_class.rb

@@ -54,7 +54,7 @@ class NilClass
   end
 
   def to_n
-    `nil`
+    `null`
   end
 
   def to_s

data/{opal → corelib}/opal/range.rb

@@ -2,10 +2,10 @@ class Range
   include Enumerable
 
   %x{
-    Range.prototype._isRange = true;
+    Range._proto._isRange = true;
 
     Opal.range = function(beg, end, exc) {
-      var range         = new Range;
+      var range         = new Range._alloc;
           range.begin   = beg;
           range.end     = end;
           range.exclude = exc;

data/{opal → corelib}/opal/runtime.js

@@ -77,29 +77,30 @@
 
   Opal.klass = function(base, superklass, id, constructor) {
     var klass;
-    if (typeof(base) !== 'function') {
-      base = base.constructor;
+
+    if (!base._isClass) {
+      base = base._klass;
     }
 
     if (superklass === null) {
-      superklass = Object;
+      superklass = ObjectClass;
     }
 
     if (__hasOwn.call(base._scope, id)) {
       klass = base._scope[id];
 
-      if (typeof klass !== 'function') {
+      if (!klass._isClass) {
         throw Opal.TypeError.$new(id + " is not a class");
       }
 
-      if (superklass !== klass._super && superklass !== Object) {
+      if (superklass !== klass._super && superklass !== ObjectClass) {
         throw Opal.TypeError.$new("superclass mismatch for class " + id);
       }
     }
     else {
       klass = boot_class(superklass, constructor);
 
-      klass._name = (base === Object ? id : base._name + '::' + id);
+      klass._name = (base === ObjectClass ? id : base._name + '::' + id);
 
       create_scope(base._scope, klass);
 
@@ -116,20 +117,21 @@
   // Define new module (or return existing module)
   Opal.module = function(base, id, constructor) {
     var klass;
-    if (typeof(base) !== 'function') {
-      base = base.constructor;
+
+    if (!base._isClass) {
+      base = base._klass;
     }
 
     if (__hasOwn.call(base._scope, id)) {
       klass = base._scope[id];
 
-      if (!klass._mod$ && klass !== Object) {
+      if (!klass._mod$ && klass !== ObjectClass) {
         throw Opal.TypeError.$new(id + " is not a module")
       }
     }
     else {
-      klass = boot_class(Class, constructor);
-      klass._name = (base === Object ? id : base._name + '::' + id);
+      klass = boot_class(ClassClass, constructor);
+      klass._name = (base === ObjectClass ? id : base._name + '::' + id);
       klass._mod$ = true;
 
       klass._included_in = [];
@@ -157,65 +159,79 @@
     var prototype = constructor.prototype;
 
     prototype.constructor = constructor;
-    prototype.constructor      = constructor;
 
-    constructor._name         = id;
-    constructor._super        = superklass;
-    constructor._methods      = [];
-    constructor._smethods     = [];
+    return constructor;
+  };
 
-    constructor['$==='] = module_eqq;
-    constructor.$to_s = module_to_s;
-    constructor.toString = module_to_s;
+  // Boot the actual (meta?) classes of core classes
+  var boot_makemeta = function(id, klass, superklass) {
+    function RubyClass() {
+      this._id = unique_id++;
+    };
 
-    Opal[id] = constructor;
+    var ctor            = function() {};
+        ctor.prototype  = superklass.prototype;
 
-    return constructor;
+    RubyClass.prototype = new ctor();
+
+    var prototype         = RubyClass.prototype;
+    prototype._isBoot = true;
+    prototype._alloc      = klass;
+    prototype._isClass    = true;
+    prototype._name       = id;
+    prototype._super      = superklass;
+    prototype.constructor = RubyClass;
+    prototype._methods    = [];
+
+    var result = new RubyClass();
+    klass.prototype._klass = result;
+    result._proto = klass.prototype;
+
+    Opal[id] = result;
+
+    return result;
   };
 
   // Create generic class with given superclass.
   var boot_class = Opal.boot = function(superklass, constructor) {
+    // instances
     var ctor = function() {};
-        ctor.prototype = superklass.prototype;
+        ctor.prototype = superklass._proto;
 
     constructor.prototype = new ctor();
     var prototype = constructor.prototype;
 
     prototype.constructor = constructor;
 
-    constructor._super        = superklass;
-    constructor._methods      = [];
-    constructor.constructor   = Class;
-
-    constructor['$===']  = module_eqq;
-    constructor.$to_s    = module_to_s;
-    constructor.toString = module_to_s;
+    // class itself
+    function OpalClass() {
+      this._id = unique_id++;
+    };
 
-    constructor['$[]'] = undefined;
-    constructor.$call  = undefined;
+    var mtor = function() {};
+        mtor.prototype = superklass.constructor.prototype;
 
-    var smethods;
+    OpalClass.prototype = new mtor();
 
-    smethods = superklass._smethods.slice();
+    prototype = OpalClass.prototype;
+    prototype._alloc = constructor;
+    prototype._isClass = true;
+    prototype.constructor = OpalClass;
+    prototype._super = superklass;
+    prototype._methods = [];
 
-    constructor._smethods = smethods;
-    for (var i = 0, length = smethods.length; i < length; i++) {
-      var m = smethods[i];
-      constructor[m] = superklass[m];
-    }
+    var result = new OpalClass();
+    constructor.prototype._klass = result;
 
-    var inherited = superklass._inherited;
+    result._proto = constructor.prototype;
 
-    if (!inherited) {
-      inherited = superklass._inherited = [];
-    }
-
-    inherited.push(constructor);
+    return result;
 
     return constructor;
   };
 
   var bridge_class = function(constructor) {
+    var klass = boot_class(ObjectClass, constructor);
     var i, length, m;
 
     constructor.prototype.constructor = constructor;
@@ -223,30 +239,17 @@
     constructor._super        = Object;
     constructor.constructor   = Class;
     constructor._methods      = [];
-    constructor._smethods     = [];
-
-    constructor['$===']  = module_eqq;
-    constructor.$to_s    = module_to_s;
-    constructor.toString = module_to_s;
 
-    var smethods = constructor._smethods = Class._methods.slice();
-    for (i = 0, length = smethods.length; i < length; i++) {
-      m = smethods[i];
-      constructor[m] = Object[m];
-    }
+    bridged_classes.push(klass);
 
-    bridged_classes.push(constructor);
-
-    var table = Object.prototype, methods = Object._methods;
+    var table = ObjectClass._proto, methods = ObjectClass._methods;
 
     for (i = 0, length = methods.length; i < length; i++) {
       m = methods[i];
       constructor.prototype[m] = table[m];
     }
 
-    constructor._smethods.push('$allocate');
-
-    return constructor;
+    return klass;
   };
 
   Opal.puts = function(a) { console.log(a); };
@@ -464,30 +467,6 @@
     return recv.$method_missing.apply(recv, [mid].concat(args));
   };
 
-  // Implementation of Class#===
-  function module_eqq(object) {
-    if (object == null) {
-      return false;
-    }
-
-    var search = object.constructor;
-
-    while (search) {
-      if (search === this) {
-        return true;
-      }
-
-      search = search._super;
-    }
-
-    return false;
-  }
-
-  // Implementation of Class#to_s
-  function module_to_s() {
-    return this._name;
-  }
-
   /**
    * Donate methods for a class/module
    */
@@ -501,11 +480,11 @@
     if (included_in) {
       for (var i = 0, length = included_in.length; i < length; i++) {
         var includee = included_in[i];
-        var dest = includee.prototype;
+        var dest = includee._proto;
 
         for (var j = 0, jj = defined.length; j < jj; j++) {
           var method = defined[j];
-          dest[method] = klass.prototype[method];
+          dest[method] = klass._proto[method];
         }
 
         if (includee._included_in) {
@@ -515,64 +494,51 @@
     }
   };
 
-  /*
-    Define a singleton method on the given klass
-
-        Opal.defs(Array, '$foo', function() {})
-
-    @param [Function] klass
-    @param [String] mid the method_id
-    @param [Function] body function body
-  */
-  Opal.defs = function(klass, mid, body) {
-    klass._smethods.push(mid);
-    klass[mid] = body;
-
-    var inherited = klass._inherited;
-    if (inherited && inherited.length) {
-      for (var i = 0, length = inherited.length, subclass; i < length; i++) {
-        subclass = inherited[i];
-        if (!subclass[mid]) {
-          Opal.defs(subclass, mid, body);
-        }
-      }
-    }
-  };
-
-  // Defines methods onto Object (which are then donated to bridged classes)
-  Object._defn = function (mid, body) {
-    this.prototype[mid] = body;
-    Opal.donate(this, [mid]);
-  };
-
   // Initialization
   // --------------
 
+  // Constructors for *instances* of core objects
   boot_defclass('BasicObject', BasicObject);
   boot_defclass('Object', Object, BasicObject);
   boot_defclass('Class', Class, Object);
 
-  Class.prototype = Function.prototype;
+  // Constructors for *classes* of core objects
+  var BasicObjectClass = boot_makemeta('BasicObject', BasicObject, Class);
+  var ObjectClass      = boot_makemeta('Object', Object, BasicObjectClass.constructor);
+  var ClassClass       = boot_makemeta('Class', Class, ObjectClass.constructor);
+
+  // Fix booted classes to use their metaclass
+  BasicObjectClass._klass = ClassClass;
+  ObjectClass._klass = ClassClass;
+  ClassClass._klass = ClassClass;
 
-  BasicObject.constructor = Object.constructor = Class.constructor = Class;
+  // Fix superclasses of booted classes
+  BasicObjectClass._super = null;
+  ObjectClass._super = BasicObjectClass;
+  ClassClass._super = ObjectClass;
 
+  // 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 = Object._included_in = [];
+  var bridged_classes = ObjectClass._included_in = [];
 
-  Opal.base = Object;
-  BasicObject._scope = Object._scope = Opal;
+  Opal.base = ObjectClass;
+  BasicObjectClass._scope = ObjectClass._scope = Opal;
   Opal.Module = Opal.Class;
-  Opal.Kernel = Object;
+  Opal.Kernel = ObjectClass;
 
-  create_scope(Opal, Class);
+  create_scope(Opal, ClassClass);
 
-  Object.prototype.toString = function() {
+  ObjectClass._proto.toString = function() {
     return this.$to_s();
   };
 
-  Opal.top = new Object;
+  Opal.top = new ObjectClass._alloc();
 
-  Opal.klass(Object, Object, 'NilClass', NilClass);
+  Opal.klass(ObjectClass, ObjectClass, 'NilClass', NilClass);
 
   var nil = Opal.nil = new NilClass;
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };