[WIP] power-assert v2

.gitignore

@@ -1,3 +1,5 @@
 node_modules
 .DS_Store
 *.log
+.idea
+sandbox/power-assert-2/generated/

README.md

@@ -1,6 +1,7 @@
 [![power-assert][power-assert-banner]][power-assert-url]
 
 [![Build Status][travis-image]][travis-url]
+[![Code Style][style-image]][style-url]
 [![License][license-image]][license-url]
 
 Reorganize [empower](https://github.com/power-assert-js/empower), [power-assert-formatter](https://github.com/power-assert-js/power-assert-formatter) and [power-assert-renderers](https://github.com/twada/power-assert-renderers) into [monorepo](https://github.com/babel/babel/blob/master/doc/design/monorepo.md) structure.
@@ -57,5 +58,8 @@ Licensed under the [MIT](https://github.com/twada/power-assert-runtime/blob/mast
 [travis-url]: https://travis-ci.org/twada/power-assert-runtime
 [travis-image]: https://secure.travis-ci.org/twada/power-assert-runtime.svg?branch=master
 
+[style-url]: https://github.com/Flet/semistandard
+[style-image]: https://img.shields.io/badge/code%20style-semistandard-brightgreen.svg
+
 [license-url]: https://github.com/twada/power-assert-runtime/blob/master/LICENSE
 [license-image]: https://img.shields.io/badge/license-MIT-brightgreen.svg

package.json

@@ -10,15 +10,15 @@
     "url": "https://github.com/twada/power-assert-runtime/issues"
   },
   "devDependencies": {
-    "babel-core": "^6.1.0",
-    "babel-plugin-espower": "^2.3.1",
-    "babel-plugin-transform-function-bind": "^6.1.0",
-    "babel-preset-es2015": "^6.1.0",
-    "babel-preset-react": "^6.1.0",
-    "babel-preset-stage-2": "^6.1.0",
-    "core-js": "^2.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-function-bind": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-react": "^7.0.0",
+    "babel-plugin-espower": "power-assert-js/babel-plugin-espower#power-assert-2",
     "lerna": "^2.11.0",
-    "mocha": "^5.0.0"
+    "mocha": "^5.0.0",
+    "semistandard": "^13.0.1",
+    "snazzy": "^8.0.0"
   },
   "homepage": "https://github.com/twada/power-assert-runtime",
   "keywords": [
@@ -33,6 +33,8 @@
   "scripts": {
     "bootstrap": "lerna bootstrap",
     "lerna": "lerna",
-    "test": "mocha --timeout 0 packages/*/test/*.js"
+    "fmt": "semistandard --fix packages/*/index.js packages/*/lib/*.js",
+    "lint": "semistandard --verbose packages/*/index.js packages/*/lib/*.js | snazzy",
+    "test": "mocha --timeout 0 --reporter dot packages/*/test/*test.js"
   }
 }

packages/empower-core/README.md

@@ -30,7 +30,7 @@ See [CHANGELOG](https://github.com/twada/power-assert-runtime/packages/empower-c
 API
 ---------------------------------------
 
-### var enhancedAssert = empowerCore(originalAssert, [options])
+### const enhancedAssert = empowerCore(originalAssert, [options])
 
 | return type            |
 |:-----------------------|
@@ -78,8 +78,8 @@ If `false`, empower-core mimics originalAssert as new object/function, so `origi
 `bindReceiver` defaults to `true`, meaning assertion methods have their `this` value bound to the original assertion. Setting `bindReceiver` to false causes the `this` reference to be passed through from the actual invocation.
 
 
-#### options.onError
-#### options.onSuccess
+#### options.onError(errorEvent)
+#### options.onSuccess(successEvent)
 
 | type       | default value |
 |:-----------|:--------------|
@@ -89,6 +89,8 @@ Both methods are called with a single `event` argument, it will have the followi
 
 - `event.enhanced` - `true` for methods matching `patterns`. `false` for methods matching `wrapOnlyPatterns`.
 
+- `event.config` - actual configuration object that is `Object.assign`ed with `defaultOptions()` and `options`.
+
 - `event.originalMessage` - The actual value the user provided for optional `message` parameter. This will be `undefined` if the user did not provide a value, even if the underlying assertion provides a default message.
 
 - `event.defaultMessage` - If you use objects instead of strings to specify patterns (see below), the `defaultMessage` metadata will be copied directly on the event object.
@@ -107,14 +109,35 @@ Both methods are called with a single `event` argument, it will have the followi
 
   ```js
   function onError (errorEvent) {
-    var e = errorEvent.error;
+    const e = errorEvent.error;
     if (errorEvent.powerAssertContext && /^AssertionError/.test(e.name)) {
         e.powerAssertContext = errorEvent.powerAssertContext;
     }
     throw e;
   }
   ```
 
+#### options.onFulfilled(errorEvent, resolve, reject)
+#### options.onRejected(successEvent, resolve, reject)
+
+| type       | default value |
+|:-----------|:--------------|
+| `function` | (function defined in `empowerCore.defaultOptions()`) |
+
+Handler functions to deal with Promises returned from target assertions. `onFulfilled` is called when assertion is resolved. `onRejected` is called when assertion is rejected.
+
+Both methods are called with three arguments, `event`, `resolve` and `reject`.
+
+| arg        | type          | description   |
+|:-----------|:--------------|:--------------|
+| `event`    | `object`      | same as `event` argument of `onError` or `onSuccess` |
+| `resolve`  | `function`    | same as `resolve` callback for Promise |
+| `reject`   | `function`    | same as `reject` callback for Promise  |
+
+
+Default implementations of `onFulfilled` and `onRejected` simply delegate to `onSuccess` and `onError` so you don't need to override `onFulfilled` and `onRejected` in most cases.
+
+
 #### options.modifyMessageBeforeAssert
 
 | type       | default value |
@@ -171,7 +194,7 @@ Methods matching these patterns will not be instrumented by the code transform,
 
 Similar to the `options.patterns`, you may supply objects with a `pattern` member, and the additional metadata will be passed to the assertion listeners.
 
-### var options = empowerCore.defaultOptions();
+### const options = empowerCore.defaultOptions();
 
 Returns default options object for `empowerCore` function. In other words, returns
 
@@ -199,7 +222,7 @@ with sensible default for `onError` and `onSuccess`
 
 ```js
 function onError (errorEvent) {
-    var e = errorEvent.error;
+    const e = errorEvent.error;
     if (errorEvent.powerAssertContext && e.name === 'AssertionError') {
         e.powerAssertContext = errorEvent.powerAssertContext;
     }

packages/empower-core/index.js

@@ -7,12 +7,11 @@
  * 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;
+const defaultOptions = require('./lib/default-options');
+const Decorator = require('./lib/decorator');
+const define = require('./lib/define-properties');
+const slice = Array.prototype.slice;
+const isEmpowered = (assertObjectOrFunction) => assertObjectOrFunction._empowered;
 
 /**
  * Enhance Power Assert feature to assert function/object.
@@ -21,58 +20,54 @@ var slice = Array.prototype.slice;
  * @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) {
+  const typeOfAssert = (typeof assert);
+  if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
+    throw new TypeError('empower-core argument should be a function or object.');
+  }
+  if (isEmpowered(assert)) {
+    return assert;
+  }
+  let enhancedAssert;
+  switch (typeOfAssert) {
     case 'function':
-        enhancedAssert = empowerAssertFunction(assert, options);
-        break;
+      enhancedAssert = empowerAssertFunction(assert, options);
+      break;
     case 'object':
-        enhancedAssert = empowerAssertObject(assert, options);
-        break;
+      enhancedAssert = empowerAssertObject(assert, options);
+      break;
     default:
-        throw new Error('Cannot be here');
-    }
-    define(enhancedAssert, { _empowered: true });
-    return enhancedAssert;
+      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());
+  const config = Object.assign(defaultOptions(), options);
+  const target = config.destructive ? assertObject : Object.create(assertObject);
+  const decorator = new Decorator(target, config);
+  return Object.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;
+  const config = Object.assign(defaultOptions(), options);
+  if (config.destructive) {
+    throw new Error('cannot use destructive:true to function.');
+  }
+  const decorator = new Decorator(assertFunction, config);
+  const enhancement = decorator.enhancement();
+  let 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));
+    };
+  }
+  Object.assign(powerAssert, assertFunction);
+  return Object.assign(powerAssert, enhancement);
 }
 
 empowerCore.defaultOptions = defaultOptions;

packages/empower-core/lib/decorate.js

@@ -1,66 +1,83 @@
 'use strict';
 
-var some = require('core-js/library/fn/array/some');
-var map = require('core-js/library/fn/array/map');
+const isNotCaptured = (value) => !isCaptured(value);
+const isCaptured = (value) =>
+  (typeof value === 'object') &&
+          (value !== null) &&
+          (typeof value.powerAssertContext !== 'undefined');
+// MEMO: ArgumentRecorder or AssertionMessage
+const isRecorded = (value) =>
+  typeof value === 'object' &&
+          value !== null &&
+          typeof value.metadata === 'function' &&
+          typeof value.matchIndex === 'function' &&
+          typeof value.eject === 'function';
 
-function decorate (callSpec, decorator) {
-    var numArgsToCapture = callSpec.numArgsToCapture;
+module.exports = function decorate (callSpec, decorator) {
+  const numArgsToCapture = callSpec.numArgsToCapture;
 
-    return function decoratedAssert () {
-        var context, message, hasMessage = false;
+  return function decoratedAssert () {
+    const hasMessage = (numArgsToCapture === (arguments.length - 1));
+    let context;
 
-        // 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
-        };
+    // see: https://github.com/twada/empower-core/pull/8#issue-127859465
+    // see: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+    const args = new Array(arguments.length);
+    for (let i = 0; i < args.length; ++i) {
+      args[i] = arguments[i];
+    }
 
-        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;
-            });
+    const invocation = {
+      thisObj: this, // be careful
+      values: args,
+      hasMessage: hasMessage
+    };
 
-            return decorator.concreteAssert(callSpec, invocation, context);
+    if (args.some(isRecorded)) {
+      invocation.values = args.map((arg) => {
+        if (!isRecorded(arg)) {
+          return arg;
+        }
+        if (!context) {
+          context = {
+            source: arg.metadata(), // API (used in AVA)
+            args: [] // API (used in AVA)
+          };
+        }
+        const record = arg.eject();
+        const matchIndex = arg.matchIndex();
+        if (matchIndex === -1) { // generated AssertionMessage
+          invocation.hasMessage = false;
         } else {
-            return decorator.concreteAssert(callSpec, invocation);
+          context.args.push({
+            matchIndex,
+            value: record.value,
+            events: record.logs // API (used in AVA)
+          });
         }
-    };
-}
-
-function isNotCaptured (value) {
-    return !isCaptured(value);
-}
-
-function isCaptured (value) {
-    return (typeof value === 'object') &&
-        (value !== null) &&
-        (typeof value.powerAssertContext !== 'undefined');
-}
-
-module.exports = decorate;
+        return record.value;
+      });
+      return decorator.concreteAssert(callSpec, invocation, context);
+    } else if (args.some(isCaptured)) {
+      invocation.values = args.map((arg, idx) => {
+        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);
+    }
+  };
+};