Initial commit

node_modules/empower-core/index.js

@@ -0,0 +1,79 @@
+/**
+ * empower-core - Power Assert feature enhancer for assert function/object.
+ *
+ * https://github.com/twada/power-assert-runtime/packages/empower-core
+ *
+ * Copyright (c) 2013-2018 Takuto Wada
+ * Licensed under the MIT license.
+ *   https://github.com/twada/power-assert-runtime/blob/master/LICENSE
+ */
+var create = require('core-js/library/fn/object/create');
+var assign = require('core-js/library/fn/object/assign');
+var defaultOptions = require('./lib/default-options');
+var Decorator = require('./lib/decorator');
+var define = require('./lib/define-properties');
+var slice = Array.prototype.slice;
+
+/**
+ * Enhance Power Assert feature to assert function/object.
+ * @param assert target assert function or object to enhance
+ * @param options enhancement options
+ * @return enhanced assert function/object
+ */
+function empowerCore (assert, options) {
+    var typeOfAssert = (typeof assert);
+    var enhancedAssert;
+    if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
+        throw new TypeError('empower-core argument should be a function or object.');
+    }
+    if (isEmpowered(assert)) {
+        return assert;
+    }
+    switch (typeOfAssert) {
+    case 'function':
+        enhancedAssert = empowerAssertFunction(assert, options);
+        break;
+    case 'object':
+        enhancedAssert = empowerAssertObject(assert, options);
+        break;
+    default:
+        throw new Error('Cannot be here');
+    }
+    define(enhancedAssert, { _empowered: true });
+    return enhancedAssert;
+}
+
+function empowerAssertObject (assertObject, options) {
+    var config = assign(defaultOptions(), options);
+    var target = config.destructive ? assertObject : create(assertObject);
+    var decorator = new Decorator(target, config);
+    return assign(target, decorator.enhancement());
+}
+
+function empowerAssertFunction (assertFunction, options) {
+    var config = assign(defaultOptions(), options);
+    if (config.destructive) {
+        throw new Error('cannot use destructive:true to function.');
+    }
+    var decorator = new Decorator(assertFunction, config);
+    var enhancement = decorator.enhancement();
+    var powerAssert;
+    if (typeof enhancement === 'function') {
+        powerAssert = function powerAssert () {
+            return enhancement.apply(null, slice.apply(arguments));
+        };
+    } else {
+        powerAssert = function powerAssert () {
+            return assertFunction.apply(null, slice.apply(arguments));
+        };
+    }
+    assign(powerAssert, assertFunction);
+    return assign(powerAssert, enhancement);
+}
+
+function isEmpowered (assertObjectOrFunction) {
+    return assertObjectOrFunction._empowered;
+}
+
+empowerCore.defaultOptions = defaultOptions;
+module.exports = empowerCore;

node_modules/empower-core/lib/decorate.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var some = require('core-js/library/fn/array/some');
+var map = require('core-js/library/fn/array/map');
+
+function decorate (callSpec, decorator) {
+    var numArgsToCapture = callSpec.numArgsToCapture;
+
+    return function decoratedAssert () {
+        var context, message, hasMessage = false;
+
+        // see: https://github.com/twada/empower-core/pull/8#issue-127859465
+        // see: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+        var args = new Array(arguments.length);
+        for(var i = 0; i < args.length; ++i) {
+            args[i] = arguments[i];
+        }
+
+        if (numArgsToCapture === (args.length - 1)) {
+            message = args.pop();
+            hasMessage = true;
+        }
+
+        var invocation = {
+            thisObj: this,
+            values: args,
+            message: message,
+            hasMessage: hasMessage
+        };
+
+        if (some(args, isCaptured)) {
+            invocation.values = map(args.slice(0, numArgsToCapture), function (arg) {
+                if (isNotCaptured(arg)) {
+                    return arg;
+                }
+                if (!context) {
+                    context = {
+                        source: arg.source,
+                        args: []
+                    };
+                }
+                context.args.push({
+                    value: arg.powerAssertContext.value,
+                    events: arg.powerAssertContext.events
+                });
+                return arg.powerAssertContext.value;
+            });
+
+            return decorator.concreteAssert(callSpec, invocation, context);
+        } else {
+            return decorator.concreteAssert(callSpec, invocation);
+        }
+    };
+}
+
+function isNotCaptured (value) {
+    return !isCaptured(value);
+}
+
+function isCaptured (value) {
+    return (typeof value === 'object') &&
+        (value !== null) &&
+        (typeof value.powerAssertContext !== 'undefined');
+}
+
+module.exports = decorate;

node_modules/empower-core/lib/decorator.js

@@ -0,0 +1,165 @@
+'use strict';
+
+var forEach = require('core-js/library/fn/array/for-each');
+var filter = require('core-js/library/fn/array/filter');
+var map = require('core-js/library/fn/array/map');
+var signature = require('call-signature');
+var decorate = require('./decorate');
+var keys = require('core-js/library/fn/object/keys');
+
+
+function Decorator (receiver, config) {
+    this.receiver = receiver;
+    this.config = config;
+    this.onError = config.onError;
+    this.onSuccess = config.onSuccess;
+    this.signatures = map(config.patterns, parse);
+    this.wrapOnlySignatures = map(config.wrapOnlyPatterns, parse);
+}
+
+Decorator.prototype.enhancement = function () {
+    var that = this;
+    var container = this.container();
+    var wrappedMethods = [];
+
+    function attach(matcherSpec, enhanced) {
+        var matcher = matcherSpec.parsed;
+        var methodName = detectMethodName(matcher.callee);
+        if (typeof that.receiver[methodName] !== 'function' || wrappedMethods.indexOf(methodName) !== -1) {
+            return;
+        }
+        var callSpec = {
+            thisObj: that.receiver,
+            func: that.receiver[methodName],
+            numArgsToCapture: numberOfArgumentsToCapture(matcherSpec),
+            matcherSpec: matcherSpec,
+            enhanced: enhanced
+        };
+        container[methodName] = callSpec.enhancedFunc = decorate(callSpec, that);
+        wrappedMethods.push(methodName);
+    }
+
+    forEach(filter(this.signatures, methodCall), function (matcher) {
+        attach(matcher, true);
+    });
+
+    forEach(filter(this.wrapOnlySignatures, methodCall), function (matcher) {
+        attach(matcher, false);
+    });
+
+    return container;
+};
+
+Decorator.prototype.container = function () {
+    var basement = {};
+    if (typeof this.receiver === 'function') {
+        var candidates = filter(this.signatures, functionCall);
+        var enhanced = true;
+        if (candidates.length === 0) {
+            enhanced = false;
+            candidates = filter(this.wrapOnlySignatures, functionCall);
+        }
+        if (candidates.length === 1) {
+            var callSpec = {
+                thisObj: null,
+                func: this.receiver,
+                numArgsToCapture: numberOfArgumentsToCapture(candidates[0]),
+                matcherSpec: candidates[0],
+                enhanced: enhanced
+            };
+            basement = callSpec.enhancedFunc = decorate(callSpec, this);
+        }
+    }
+    return basement;
+};
+
+Decorator.prototype.concreteAssert = function (callSpec, invocation, context) {
+    var func = callSpec.func;
+    var thisObj = this.config.bindReceiver ? callSpec.thisObj : invocation.thisObj;
+    var enhanced = callSpec.enhanced;
+    var args = invocation.values;
+    var message = invocation.message;
+    var matcherSpec = callSpec.matcherSpec;
+
+    if (context && typeof this.config.modifyMessageBeforeAssert === 'function') {
+        message = this.config.modifyMessageBeforeAssert({originalMessage: message, powerAssertContext: context});
+    }
+    args = args.concat(message);
+
+    var data = {
+        thisObj: invocation.thisObj,
+        assertionFunction: callSpec.enhancedFunc,
+        originalMessage: message,
+        defaultMessage: matcherSpec.defaultMessage,
+        matcherSpec: matcherSpec,
+        enhanced: enhanced,
+        args: args
+    };
+
+    if (context) {
+        data.powerAssertContext = context;
+    }
+
+    return this._callFunc(func, thisObj, args, data);
+};
+
+// see: https://github.com/twada/empower-core/pull/8#issuecomment-173480982
+Decorator.prototype._callFunc = function (func, thisObj, args, data) {
+    var ret;
+    try {
+        ret = func.apply(thisObj, args);
+    } catch (e) {
+        data.assertionThrew = true;
+        data.error = e;
+        return this.onError.call(thisObj, data);
+    }
+    data.assertionThrew = false;
+    data.returnValue = ret;
+    return this.onSuccess.call(thisObj, data);
+};
+
+function numberOfArgumentsToCapture (matcherSpec) {
+    var matcher = matcherSpec.parsed;
+    var len = matcher.args.length;
+    var lastArg;
+    if (0 < len) {
+        lastArg = matcher.args[len - 1];
+        if (lastArg.name === 'message' && lastArg.optional) {
+            len -= 1;
+        }
+    }
+    return len;
+}
+
+
+function detectMethodName (callee) {
+    if (callee.type === 'MemberExpression') {
+        return callee.member;
+    }
+    return null;
+}
+
+
+function functionCall (matcherSpec) {
+    return matcherSpec.parsed.callee.type === 'Identifier';
+}
+
+
+function methodCall (matcherSpec) {
+    return matcherSpec.parsed.callee.type === 'MemberExpression';
+}
+
+function parse(matcherSpec) {
+    if (typeof matcherSpec === 'string') {
+        matcherSpec = {pattern: matcherSpec};
+    }
+    var ret = {};
+    forEach(keys(matcherSpec), function (key) {
+        ret[key] = matcherSpec[key];
+    });
+    ret.parsed = signature.parse(matcherSpec.pattern);
+    return ret;
+}
+
+
+module.exports = Decorator;

node_modules/empower-core/lib/default-options.js

@@ -0,0 +1,35 @@
+'use strict';
+
+module.exports = function defaultOptions () {
+    return {
+        destructive: false,
+        bindReceiver: true,
+        onError: onError,
+        onSuccess: onSuccess,
+        patterns: [
+            'assert(value, [message])',
+            'assert.ok(value, [message])',
+            'assert.equal(actual, expected, [message])',
+            'assert.notEqual(actual, expected, [message])',
+            'assert.strictEqual(actual, expected, [message])',
+            'assert.notStrictEqual(actual, expected, [message])',
+            'assert.deepEqual(actual, expected, [message])',
+            'assert.notDeepEqual(actual, expected, [message])',
+            'assert.deepStrictEqual(actual, expected, [message])',
+            'assert.notDeepStrictEqual(actual, expected, [message])'
+        ],
+        wrapOnlyPatterns: []
+    };
+};
+
+function onError (errorEvent) {
+    var e = errorEvent.error;
+    if (errorEvent.powerAssertContext && /^AssertionError/.test(e.name)) {
+        e.powerAssertContext = errorEvent.powerAssertContext;
+    }
+    throw e;
+}
+
+function onSuccess(successEvent) {
+    return successEvent.returnValue;
+}

node_modules/empower-core/lib/define-properties.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var defineProperty = require('core-js/library/fn/object/define-property');
+var forEach = require('core-js/library/fn/array/for-each');
+var keys = require('core-js/library/fn/object/keys');
+
+module.exports = function defineProperties (obj, map) {
+    forEach(keys(map), function (name) {
+        defineProperty(obj, name, {
+            configurable: true,
+            enumerable: false,
+            value: map[name],
+            writable: true
+        });
+    });
+};

node_modules/empower-core/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "empower-core",
+  "description": "Power Assert feature enhancer for assert function/object",
+  "version": "1.2.0",
+  "author": {
+    "name": "Takuto Wada",
+    "email": "takuto.wada@gmail.com",
+    "url": "https://github.com/twada"
+  },
+  "dependencies": {
+    "call-signature": "0.0.2",
+    "core-js": "^2.0.0"
+  },
+  "devDependencies": {
+    "acorn": "^5.0.0",
+    "acorn-es7-plugin": "^1.0.14",
+    "buster-assertions": "^0.10.4",
+    "escodegen": "^1.8.0",
+    "espower": "^2.0.0",
+    "mocha": "^5.0.0"
+  },
+  "directories": {
+    "lib": "./lib"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "README.md",
+    "index.js",
+    "lib",
+    "package.json"
+  ],
+  "homepage": "https://github.com/twada/power-assert-runtime",
+  "license": "MIT",
+  "main": "./index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/twada/power-assert-runtime.git"
+  }
+}