opal 0.3.20 → 0.3.21

data/core/proc.rb

@@ -14,17 +14,13 @@ class Proc < `Function`
   end
 
   def call(*args)
-    `this.apply(this._s, #{args})`
+    `#{self}.apply(null, [#{self}._s].concat(#{args}))`
   end
 
   def to_proc
     self
   end
 
-  def to_s
-    "#<Proc:0x0000000>"
-  end
-
   def lambda?
     `!!this.$lambda`
   end

data/core/range.rb

@@ -2,7 +2,7 @@ class Range
   include Enumerable
 
   %x{
-    Range.prototype._isRange = true;
+    Range_prototype._isRange = true;
 
     Opal.range = function(beg, end, exc) {
       var range         = new Range;
@@ -23,20 +23,20 @@ class Range
   def ==(other)
     return false unless Range === other
 
-    exclude_end? == other.exclude_end? && `this.begin` == other.begin && `this.end` == other.end
+    exclude_end? == other.exclude_end? && `#{self}.begin` == other.begin && `#{self}.end` == other.end
   end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def ===(obj)
-    `return obj >= this.begin && obj <= this.end`
+    `return obj >= #{self}.begin && (#{self}.exclude ? obj < #{self}.end : obj <= #{self}.end)`
   end
 
   def begin
-    `this.begin`
+    `#{self}.begin`
   end
 
   def cover?(value)
-    `this.begin` <= value && value <= (exclude_end? ? `this.end` - 1 : `this.end`)
+    `#{self}.begin` <= value && value <= (exclude_end? ? `#{self}.end` - 1 : `#{self}.end`)
   end
 
   def each
@@ -56,22 +56,22 @@ class Range
   end
 
   def end
-    `this.end`
+    `#{self}.end`
   end
 
   def eql?(other)
     return false unless Range === other
 
-    exclude_end? == other.exclude_end? && `this.begin`.eql?(other.begin) && `this.end`.eql?(other.end)
+    exclude_end? == other.exclude_end? && `#{self}.begin`.eql?(other.begin) && `#{self}.end`.eql?(other.end)
   end
 
   def exclude_end?
-    `this.exclude`
+    `#{self}.exclude`
   end
 
   # FIXME: currently hardcoded to assume range holds numerics
   def include?(val)
-    `return obj >= this.begin && obj <= this.end`
+    `return obj >= #{self}.begin && obj <= #{self}.end`
   end
 
   alias max end
@@ -87,10 +87,10 @@ class Range
   end
 
   def to_s
-    `this.begin + (this.exclude ? '...' : '..') + this.end`
+    `#{self}.begin + (#{self}.exclude ? '...' : '..') + #{self}.end`
   end
 
   def inspect
-    `this.begin + (this.exclude ? '...' : '..') + this.end`
+    `#{self}.begin + (#{self}.exclude ? '...' : '..') + #{self}.end`
   end
 end

data/core/regexp.rb

@@ -8,21 +8,21 @@ class Regexp < `RegExp`
   end
 
   def ==(other)
-    `other.constructor == RegExp && this.toString() === other.toString()`
+    `other.constructor == RegExp && #{self}.toString() === other.toString()`
   end
 
   def ===(obj)
-    `this.test(obj)`
+    `#{self}.test(obj)`
   end
 
   def =~(string)
     %x{
-      var result = this.exec(string);
+      var result = #{self}.exec(string);
 
       if (result) {
-        result.$to_s    = match_to_s;
-        result.$inspect = match_inspect;
-        result._real    = result._klass = #{ MatchData };
+        var matchdata = #{MatchData};
+        result.$k = matchdata;
+        result.$m = matchdata.$m_tbl;
 
         #{$~ = `result`};
       }
@@ -37,17 +37,17 @@ class Regexp < `RegExp`
   alias eql? ==
 
   def inspect
-    `this.toString()`
+    `#{self}.toString()`
   end
 
   def match(pattern)
     %x{
-      var result  = this.exec(pattern);
+      var result  = #{self}.exec(pattern);
 
       if (result) {
-        result.$to_s    = match_to_s;
-        result.$inspect = match_inspect;
-        result._real    = result._klass = #{ MatchData };
+        var matchdata = #{MatchData};
+        result.$k = matchdata;
+        result.$m = matchdata.$m_tbl;
 
         return #{$~ = `result`};
       }
@@ -58,19 +58,24 @@ class Regexp < `RegExp`
   end
 
   def to_s
-    `this.source`
+    `#{self}.source`
   end
-
-  %x{
-    function match_inspect() {
-      return "<#MatchData " + this[0].$inspect() + ">";
-    }
-
-    function match_to_s() {
-      return this[0];
-    }
-  }
 end
 
 class MatchData
+  def [](idx)
+    `#{self}[idx]`
+  end
+
+  def inspect
+    "#<MatchData #{self[0].inspect}>"
+  end
+
+  def to_a
+    `#{self}.slice()`
+  end
+
+  def to_s
+    self[0]
+  end
 end

data/core/runtime.js

@@ -28,6 +28,12 @@ Opal.alloc  = TopScope;
 // This is a useful reference to global object inside ruby files
 Opal.global = this;
 
+// Root method table (BasicObject inherits from this)
+function RootMethodTableConstructor() {}
+
+// The prototype (actual table) for root
+var RootMethodTable = RootMethodTableConstructor.prototype;
+
 // Minify common function calls
 var __hasOwn = Opal.hasOwnProperty;
 var __slice  = Opal.slice = Array.prototype.slice;
@@ -41,6 +47,34 @@ Opal.cvars = {};
 // Globals table
 Opal.gvars = {};
 
+var method_missing_mid = '';
+
+function method_missing_handler(self) {
+  var args = __slice.call(arguments, 1);
+  return self.$m.method_missing.apply(null, [self, method_missing_mid].concat(args));
+}
+
+Opal.mm = function(mid) {
+  method_missing_mid = mid;
+  return method_missing_handler;
+};
+
+Opal.send = function(recv, mid) {
+  var args = __slice.call(arguments, 2);
+  return (recv.$m[mid] || Opal.mm(mid)).apply(null, [recv].concat(args));
+};
+
+// define singleton method
+Opal.defs = function(obj, name, method) {
+  var singleton;
+
+  if (!(singleton = obj._singleton)) {
+    singleton = Opal.send(obj, 'singleton_class');
+  }
+
+  singleton.$m_tbl[name] = method;
+};
+
 // Runtime method used to either define a new class, or re-open an old
 // class. The base may be an object (rather than a class), which is
 // always the case when defining classes in the top level as the top
@@ -76,7 +110,7 @@ Opal.gvars = {};
 Opal.klass = function(base, superklass, id, constructor) {
   var klass;
   if (base._isObject) {
-    base = base._real;
+    base = base.$k;
   }
 
   if (superklass === null) {
@@ -87,15 +121,14 @@ Opal.klass = function(base, superklass, id, constructor) {
     klass = base._scope[id];
   }
   else {
-    if (!superklass._methods) {
+    if (!superklass.$m_tbl) {
       var bridged = superklass;
       superklass  = Object;
-      klass       = bridge_class(bridged);
-    }
-    else {
-      klass = boot_class(superklass, constructor);
+      constructor = bridged;
     }
 
+    klass = boot_class(superklass, constructor, bridged);
+
     klass._name = (base === Object ? id : base._name + '::' + id);
 
     var const_alloc   = function() {};
@@ -105,8 +138,8 @@ Opal.klass = function(base, superklass, id, constructor) {
 
     base[id] = base._scope[id] = klass;
 
-    if (superklass.$inherited) {
-      superklass.$inherited(klass);
+    if (superklass.$m.inherited) {
+      superklass.$m.inherited(superklass, klass);
     }
   }
 
@@ -117,14 +150,14 @@ Opal.klass = function(base, superklass, id, constructor) {
 Opal.module = function(base, id, constructor) {
   var klass;
   if (base._isObject) {
-    base = base._real;
+    base = base.$k;
   }
 
   if (__hasOwn.call(base._scope, id)) {
     klass = base._scope[id];
   }
   else {
-    klass = boot_module(constructor, id);
+    klass = boot_module(constructor);
     klass._name = (base === Object ? id : base._name + '::' + id);
 
     klass._isModule = true;
@@ -141,21 +174,11 @@ Opal.module = function(base, id, constructor) {
   return klass;
 }
 
-// Convert a ruby method name into a javascript identifier
-var mid_to_jsid = function(mid) {
-  return method_names[mid] ||
-    ('$' + mid.replace('!', '$b').replace('?', '$p').replace('=', '$e'));
-};
-
 // Utility function to raise a "no block given" error
 var no_block_given = function() {
   throw new Error('no block given');
 };
 
-// An array of all classes inside Opal. Used for donating methods from
-// Module and Class.
-var classes = Opal.classes = [];
-
 // Boot a base class (makes instances).
 var boot_defclass = function(id, constructor, superklass) {
   if (superklass) {
@@ -165,192 +188,140 @@ var boot_defclass = function(id, constructor, superklass) {
     constructor.prototype = new ctor();
   }
 
-  var prototype = constructor.prototype;
-
-  prototype.constructor = constructor;
-  prototype._isObject   = true;
-  prototype._klass      = constructor;
-  prototype._real       = constructor;
-
-  constructor._included_in  = [];
-  constructor._isClass      = true;
-  constructor._name         = id;
-  constructor._super        = superklass;
-  constructor._methods      = [];
-  constructor._smethods     = [];
-  constructor._isObject     = false;
-  constructor._subclasses   = [];
-
-  constructor._donate = __donate;
-  constructor._sdonate = __sdonate;
-
-  Opal[id] = constructor;
-
-  classes.push(constructor);
+  // method table constructor;
+  var m_ctr = function() {};
 
-  return constructor;
-};
+  if (superklass) {
+    // not BasicObject
+    m_ctr.prototype = new superklass.$m_ctr;
+  }
+  else {
+    // BasicObject
+    m_ctr.prototype = RootMethodTable;
+  }
 
-// Create generic class with given superclass.
-var boot_class = function(superklass, constructor) {
-  var ctor = function() {};
-      ctor.prototype = superklass.prototype;
+  var    m_tbl = m_ctr.prototype;
+  m_tbl.constructor = m_ctr;
 
-  constructor.prototype = new ctor();
   var prototype = constructor.prototype;
 
-  prototype._klass      = constructor;
-  prototype._real       = constructor;
   prototype.constructor = constructor;
+  prototype._isObject   = true;
+  prototype.$k      = constructor;
 
-  constructor._included_in  = [];
-  constructor._isClass      = true;
-  constructor._super        = superklass;
-  constructor._methods      = [];
-  constructor._isObject     = false;
-  constructor._klass        = Class;
-  constructor._real         = Class;
-  constructor._donate       = __donate
-  constructor._sdonate      = __sdonate;
-  constructor._subclasses   = [];
+  // method table of instances
+  prototype.$m          = m_tbl;
 
-  constructor.$eqq$ = module_eqq;
+  // constructor._included_in  = [];
+  // constructor._isClass      = true;
+  // constructor._name         = id;
+  // constructor._super        = superklass;
+  // constructor._methods      = [];
+  // constructor._smethods     = [];
+  constructor._isObject     = false;
 
-  superklass._subclasses.push(constructor);
+  // method table for class methods
+  // constructor.$m            = c_tbl;
+  // method table of instances
+  constructor.$m_tbl        = m_tbl;
+  // method table constructor of instances
+  constructor.$m_ctr        = m_ctr;
 
-  var smethods;
+  constructor.$s = superklass;
 
-  smethods = superklass._smethods.slice();
+  constructor._name         = id;
 
-  constructor._smethods = smethods;
-  for (var i = 0, length = smethods.length; i < length; i++) {
-    var m = smethods[i];
-    constructor[m] = superklass[m];
-  }
+  constructor._donate = __donate;
 
-  classes.push(constructor);
+  Opal[id] = constructor;
 
   return constructor;
 };
 
-var boot_module = function(constructor, id) {
-  var ctor = function() {};
-      ctor.prototype = Module.prototype;
+var boot_defmeta = function(constructor, parent_m_tbl) {
+  var m_ctr = function(){};
+  m_ctr.prototype = new parent_m_tbl;
 
-  constructor.prototype = new ctor();
-  var prototype = constructor.prototype;
-
-  prototype.constructor = constructor;
+  var m_tbl = m_ctr.prototype;
+  m_tbl.constructor = m_ctr;
 
-  constructor._isModule = true;
-  constructor._name     = id;
-  constructor._methods  = [];
-  constructor._smethods = [];
-  constructor._klass    = Module;
-  constructor._donate   = __donate;
-  constructor._sdonate  = function(){};
-
-  classes.push(constructor);
-
-  var smethods = constructor._smethods = Module._methods.slice();
-  for (var i = 0, length = smethods.length; i < length; i++) {
-    var m = smethods[i];
-    constructor[m] = Object[m];
-  }
+  constructor.$m = m_tbl;
 
   return constructor;
 };
 
-var bridge_class = function(constructor) {
-  constructor.prototype._klass = constructor;
-  constructor.prototype._real = constructor;
-
-  constructor._included_in  = [];
-  constructor._isClass      = true;
-  constructor._super        = Object;
-  constructor._klass        = Class;
-  constructor._methods      = [];
-  constructor._smethods     = [];
-  constructor._isObject     = false;
-  constructor._subclasses   = [];
-
-  constructor._donate = function(){};
-  constructor._sdonate = __sdonate;
+// Create generic class with given superclass.
+var boot_class = function(superklass, constructor, bridged) {
+  // method table constructor
+  function m_ctr(){};
+  m_ctr.prototype = new superklass.$m_tbl.constructor;
+  
+  // method table itself
+  var m_tbl = m_ctr.prototype;
+  m_tbl.constructor = m_ctr;
 
-  constructor.$eqq$ = module_eqq;
+  var prototype = constructor.prototype;
 
-  var smethods = constructor._smethods = Module._methods.slice();
-  for (var i = 0, length = smethods.length; i < length; i++) {
-    var m = smethods[i];
-    constructor[m] = Object[m];
+  if (!bridged) {
+    constructor.prototype = new superklass;
+    prototype = constructor.prototype;
+    prototype.constructor = constructor;
   }
 
-  bridgedClasses.push(constructor);
-  classes.push(constructor);
+  prototype.$k = constructor; // instances need to know their class
+  prototype.$m = m_tbl;       // all instances get method table
 
-  var allocator = function(initializer) {
-    var result, kls = this, methods = kls._methods, proto = kls.prototype;
+  prototype._isObject = true;
 
-    if (initializer == null) {
-      result = new constructor
-    }
-    else {
-      result = new constructor(initializer);
-    }
+  constructor.$m_ctr  = m_ctr;
+  constructor.$m_tbl  = m_tbl;
 
-    if (kls === constructor) {
-      return result;
-    }
+  // FIXME: need c_ctr
+  var c_ctr = function(){};
+  c_ctr.prototype = new superklass.$m.constructor;
 
-    result._klass = kls;
-    result._real  = kls;
+  var c_tbl = c_ctr.prototype;
+  c_tbl.constructor = c_ctr;
+  constructor.$m = c_tbl;
 
-    for (var i = 0, length = methods.length; i < length; i++) {
-      var method = methods[i];
-      result[method] = proto[method];
-    }
 
-    return result;
-  };
+  constructor.$k      = Class;
+  constructor.$s      = superklass;
 
-  var table = Object.prototype, methods = Object._methods;
+  constructor._donate       = __donate
+  // constructor._included_in  = [];
+  // constructor._isClass      = true;
+  // constructor._super        = superklass;
+  // constructor._methods      = [];
+  constructor._isObject     = false;
+  // constructor._klass        = Class;
+  
+  return constructor;
+};
 
-  for (var i = 0, length = methods.length; i < length; i++) {
-    var m = methods[i];
-    constructor.prototype[m] = table[m];
-  }
+var boot_module = function(constructor) {
+  // constructor.$m_ctr  = m_ctr;
+  constructor.$m_tbl  = {};     // simple method table for modules
 
-  constructor.$allocate = allocator;
+  // FIXME: need c_ctr
+  var c_ctr = function(){};
+  c_ctr.prototype = new Module.$m.constructor;
+  
+  var c_tbl = c_ctr.prototype;
+  constructor.$m = c_tbl;
 
-  constructor._smethods.push('$allocate');
 
-  return constructor;
-};
+  constructor.$k      = Class;
 
-// An IClass is a fake class created when a module is included into a
-// class or another module. It is a "copy" of the module that is then
-// injected into the hierarchy so it appears internally that the iclass
-// is the super of the class instead of the old super class. This is
-// actually hidden from the ruby side of things, but allows internal
-// features such as super() etc to work. All useful properties from the
-// module are copied onto this iclass.
-//
-// @param [RubyClass] klass the klass which is including the module
-// @param [RubyModule] module the module which is being included
-// @return [RubyIClass] returns newly created iclass
-var define_iclass = function(klass, module) {
-  var iclass = {
-    _proto:     module._proto,
-    _super:     klass._super,
-    _isIClass:  true,
-    _klass:     module,
-    _name:      module._name,
-    _methods:   module._methods
-  };
-
-  klass._super = iclass;
-
-  return iclass;
+  constructor._donate       = __donate
+  // constructor._included_in  = [];
+  // constructor._isClass      = true;
+  // constructor._super        = superklass;
+  // constructor._methods      = [];
+  constructor._isObject     = false;
+  // constructor._klass        = Class;
+  
+  return constructor;
 };
 
 // Initialization
@@ -360,79 +331,39 @@ boot_defclass('BasicObject', BasicObject);
 boot_defclass('Object', Object, BasicObject);
 boot_defclass('Class', Class, Object);
 
-Class.prototype = Function.prototype;
-
-BasicObject._klass = Object._klass = Class._klass = Class;
-
-Module._donate = function(defined) {
-  // ...
-};
-
-// Implementation of Module#===
-function module_eqq(object) {
-  if (object == null) {
-    return false;
-  }
-
-  var search = object._klass;
+boot_defmeta(BasicObject, Class.$m_tbl.constructor);
+boot_defmeta(Object, BasicObject.$m.constructor);
+boot_defmeta(Class, Object.$m.constructor);
 
-  while (search) {
-    if (search === this) {
-      return true;
-    }
-
-    search = search._super;
-  }
-
-  return false;
-}
+BasicObject.$k = Object.$k = Class.$k = Class;
 
 // Donator for all 'normal' classes and modules
-function __donate(defined, indirect) {
-  var methods = this._methods, included_in = this.$included_in;
-
-  if (!indirect) {
-    this._methods = methods.concat(defined);
-  }
+function __donate(defined) {
+  var included_in = this.$included_in, m_tbl = this.$m_tbl;
 
   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.$m_tbl;
 
-      for (var j = 0, jj = defined.length; j < jj; j++) {
-        var method = defined[j];
-        dest[method] = this.prototype[method];
+      for (var idx = 0, jj = defined.length; idx < jj; idx++) {
+        var method = defined[idx];
+        dest[method] = m_tbl[method];
       }
 
       if (includee.$included_in) {
-        includee._donate(defined, true);
+        // includee._donate(defined, true);
       }
     }
 
   }
 }
 
-// Donator for singleton (class) methods
-function __sdonate(defined) {
-  var smethods = this._smethods, subclasses = this._subclasses;
-
-  this._smethods = smethods.concat(defined);
-
-  for (var i = 0, length = subclasses.length; i < length; i++) {
-    var s = subclasses[i];
-
-    for (var j = 0, jj = defined.length; j < jj; j++) {
-    }
-  }
-}
-
-var bridgedClasses = Object.$included_in = [];
-BasicObject.$included_in = bridgedClasses;
+var bridged_classes = Object.$included_in = [];
+BasicObject.$included_in = bridged_classes;
 
 BasicObject._scope = Object._scope = Opal;
 Opal.Module = Opal.Class;
-Opal.Kernel = Object;
 
 var class_const_alloc = function(){};
 var class_const_scope = new TopScope();
@@ -440,7 +371,7 @@ class_const_scope.alloc = class_const_alloc;
 Class._scope = class_const_scope;
 
 Object.prototype.toString = function() {
-  return this.$to_s();
+  return this.$m.to_s(this, 'to_s');
 };
 
 Opal.top = new Object;