[snapshot]

elia · elia · commit 7d7ef7fb1aa6 · 2014-09-11T23:51:11.000+02:00
diff --git a/benchmarks/class_boundaries.coffee b/benchmarks/class_boundaries.coffee
@@ -0,0 +1,38 @@
+
+rb_create_class = (name, superclass = null) ->
+  class TopProto
+  class BottomProto extends TopProto
+
+  rb_klass = {
+    top_proto: TopProto
+    bottom_proto: BottomProto
+    superclass: null
+    included_modules: []
+  }
+
+  rb_update_inheritance_chain(rb_klass)
+
+  return rb_klass
+
+
+rb_include = (klass, module) ->
+  klass.included_modules.push module
+  klass.update_modules
+
+rb_update_inheritance_chain(klass)
+  module_copies_list = [klass.top_proto]
+  klass.included_modules.each (module)->
+    module_copy = duplicate_module(module)
+    set_super_prototype(base: module_copy, parent: module_copies_list.last())
+  set_super_prototype(base: klass.bottom_proto, parent: module_copies_list.last())
+
+set_super_prototype(kwargs)
+  base = kwargs.base
+  parent = kwargs.parent
+  base.prototype
+
+duplicate_module(module)->
+  module_copy = {}
+  for method in module
+    module_copy[method] = module[method]
+  module_copy
diff --git a/opal/corelib/class.rb b/opal/corelib/class.rb
@@ -8,9 +8,9 @@ def self.new(sup = Object, &block)
       }
 
       function AnonClass(){};
-      var klass       = Opal.boot(sup, AnonClass)
-      klass.$$name     = nil;
-      klass.$$parent  = sup;
+      var klass      = Opal.boot(sup, AnonClass)
+      klass.$$name   = nil;
+      klass.$$parent = sup;
 
       // inherit scope from parent
       $opal.create_scope(sup.$$scope, klass);
diff --git a/opal/corelib/module.rb b/opal/corelib/module.rb
@@ -77,56 +77,8 @@ def ancestors
   end
 
   def append_features(klass)
-    %x{
-      var module   = self,
-          included = klass.$$inc;
-
-      // check if this module is already included in the klass
-      for (var i = 0, length = included.length; i < length; i++) {
-        if (included[i] === module) {
-          return;
-        }
-      }
-
-      included.push(module);
-      module.$$dep.push(klass);
-
-      // iclass
-      var iclass = {
-        name: module.$$name,
-
-        $$proto:   module.$$proto,
-        $$parent: klass.$$parent,
-        __iclass: true
-      };
-
-      klass.$$parent = iclass;
-
-      var donator   = module.$$proto,
-          prototype = klass.$$proto,
-          methods   = module.$$methods;
-
-      for (var i = 0, length = methods.length; i < length; i++) {
-        var method = methods[i];
-
-        if (prototype.hasOwnProperty(method) && !prototype[method].$$donated) {
-          // if the target class already has a method of the same name defined
-          // and that method was NOT donated, then it must be a method defined
-          // by the class so we do not want to override it
-        }
-        else {
-          prototype[method] = donator[method];
-          prototype[method].$$donated = true;
-        }
-      }
-
-      if (klass.$$dep) {
-        $opal.donate(klass, methods.slice(), true);
-      }
-
-      $opal.donate_constants(module, klass);
-    }
-
+    raise TypeError unless Class === klass
+    `$opal.rb_include_module(klass, self)`
     self
   end
 
diff --git a/opal/corelib/runtime.js b/opal/corelib/runtime.js
@@ -1,6 +1,6 @@
 (function(undefined) {
   // The Opal object that is exposed globally
-  var Opal = this.Opal = {};
+  var Opal = this.Opal = {}, $opal = Opal;
 
   // All bridged classes - keep track to donate methods from Object
   var bridged_classes = Opal.bridged_classes = [];
@@ -395,6 +395,67 @@
     }
   };
 
+
+  function copy_methods(source, target) {
+    for (method in source) {
+      if ($hasOwn.call(source, method)) {
+        target[method] = source[method];
+      }
+    }
+  }
+
+
+  // iclass:
+  //    The ghost class that sits in the inheritance chain
+  //    of a class that has included the module.
+  //    It has all module methods.
+  //
+  function boot_iclass(module, klass_parent_ctor) {
+    var iclass_proto = new klass_parent_ctor();
+    copy_methods(module.$$proto, iclass_proto)
+    var iclass = {
+      name:        module.$$name,
+      $$proto:     iclass_proto,
+      $$iclass_of: module
+    };
+
+    return iclass;
+  }
+
+
+  Opal.rb_include_module = function rb_include_module(klass, module) {
+    var included = klass.$$inc;
+
+  	// ignore if the module included already in superclasses
+    for (var i = 0, length = included.length; i < length; i++) {
+      if (included[i] === module) {
+        return;
+      }
+    }
+
+    included.push(module);
+    module.$$dep.push(klass);
+
+    var iclass_parent_ctor = function() {};
+        iclass_parent_ctor.prototype = klass.$$parent.$$proto;
+
+    var iclass = boot_iclass(module, iclass_parent_ctor)
+
+    iclass.$$parent = klass.$$parent;
+    klass.$$parent  = iclass;
+    klass.$$proto.constructor.prototype = iclass.$$proto
+
+    // var donator   = module.$$proto,
+    //     prototype = klass.$$proto,
+    //     methods   = module.$$methods;
+    //
+    if (klass.$$dep) {
+      $opal.donate(iclass, methods.slice(), true);
+    }
+
+    $opal.donate_constants(module, klass);
+  };
+
   /*
    * Methods stubs are used to facilitate method_missing in opal. A stub is a
    * placeholder function which just calls `method_missing` on the receiver.
@@ -687,26 +748,17 @@
   /**
    * Donate methods for a class/module
    */
-  Opal.donate = function(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) {
-          Opal.donate(includee, defined, true);
+  Opal.donate = function(module, methods) {
+    var deps = module.$$dep, target, proto = module.$$proto;
+    console.log('DONATE', module.$$name, methods, deps == null);
+    if (deps == null) return;
+
+    for (method in proto) {
+      if (!method.$$donated && $hasOwn.call(proto, method)) {
+        method.$$donated = true
+        for (var i = deps.length - 1; i >= 0; i--) {
+          target = deps[i].$$proto;
+          target[method] = proto[method];
         }
       }
     }
diff --git a/puts.js b/puts.js
