opal · Nov 27, 2014 · Nov 27, 2014
Showing with 63 additions and 10 deletions.

+20 −9 lib/opal/nodes/def.rb

+43 −1 opal/corelib/runtime.js
diff --git a/lib/opal/nodes/def.rb b/lib/opal/nodes/def.rb
@@ -99,26 +99,37 @@ def compile
         if recvr
           unshift 'Opal.defs(', recv(recvr), ", '$#{mid}', "
           push ')'
-        elsif scope.class? and %w(Object BasicObject).include?(scope.name)
+        elsif uses_defn?(scope)
           wrap "Opal.defn(self, '$#{mid}', ", ')'
-        elsif scope.module?
-          wrap "Opal.defn(self, '$#{mid}', ", ")"
-        elsif scope.class_scope?
-          scope.methods << "$#{mid}"
+        elsif scope.class?
           unshift "#{scope.proto}#{jsid} = "
-        elsif scope.iter?
-          wrap "Opal.defn(self, '$#{mid}', ", ')'
-        elsif scope.type == :sclass
+        elsif scope.sclass?
           unshift "self.$$proto#{jsid} = "
         elsif scope.top?
           unshift "Opal.Object.$$proto#{jsid} = "
         else
-          unshift "def#{jsid} = "
+          raise "Unknown def type for `#{jsid}'"
         end
 
         wrap '(', ", nil) && '#{mid}'" if expr?
       end
 
+      # Simple helper to check whether this method should be defined through
+      # `Opal.defn()` runtime helper.
+      #
+      # @param [Opal::Scope] scope
+      # @returns [Boolean]
+      #
+      def uses_defn?(scope)
+        if scope.iter? or scope.module?
+          true
+        elsif scope.class? and %w(Object BasicObject).include?(scope.name)
+          true
+        else
+          false
+        end
+      end
+
       # Returns code used in debug mode to check arity of method call
       def arity_check(args, opt, splat, block_name, mid)
         meth = mid.to_s.inspect

diff --git a/opal/corelib/runtime.js b/opal/corelib/runtime.js
@@ -911,6 +911,48 @@
     }
   };
 
+  /**
+    Donate a newly defined method defined on a module.
+
+    @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 donate_module_defn(module, jsid, body) {
+    var included_in = module.$$dep;
+
+    module.$$methods = module.$$methods.concat([jsid]);
+
+    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
+          // FIXME: we should resolve the order of modules to check if we
+          // should define it
+          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) {
+          Opal.donate(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
@@ -951,7 +993,7 @@
   Opal.defn = function(obj, jsid, body) {
     if (obj.$$is_mod) {
       obj.$$proto[jsid] = body;
-      Opal.donate(obj, [jsid]);
+      donate_module_defn(obj, jsid, body);
 
       body.$$owner = obj;