refactor(empower): integrate decorateOneArg and decorateTwoArgs into decorateArgs function

Author: twada

lib/enhance.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var escallmatch = require('escallmatch'),
+    slice = Array.prototype.slice,
     isPhantom = typeof window !== 'undefined' && typeof window.callPhantom === 'function';
 
 
@@ -44,7 +45,8 @@ function enhance (target, formatter, config) {
                 throw f;
             }
         },
-        enhancement = (typeof target === 'function') ? decorateOneArg(target, target, doPowerAssert) : {},
+        // check function signiture
+        enhancement = (typeof target === 'function') ? decorateArgs(1, target, target, doPowerAssert) : {},
         events = [];
 
     function buildPowerAssertText (message, context) {
@@ -78,10 +80,10 @@ function enhance (target, formatter, config) {
         if (methodName && typeof target[methodName] === 'function') {
             switch (len) {
             case 1:
-                enhancement[methodName] = decorateOneArg(target, target[methodName], doPowerAssert);
+                enhancement[methodName] = decorateArgs(len, target, target[methodName], doPowerAssert);
                 break;
             case 2:
-                enhancement[methodName] = decorateTwoArgs(target, target[methodName], doPowerAssert);
+                enhancement[methodName] = decorateArgs(len, target, target[methodName], doPowerAssert);
                 break;
             default:
                 throw new Error('not supported');
@@ -108,65 +110,38 @@ function isEspoweredValue (value) {
 }
 
 
-function decorateOneArg (target, baseAssert, doPowerAssert) {
-    return function (arg1, message) {
-        var context, val1;
-        if (! isEspoweredValue(arg1)) {
-            return baseAssert.apply(target, [arg1, message]);
-        }
-        val1 = arg1.powerAssertContext.value;
-        context = {
-            source: arg1.source,
-            args: []
-        };
-        context.args.push({
-            value: val1,
-            events: arg1.powerAssertContext.events
-        });
-        return doPowerAssert(baseAssert, [val1], message, context);
-    };
-}
+function decorateArgs (numNonMessageArgs, target, baseAssert, doPowerAssert) {
+    return function () {
+        var context, message, args = slice.apply(arguments);
 
-
-function decorateTwoArgs (target, baseAssert, doPowerAssert) {
-    return function (arg1, arg2, message) {
-        var context, val1, val2;
-        if (!(isEspoweredValue(arg1) || isEspoweredValue(arg2))) {
-            return baseAssert.apply(target, [arg1, arg2, message]);
+        if (args.every(function (arg) { return !isEspoweredValue(arg); })) {
+            return baseAssert.apply(target, args);
         }
 
-        if (isEspoweredValue(arg1)) {
-            context = {
-                source: arg1.source,
-                args: []
-            };
-            context.args.push({
-                value: arg1.powerAssertContext.value,
-                events: arg1.powerAssertContext.events
-            });
-            val1 = arg1.powerAssertContext.value;
-        } else {
-            val1 = arg1;
-        }
-
-        if (isEspoweredValue(arg2)) {
-            if (!isEspoweredValue(arg1)) {
+        var values = args.slice(0, numNonMessageArgs).map(function (arg, idx) {
+            if (!isEspoweredValue(arg)) {
+                return arg;
+            }
+            if (!context) {
                 context = {
-                    source: arg2.source,
+                    source: arg.source,
                     args: []
                 };
             }
             context.args.push({
-                value: arg2.powerAssertContext.value,
-                events: arg2.powerAssertContext.events
+                value: arg.powerAssertContext.value,
+                events: arg.powerAssertContext.events
             });
-            val2 = arg2.powerAssertContext.value;
-        } else {
-            val2 = arg2;
+            return arg.powerAssertContext.value;
+        });
+
+        if (numNonMessageArgs === (args.length - 1)) {
+            message = args[args.length - 1];
         }
 
-        return doPowerAssert(baseAssert, [val1, val2], message, context);
+        return doPowerAssert(baseAssert, values, message, context);
     };
 }
 
+
 module.exports = enhance;