Merge pull request #14 from jon-hall/feature/unwrapped-function-cache-bug

Fix issue with async functions being cached as-is, and so not getting…

Author: maxkorp

index.js

@@ -18,10 +18,22 @@ function processExports(exports, test, cached, parentKeyName) {
   // Return early if this object has already been processed.
   if (cached.indexOf(exports) > -1) {
     return exports;
+  } else if(typeof exports === "function") {
+    // For functions, cache the original and wrapped version, else non-wrapped
+    // functions end up being given back when encountered multiple times.
+    var cacheResult = cached.filter(function(c) {
+      return c.original === exports;
+    });
+
+    if(cacheResult.length) {
+      return cacheResult[0].wrapped;
+    }
   }
 
-  // Record this object in the cache.
-  cached.push(exports);
+  // Record this object in the cache, if it is not a function.
+  if(typeof exports != "function") {
+    cached.push(exports);
+  }
 
   // Pass through if not an object or function.
   if (typeof exports != "object" && typeof exports != "function") {
@@ -32,14 +44,21 @@ function processExports(exports, test, cached, parentKeyName) {
 
   // If a function, simply return it wrapped.
   if (typeof exports === "function") {
+    // Assign the new function in place.
+    var wrapped = Promise.denodeify(exports);
+
+    // Push the wrapped function onto the cache before processing properties,
+    // else a cyclical function property causes a stack overflow.
+    cached.push({
+      original: exports,
+      wrapped: wrapped
+    });
+
     // Find properties added to functions.
     for (var keyName in exports) {
       exports[keyName] = processExports(exports[keyName], test, cached, name);
     }
 
-    // Assign the new function in place.
-    var wrapped = Promise.denodeify(exports);
-
     // Find methods on the prototype, if there are any.
     if (Object.keys(exports.prototype).length) {
       processExports(exports.prototype, test, cached, name);

test/index.js

@@ -104,5 +104,37 @@ describe("Promisify", function() {
 
       return new Test().a();
     });
+
+    it("can deal with the same async function being present in an object more than once", function() {
+      var a = {
+        a: function(d, cb) {
+          cb && cb(null, d);
+        }
+      };
+
+      a.b = a.a;
+
+      a = promisify(a);
+
+      assert(a.a(5) !== undefined, "function not wrapped");
+      assert(typeof a.a(5).then === "function", "function not wrapped");
+      assert(a.b(5) !== undefined, "duplicate function not wrapped");
+      assert(typeof a.b(5).then === "function", "duplicate function not wrapped");
+    });
+
+    it("can deal with cyclical function properties", function() {
+      var a = function(d, cb) {
+        cb && cb(null, d);
+      };
+
+      a.a = a;
+
+      a = promisify(a);
+
+      assert(a(5) !== undefined, "function not wrapped");
+      assert(typeof a(5).then === "function", "function not wrapped");
+      assert(a.a(5) !== undefined, "function property not wrapped");
+      assert(typeof a.a(5).then === "function", "function property not wrapped");
+    });
   });
 });