Improve the ability to find async functions.

This provides an optional filter function to aid with intelligently
locatating nested functions that are asynchronous.

Also better represents the original functions after wrapping.

Author: tbranyen

index.js

@@ -10,31 +10,70 @@ var callbacks = ["cb", "callback", "callback_", "done"];
  * inspecting the last argument in the parameter signature for a callback.
  *
  * @param {*} exports - Should be a function or an object, identity other.
+ * @param {Function} test - Optional function to identify async methods.
+ * @param {String} parentKeyName - Tracks the keyName in a digestable format.
  * @returns {*} exports - Identity.
  */
-function processExports(exports) {
+function processExports(exports, test, cached, parentKeyName) {
+  // Return early if this object has already been processed.
+  if (cached.indexOf(exports) > -1) {
+    return exports;
+  }
+
+  // Record this object in the cache.
+  cached.push(exports);
+
   // Pass through if not an object or function.
   if (typeof exports != "object" && typeof exports != "function") {
     return exports;
   }
 
+  var name = exports.name + "#";
+
   // If a function, simply return it wrapped.
   if (typeof exports === "function") {
-    return Promise.denodeify(exports);
+    // 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);
+    }
+
+    // Attach the augmented prototype.
+    wrapped.prototype = exports.prototype;
+
+    // Ensure attached properties to the previous function are accessible.
+    wrapped.__proto__ = exports;
+
+    return wrapped;
   }
 
   Object.keys(exports).map(function(keyName) {
     // Convert to values.
     return [keyName, exports[keyName]];
   }).filter(function(keyVal) {
+    var keyName = keyVal[0];
     var value = keyVal[1];
 
     // If an object is encountered, recursively traverse.
     if (typeof value === "object") {
-      processExports(exports);
+      processExports(exports, test, cached, keyName + ".");
     }
     // Filter to functions with callbacks only.
     else if (typeof value === "function") {
+      // If a filter function exists, use this to determine if the function
+      // is asynchronous.
+      if (test) {
+        // Pass the function itself, its keyName, and the parent keyName.
+        return test(value, keyName, parentKeyName);
+      }
+
       // If the callback name exists as the last argument, consider it an
       // asynchronous function.  Brittle? Fragile? Effective.
       if (callbacks.indexOf(args(value).slice(-1)[0]) > -1) {
@@ -45,8 +84,8 @@ function processExports(exports) {
     var keyName = keyVal[0];
     var func = keyVal[1];
 
-    // Assign the new function in place.
-    exports[keyName] = Promise.denodeify(func);
+    // Wrap this function and reassign.
+    exports[keyName] = processExports(func, test, cached, parentKeyName);
   });
 
   return exports;
@@ -56,9 +95,10 @@ function processExports(exports) {
  * Public API for Promisify.  Will resolve modules names using `require`.
  *
  * @param {*} name - Can be a module name, object, or function.
+ * @param {Function} test - Optional function to identify async methods.
  * @returns {*} exports - The resolved value from require or passed in value.
  */
-module.exports = function(name) {
+module.exports = function(name, test) {
   var exports = name;
 
   // If the name argument is a String, will need to resovle using the built in
@@ -69,7 +109,7 @@ module.exports = function(name) {
 
   // Iterate over all properties and find asynchronous functions to convert to
   // promises.
-  return processExports(exports);
+  return processExports(exports, test, []);
 };
 
 // Export callbacks to the module.