fix: array and directive string expression support

package.json

@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "@babel/core": "^7.2.2",
+    "@babel/parser": "^7.2.3",
     "@babel/template": "^7.2.2",
     "@babel/traverse": "^7.2.3",
     "@babel/types": "^7.2.2",

src/ast-utils.ts

@@ -1,7 +1,15 @@
 // LICENSE : MIT
 "use strict";
 import * as assert from "assert";
-import { CallExpression, Comment, isCallExpression, isIdentifier, isLiteral, isNullLiteral } from "@babel/types";
+import {
+    CallExpression,
+    Comment,
+    isCallExpression,
+    isIdentifier,
+    isLiteral,
+    isNullLiteral,
+    isDirective
+} from "@babel/types";
 import template from "@babel/template";
 
 const commentCodeRegExp = /=>\s*?(.*?)$/i;
@@ -85,10 +93,18 @@ export function wrapAssert(actualNode: any, expectedNode: any, options: wrapAsse
             ACTUAL_NODE
         });
     } else if (isLiteral(expectedNode)) {
-        return template`assert.strictEqual(ACTUAL_NODE, EXPECTED_NODE)`({
-            ACTUAL_NODE,
-            EXPECTED_NODE
-        });
+        // Handle Directive Prorogue as string literal
+        if (isDirective(ACTUAL_NODE)) {
+            return template`assert.strictEqual(ACTUAL_NODE, EXPECTED_NODE)`({
+                ACTUAL_NODE: (ACTUAL_NODE.value as any).extra.raw,
+                EXPECTED_NODE
+            });
+        } else {
+            return template`assert.strictEqual(ACTUAL_NODE, EXPECTED_NODE)`({
+                ACTUAL_NODE,
+                EXPECTED_NODE
+            });
+        }
     } else {
         return template`assert.deepStrictEqual(ACTUAL_NODE, EXPECTED_NODE)`({
             ACTUAL_NODE,

src/comment-to-assert.ts

@@ -1,9 +1,9 @@
 // LICENSE : MIT
 "use strict";
 import { ERROR_COMMENT_PATTERN, PROMISE_COMMENT_PATTERN, tryGetCodeFromComments, wrapAssert } from "./ast-utils";
-import { parse, ParseResult, transformFromAstSync } from "@babel/core";
-import { identifier, isExpressionStatement } from "@babel/types";
-import * as template from "@babel/template";
+import { transformFromAstSync } from "@babel/core";
+import { identifier, isExpressionStatement, File } from "@babel/types";
+import { parse, parseExpression, ParserOptions } from "@babel/parser";
 import traverse from "@babel/traverse";
 
 function getExpressionNodeFromCommentValue(string: string): { type: string } & { [index: string]: any } {
@@ -26,7 +26,7 @@ function getExpressionNodeFromCommentValue(string: string): { type: string } & {
         };
     }
     try {
-        return template.expression(string)();
+        return parseExpression(string);
     } catch (e) {
         console.error(`Can't parse comments // => expression`);
         throw e;
@@ -35,9 +35,7 @@ function getExpressionNodeFromCommentValue(string: string): { type: string } & {
 
 export interface toAssertFromSourceOptions {
     asyncCallbackName?: string;
-    babel?: {
-        plugins: string[];
-    };
+    babel?: ParserOptions;
 }
 
 /**
@@ -48,7 +46,7 @@ export function toAssertFromSource(code: string, options?: toAssertFromSourceOpt
     const ast = parse(code, {
         // parse in strict mode and allow module declarations
         sourceType: "module",
-        plugins: (options && options.babel && options.babel.plugins) || []
+        ...options && options.babel ? options.babel : {}
     });
     if (!ast) {
         throw new Error("Can not parse the code");
@@ -74,7 +72,7 @@ export interface toAssertFromASTOptions {
 /**
  * transform AST to asserted AST.
  */
-export function toAssertFromAST(ast: ParseResult, options: toAssertFromASTOptions = {}) {
+export function toAssertFromAST(ast: File, options: toAssertFromASTOptions = {}) {
     const replaceSet = new Set();
     traverse(ast, {
         exit(path) {

test/snapshots/Array-strings/input.js

@@ -0,0 +1,6 @@
+const array = ["A", "B", "C"];
+array.unshift("S"); // "S"を先頭に追加
+console.log(array); // => ["S", "A", "B", "C"]
+const shiftedItem = array.shift(); // 先頭の要素を削除
+console.log(shiftedItem); // => "S"
+console.log(array); // => ["A", "B", "C"]

test/snapshots/Array-strings/output.js

@@ -0,0 +1,10 @@
+const array = ["A", "B", "C"];
+array.unshift("S"); // "S"を先頭に追加
+
+assert.deepStrictEqual(array, ["S", "A", "B", "C"]); // => ["S", "A", "B", "C"]
+
+const shiftedItem = array.shift(); // 先頭の要素を削除
+
+assert.strictEqual(shiftedItem, "S"); // => "S"
+
+assert.deepStrictEqual(array, ["A", "B", "C"]); // => ["A", "B", "C"]

test/snapshots/Number-String/input.js

@@ -0,0 +1,3 @@
+console.log(0b0000000000000000000000000001001); // => 9
+// Number#toStringメソッドを使うことで2進数表記の文字列を取得できる
+console.log((9).toString(2)); // => "1001"

test/snapshots/Number-String/output.js

@@ -0,0 +1,4 @@
+assert.strictEqual(0b0000000000000000000000000001001, 9); // => 9
+// Number#toStringメソッドを使うことで2進数表記の文字列を取得できる
+
+assert.strictEqual(9 .toString(2), "1001"); // => "1001"

test/snapshots/directive-string-prologue/input.js

@@ -0,0 +1,3 @@
+"文字列"; // => "文字列"
+"\u6587\u5b57\u5217"; // => "文字列"
+"𩸽"[0]; // => "\uD867"

test/snapshots/directive-string-prologue/output.js

@@ -0,0 +1,5 @@
+assert.strictEqual("文字列", "文字列"); // => "文字列"
+
+assert.strictEqual("\u6587\u5b57\u5217", "文字列"); // => "文字列"
+
+assert.strictEqual("𩸽"[0], "\uD867"); // => "\uD867"