Merge 82971d7 into ee8dbce

README.md

@@ -11,7 +11,7 @@ Power Assert feature enhancer for assert function/object.
 
 DESCRIPTION
 ---------------------------------------
-`empower` is a core module of [power-assert](http://github.com/twada/power-assert) family. `empower` enhances standard `assert` function or any assert-like object to work with power-assert feature added code instrumented by [espower](http://github.com/twada/espower). `empower` module also provides a default formatter for power-assert output.
+`empower` is a core module of [power-assert](http://github.com/twada/power-assert) family. `empower` enhances standard `assert` function or any assert-like object to work with power-assert feature added code instrumented by [espower](http://github.com/twada/espower).
 
 
 `empower` works with standard `assert` function (best fit with [Mocha](http://visionmedia.github.io/mocha/)), and also supports assert-like objects provided by various testing frameworks such as [QUnit](http://qunitjs.com/) or [nodeunit](https://github.com/caolan/nodeunit).

bower.json

@@ -1,6 +1,6 @@
 {
     "name": "empower",
-    "version": "0.2.1",
+    "version": "0.3.0-dev",
     "main": [
         "lib/empower.js",
         "lib/power-assert-formatter.js"

lib/empower.js

@@ -17,21 +17,19 @@
 
     // using returnExports UMD pattern
     if (typeof define === 'function' && define.amd) {
-        define(['./power-assert-formatter'], factory);
+        define(factory);
     } else if (typeof exports === 'object') {
-        module.exports = factory(require('./power-assert-formatter'));
+        module.exports = factory();
     } else {
-        root.empower = factory(root.powerAssertFormatter);
+        root.empower = factory();
     }
-}(this, function (defaultFormatter) {
+}(this, function () {
     'use strict';
 
 
     function defaultOptions () {
         return {
             destructive: false,
-            formatter: defaultFormatter,
-            lineSeparator: '\n',
             targetMethods: {
                 oneArg: [
                     'ok'
@@ -52,10 +50,11 @@
     /**
      * Enhance Power Assert feature to assert function/object.
      * @param assert target assert function or object to enhance
+     * @param formatter power assert format function
      * @param options enhancement options
      * @return enhanced assert function/object
      */
-    function empower (assert, options) {
+    function empower (assert, formatter, options) {
         var typeOfAssert = (typeof assert),
             config;
         if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
@@ -67,9 +66,9 @@
         config = extend(defaultOptions(), (options || {}));
         switch (typeOfAssert) {
         case 'function':
-            return empowerAssertFunction(assert, config);
+            return empowerAssertFunction(assert, formatter, config);
         case 'object':
-            return empowerAssertObject(assert, config);
+            return empowerAssertObject(assert, formatter, config);
         default:
             throw new Error('Cannot be here');
         }
@@ -81,21 +80,21 @@
     }
 
 
-    function empowerAssertObject (assertObject, config) {
+    function empowerAssertObject (assertObject, formatter, config) {
         if (typeof assertObject.ok !== 'function') {
             throw new TypeError('empower target object should be respond to \'ok\' method.');
         }
-        var enhancement = enhance(assertObject, config),
+        var enhancement = enhance(assertObject, formatter, config),
             target = config.destructive ? assertObject : Object.create(assertObject);
         return extend(target, enhancement);
     }
 
 
-    function empowerAssertFunction (assertFunction, config) {
+    function empowerAssertFunction (assertFunction, formatter, config) {
         if (config.destructive) {
             throw new Error('cannot use destructive:true to function.');
         }
-        var enhancement = enhance(assertFunction, config),
+        var enhancement = enhance(assertFunction, formatter, config),
             powerAssert = function powerAssert (context, message) {
                 enhancement.ok(context, message);
             };
@@ -104,7 +103,7 @@
     }
 
 
-    function enhance (target, config) {
+    function enhance (target, formatter, config) {
         var events = [],
             enhancement = {};
 
@@ -121,12 +120,12 @@
 
         config.targetMethods.oneArg.forEach(function (methodName) {
             if (typeof target[methodName] === 'function') {
-                enhancement[methodName] = decorateOneArg(bind(target[methodName], target), config);
+                enhancement[methodName] = decorateOneArg(target[methodName].bind(target), formatter);
             }
         });
         config.targetMethods.twoArgs.forEach(function (methodName) {
             if (typeof target[methodName] === 'function') {
-                enhancement[methodName] = decorateTwoArgs(bind(target[methodName], target), config);
+                enhancement[methodName] = decorateTwoArgs(target[methodName].bind(target), formatter);
             }
         });
 
@@ -141,19 +140,19 @@
     }
 
 
-    function decorateOneArg (baseAssert, config) {
+    function decorateOneArg (baseAssert, formatter) {
         return function (value, message) {
             var context;
             if (! isEspoweredValue(value)) {
                 return baseAssert(value, message);
             }
             context = value.powerAssertContext;
-            return baseAssert(context.value, buildPowerAssertText(message, context, config));
+            return baseAssert(context.value, buildPowerAssertText(message, context, formatter));
         };
     }
 
 
-    function decorateTwoArgs (baseAssert, config) {
+    function decorateTwoArgs (baseAssert, formatter) {
         return function (arg1, arg2, message) {
             var context, val1, val2;
             if (!(isEspoweredValue(arg1) || isEspoweredValue(arg2))) {
@@ -178,13 +177,13 @@
                 val2 = arg2;
             }
 
-            return baseAssert(val1, val2, buildPowerAssertText(message, context, config));
+            return baseAssert(val1, val2, buildPowerAssertText(message, context, formatter));
         };
     }
 
 
-    function buildPowerAssertText (message, context, config) {
-        var powerAssertText = config.formatter.format(context).join(config.lineSeparator);
+    function buildPowerAssertText (message, context, formatter) {
+        var powerAssertText = formatter(context);
         return message ? message + ' ' + powerAssertText : powerAssertText;
     }
 
@@ -205,24 +204,6 @@
     }
 
 
-    // borrowed from https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
-    function bind (aFunction, oThis) {
-        if (typeof aFunction !== 'function') {
-            throw new TypeError('bind - what is trying to be bound is not callable');
-        }
-        var aArgs = Array.prototype.slice.call(arguments, 2),
-            fToBind = aFunction,
-            NOP = function () {},
-            fBound = function () {
-                return fToBind.apply(((aFunction instanceof NOP) && oThis) ? aFunction : oThis,
-                                     aArgs.concat(Array.prototype.slice.call(arguments)));
-            };
-        NOP.prototype = aFunction.prototype;
-        fBound.prototype = new NOP();
-        return fBound;
-    }
-
-
     // using returnExports UMD pattern with substack pattern
     empower.defaultOptions = defaultOptions;
     return empower;

package.json

@@ -1,7 +1,7 @@
 {
   "name": "empower",
   "description": "Power Assert feature enhancer for assert function/object",
-  "version": "0.2.1",
+  "version": "0.3.0-dev",
   "keywords": [
     "test",
     "assert",
@@ -29,7 +29,6 @@
     "espower": "~0.3.0",
     "esprima": "~1.0.4",
     "escodegen": "~1.0.1",
-    "coffee-script-redux": "2.0.0-beta7",
     "grunt": "~0.4.2",
     "grunt-mocha-test": "~0.8.1",
     "grunt-contrib-jshint": "~0.7.2",