[WIP] power-assert v2

.travis.yml

@@ -1,7 +1,6 @@
 language: node_js
 sudo: false
 node_js:
-  - "6" # to be removed on "April 2019"
   - "8" # to be removed on "December 2019"
   - "10" # to be removed on "April 2021"
-  - "11" # to be removed on "June 2019"
+  - "12" # to be removed on "April 2022"

README.md

@@ -5,7 +5,7 @@ Babel plugin for power-assert.
 
 [![Build Status][travis-image]][travis-url]
 [![NPM version][npm-image]][npm-url]
-[![Dependency Status][depstat-image]][depstat-url]
+[![Code Style][style-image]][style-url]
 [![License][license-image]][license-url]
 
 
@@ -318,7 +318,6 @@ You can customize configs such as assertion patterns via [.babelrc](https://babe
   ],
   "plugins": [
     ["babel-plugin-espower", {
-      "embedAst": true,
       "patterns": [
         "assert.isNull(object, [message])",
         "assert.same(actual, expected, [message])",
@@ -336,7 +335,6 @@ require('@babel/register')({
     presets: [...],
     plugins: [
         ['babel-plugin-espower', {
-            embedAst: true,
             patterns: [
                 'assert.isNull(object, [message])',
                 'assert.same(actual, expected, [message])',
@@ -356,7 +354,6 @@ var transformed = babel.transform(jsCode, {
     presets: [...],
     plugins: [
         ['babel-plugin-espower', {
-            embedAst: true,
             patterns: [
                 'assert.isNull(object, [message])',
                 'assert.same(actual, expected, [message])',
@@ -390,7 +387,7 @@ Configuration options for `babel-plugin-espower`. If not passed, default options
         'assert.deepStrictEqual(actual, expected, [message])',
         'assert.notDeepStrictEqual(actual, expected, [message])'
     ],
-    embedAst: true,
+    embedAst: false, // false by default, true if there are some syntax plugins configured
     visitorKeys: babel.types.VISITOR_KEYS,
     astWhiteList: babel.types.BUILDER_KEYS,
     sourceRoot: process.cwd(),
@@ -402,6 +399,7 @@ Configuration options for `babel-plugin-espower`. If not passed, default options
 #### options.embedAst
 
 If you want to use non-ECMASCript-standard features such as JSX tags in your `assert()`, you should set `embedAst` option to `true`.
+Since 4.0.0, `embedAst` option is configured automatically.
 
 ```js
 assert(shallow(<Foo />).is('.foo'));
@@ -444,8 +442,8 @@ Licensed under the [MIT](https://github.com/power-assert-js/babel-plugin-espower
 [travis-url]: https://travis-ci.org/power-assert-js/babel-plugin-espower
 [travis-image]: https://secure.travis-ci.org/power-assert-js/babel-plugin-espower.svg?branch=master
 
-[depstat-url]: https://gemnasium.com/power-assert-js/babel-plugin-espower
-[depstat-image]: https://gemnasium.com/power-assert-js/babel-plugin-espower.svg
+[style-url]: https://github.com/Flet/semistandard
+[style-image]: https://img.shields.io/badge/code%20style-semistandard-brightgreen.svg
 
 [license-url]: https://github.com/power-assert-js/babel-plugin-espower/blob/master/LICENSE
 [license-image]: https://img.shields.io/badge/license-MIT-brightgreen.svg

index.js

@@ -1,7 +1,7 @@
 /**
  * babel-plugin-espower:
  *   Babel plugin for power-assert
- * 
+ *
  * https://github.com/power-assert-js/babel-plugin-espower
  *
  * Copyright (c) 2015-2019 Takuto Wada

lib/argument-modification.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const define = require('./define-properties');
+const createIsNodeToBeCaptured = require('./to-be-captured');
+const { createNewArgumentRecorderNode, createNewAssertionMessageNode } = require('./create-node');
+
+class ArgumentModification {
+  constructor (babel, match, options, cloneAst, assertionNodePath, metadataIdent) {
+    this.babel = babel;
+    this.options = options;
+    this.currentArgumentMatchResult = match;
+    this.assertionNodePath = assertionNodePath;
+    this.metadataIdent = metadataIdent;
+    this.cloneAst = cloneAst;
+    this.currentArgumentNodePath = null;
+    this.argumentModified = false;
+    this.messageUpdated = false;
+    this.isNodeToBeCaptured = createIsNodeToBeCaptured(babel.types);
+  }
+
+  toBeCaptured (nodePath) {
+    return this.isNodeToBeCaptured(nodePath);
+  }
+
+  isLeaving (nodePath) {
+    return this.currentArgumentNodePath === nodePath;
+  }
+
+  isCapturing () {
+    return true;
+  }
+
+  isMessageUpdated () {
+    return !!this.messageUpdated;
+  }
+
+  isArgumentModified () {
+    return !!this.argumentModified;
+  }
+
+  enter (nodePath) {
+    // entering target argument
+    this.currentArgumentNodePath = nodePath;
+    // create recorder per argument
+    this.argumentRecorder = createNewArgumentRecorderNode({
+      nodePath,
+      types: this.babel.types,
+      visitorKeys: this.options.visitorKeys,
+      metadataIdent: this.metadataIdent,
+      cloneAst: this.cloneAst,
+      calleeNode: this.assertionNodePath.node.callee,
+      matchIndex: this.currentArgumentMatchResult.index
+    });
+  }
+
+  leave (nodePath) {
+    const currentNode = nodePath.node;
+    const shouldCaptureValue = this.toBeCaptured(nodePath);
+    const pathToBeCaptured = shouldCaptureValue ? currentNode._espowerEspath : null;
+    const shouldCaptureArgument = this.isArgumentModified() || shouldCaptureValue;
+    const resultNode = shouldCaptureArgument ? this.captureArgument(currentNode, pathToBeCaptured) : currentNode;
+    if (this.currentArgumentMatchResult.name === 'message' && this.currentArgumentMatchResult.kind === 'optional') {
+      this.messageUpdated = true;
+      // enclose it in AssertionMessage
+      return createNewAssertionMessageNode({
+        nodePath,
+        types: this.babel.types,
+        visitorKeys: this.options.visitorKeys,
+        metadataIdent: this.metadataIdent,
+        cloneAst: this.cloneAst,
+        originalMessageNode: resultNode,
+        matchIndex: this.currentArgumentMatchResult.index
+      });
+    } else {
+      return resultNode;
+    }
+  }
+
+  captureNode (nodePath) {
+    const currentNode = nodePath.node;
+    const espath = currentNode._espowerEspath;
+    return this.insertRecorder(currentNode, espath, '_tap');
+  }
+
+  captureArgument (currentNode, espath) {
+    return this.insertRecorder(currentNode, espath, '_rec');
+  }
+
+  insertRecorder (currentNode, espath, methodName) {
+    const receiver = this.argumentRecorder;
+    const types = this.babel.types;
+    const args = [
+      currentNode
+    ];
+    if (espath) {
+      args.push(types.valueToNode(espath));
+    }
+    const newNode = types.callExpression(
+      types.memberExpression(receiver, types.identifier(methodName)),
+      args
+    );
+    define(newNode, { _generatedByEspower: true });
+    this.argumentModified = true;
+    return newNode;
+  }
+}
+
+class NoModification {
+  enter (nodePath) {
+    this.currentArgumentNodePath = nodePath;
+  }
+  leave (nodePath) {
+    return nodePath;
+  }
+  isLeaving (nodePath) {
+    return this.currentArgumentNodePath === nodePath;
+  }
+  isCapturing () {
+    return false;
+  }
+  isMessageUpdated () {
+    return false;
+  }
+  isArgumentModified () {
+    return false;
+  }
+}
+
+module.exports = {
+  ArgumentModification,
+  NoModification
+};

lib/argument-recorder.js

@@ -0,0 +1,165 @@
+'use strict';
+module.exports = function () {
+  const isPromiseLike = (o) => o !== null &&
+                typeof o === 'object' &&
+                typeof o.then === 'function' &&
+                typeof o.catch === 'function';
+
+  const mark = (_this, s) => {
+    return function () {
+      const args = Array.from(arguments);
+      _this.status = s;
+      _this.value = (args.length === 1) ? args[0] : args;
+    };
+  };
+
+  class $Promise$ {
+    constructor (prms) {
+      this.status = 'pending';
+      prms.then(mark(this, 'resolved'), mark(this, 'rejected'));
+    }
+  }
+
+  const wrap = (v) => isPromiseLike(v) ? new $Promise$(v) : v;
+
+  class ArgumentRecorder {
+    /**
+     * @typedef {Object} AssertionMetadata
+     * @property {string} content
+     * @property {string} filepath
+     * @property {number} line
+     * @property {number} version
+     * @property {string} pattern
+     * @property {array} params
+     * @property {boolean} [async] - true if enclosed in async function
+     * @property {boolean} [generator] - true if enclosed in generator function
+     * @property {string} [ast] - stringified AST
+     * @property {string} [tokens] - stringified tokens
+     * @property {string} [visitorKeys] - stringified visitorKeys
+     */
+
+    /**
+     * record argument value and metadata silently
+     * @param {function} callee - callee of target argument
+     * @param {AssertionMetadata} am - generated metadata for target assertion
+     * @param {number} matchIndex - index of matched parameter
+     */
+    constructor (callee, am, matchIndex) {
+      this._callee = callee;
+      this._am = am;
+      this._logs = [];
+      this._recorded = null;
+      this._val = null;
+      this._idx = matchIndex;
+      const conf = am.params[matchIndex];
+      this._isBlock = !!conf.block;
+    }
+
+    /**
+     * @return {AssertionMetadata} - AssertionMetadata for target assertion
+     */
+    metadata () {
+      return this._am;
+    }
+
+    /**
+     * @return {number} - index of matched parameter
+     */
+    matchIndex () {
+      return this._idx;
+    }
+
+    /**
+     * @return {*} - recorded actual value of target argument
+     */
+    val () {
+      return this._val;
+    }
+
+    /**
+     * tap capturable node value with its espath then store them as a Log
+     * @param {*} value - actual value of target node
+     * @param {string} espath - espath of target node in AST
+     * @return {*} - the original value
+     */
+    _tap (value, espath) {
+      this._logs.push({
+        value: wrap(value),
+        espath
+      });
+      return value;
+    }
+
+    /**
+     * record argument value silently then clear captured logs
+     * optionally, proxy block argument then store its result as a Log
+     * @param {*} value - actual value of target argument
+     * @param {string} [espath] - espath of target node in AST
+     * @return {*|ArgumentRecorder} - ArgumentRecorder or actual value of target argument
+     */
+    _rec (value, espath) {
+      const empowered = this._callee && this._callee._empowered;
+      try {
+        if (!empowered) return value;
+        if (!espath) return this;
+
+        const log = {
+          value: wrap(value),
+          espath
+        };
+        this._logs.push(log);
+
+        if (this._isBlock && empowered && typeof value === 'function') {
+          value = new Proxy(value, {
+            apply (target, thisArg, args) {
+              try {
+                const ret = target.apply(thisArg, args);
+                log.value = wrap(ret);
+                return ret;
+              } catch (e) {
+                log.value = e;
+                throw e;
+              }
+            }
+          });
+        }
+
+        return this;
+      } finally {
+        if (empowered) {
+          this._recorded = {
+            value,
+            logs: [].concat(this._logs)
+          };
+        }
+        this._val = value; // actual value of target argument
+        this._logs = []; // clear logs
+      }
+    }
+
+    /**
+     * @typedef {Object} Log
+     * @property {*} value - recorded actual value of target node
+     * @property {string} espath - espath of target node in AST
+     */
+
+    /**
+     * @typedef {Object} RecordedData
+     * @property {*} value - recorded actual value of target argument
+     * @property {Log[]} logs - recorded Logs
+     */
+
+    /**
+     * return RecordedData then clear cache
+     * @return {RecordedData} - captured value and metadata of target argument
+     */
+    eject () {
+      const ret = this._recorded;
+      this._recorded = null;
+      this._val = null;
+      return ret;
+    }
+  }
+
+  return ArgumentRecorder;
+};