escover 1.13.0 → 1.17.0

package/ChangeLog

@@ -1,3 +1,28 @@
+2022.01.27, v1.17.0
+
+feature:
+- escover: improve ternary support: Identifier
+
+
+2022.01.27, v1.16.0
+
+feature:
+- escover: add support of ternary
+
+
+2022.01.26, v1.15.0
+
+fix:
+- escover: logical: find up
+
+
+2022.01.21, v1.14.0
+
+feature:
+- escover: instrument: integrate with putout with crawling enabled
+- escover: format: files: add align center
+
+
 2022.01.20, v1.13.0
 
 feature:

package/lib/formatters/files.js

@@ -35,6 +35,8 @@ export default (coverageFile) => {
         },
         columns: [{
             paddingLeft: 0,
+        }, {
+            alignment: 'center',
         }],
         border: {
             ...getBorderCharacters('void'),

package/lib/formatters/lines.js

@@ -1,7 +1,8 @@
 import chalk from 'chalk';
-const {entries} = Object;
 
+const {entries} = Object;
 const createOut = (output) => (a) => output.push(a);
+
 export default (coverageFile) => {
     const output = [];
     const out = createOut(output);
@@ -56,19 +57,15 @@ export default (coverageFile) => {
     out(`1..${files.length}`);
     out(`# files: ${files.length}`);
     out(`# covered: ${coverage.coveredCount}`);
-    
     out('');
     
-    if (!coverage.uncoveredCount) {
+    if (!coverage.uncoveredCount)
         out('#️ 🌴 ok');
-    }
     
-    if (coverage.uncoveredCount) {
+    if (coverage.uncoveredCount)
         out(`# 🧨 fail: ${coverage.uncoveredCount}`);
-    }
     
     out('');
     
     return output.join('\n');
 };
-

package/lib/instrument/index.js

@@ -1,5 +1,4 @@
 import putout from 'putout';
-
 import * as mark from './plugin-mark/index.js';
 
 export const instrument = (url, source) => {

package/lib/instrument/plugin-mark/{return.js → argument.js}

@@ -1,7 +1,7 @@
 import {types} from 'putout';
 const {SequenceExpression} = types;
 
-export const addMarkToReturn = (path, lineNode) => {
+export const addMarkToArgument = (path, lineNode) => {
     const {node} = path;
     const {expression} = lineNode;
     

package/lib/instrument/plugin-mark/index.js

@@ -4,9 +4,8 @@ import {
     operator,
 } from 'putout';
 
-import {addMarkToReturn} from './return.js';
+import {addMarkToArgument} from './argument.js';
 import {addMarkToArrowFunction} from './arrow.js';
-import {addMarkToThrow} from './throw.js';
 
 const {
     NumericLiteral,
@@ -39,12 +38,10 @@ export const report = () => 'Mark line';
 
 export const fix = (path, {options}) => {
     const {node} = path;
-    
     const {start} = path.node.loc;
     
     const {
         c4 = {
-            mark: () => {},
             init: () => {},
         },
     } = options;
@@ -56,8 +53,9 @@ export const fix = (path, {options}) => {
         return;
     }
     
-    if (path.isCallExpression()) {
+    if (path.isIdentifier()) {
         const {node} = path;
+        
         replaceWith(path, SequenceExpression([
             lineNode.expression,
             node,
@@ -65,48 +63,42 @@ export const fix = (path, {options}) => {
         return;
     }
     
-    if (path.isLogicalExpression()) {
-        replaceWith(path.get('left'), SequenceExpression([
+    if (path.isCallExpression() || path.isNewExpression()) {
+        const {node} = path;
+        
+        replaceWith(path, SequenceExpression([
             lineNode.expression,
-            path.node.left,
-        ]));
-        replaceWith(path.get('right'), SequenceExpression([
-            getLineNode(c4, path.node.right.loc.start).expression,
-            path.node.right,
+            node,
         ]));
         return;
     }
     
-    if (path.isAssignmentPattern() || path.isAssignmentExpression()) {
-        replaceWith(path.get('right'), SequenceExpression([
+    if (path.parentPath.isLogicalExpression())
+        return replaceWith(path, SequenceExpression([
             lineNode.expression,
-            node.right,
+            path.node,
         ]));
-        return;
-    }
     
-    if (path.isNewExpression()) {
-        replaceWith(path, SequenceExpression([
+    if (path.isAssignmentPattern() || path.isAssignmentExpression()) {
+        replaceWith(path.get('right'), SequenceExpression([
             lineNode.expression,
-            node,
+            node.right,
         ]));
         return;
     }
     
-    if (path.isReturnStatement())
-        return addMarkToReturn(path, lineNode);
-    
     if (path.isArrowFunctionExpression())
         return addMarkToArrowFunction(path, lineNode);
     
-    if (path.isThrowStatement())
-        return addMarkToThrow(path, lineNode);
+    if (path.isReturnStatement() || path.isThrowStatement())
+        return addMarkToArgument(path, lineNode);
     
-    if (path.isContinueStatement() || path.isBreakStatement())
+    if (path.isContinueStatement() || path.isBreakStatement()) {
         return replaceWithMultiple(path, [
             lineNode,
             path.node,
         ]);
+    }
     
     replaceWith(path, BlockStatement([
         node,
@@ -115,24 +107,42 @@ export const fix = (path, {options}) => {
 
 const EXCLUDE = [
     LINE,
-    `(${LINE}, __z)`,
     `return (${LINE}, __z)`,
     `return ${LINE}`,
     `throw (${LINE}, __z)`,
 ];
 
-export const exclude = () => EXCLUDE;
+const SEQUENCE = `(${LINE}, __z)`;
+const isExclude = (node) => {
+    const templates = [
+        ...EXCLUDE,
+        SEQUENCE,
+    ];
+    return compareAny(node, templates, {
+        findUp: false,
+    });
+};
 
-export const include = () => [
-    'CallExpression',
-    'NewExpression',
-    'ReturnStatement',
-    'ThrowStatement',
-];
+export const exclude = () => EXCLUDE;
 
 export const traverse = ({push}) => ({
+    'ThrowStatement|ReturnStatement'(path) {
+        push(path);
+    },
+    CallExpression(path) {
+        if (compare(path.parentPath.node, SEQUENCE))
+            return;
+        
+        push(path);
+    },
+    'CallExpression|NewExpression'(path) {
+        if (compare(path.parentPath.node, SEQUENCE))
+            return;
+        
+        push(path);
+    },
     'AssignmentPattern|AssignmentExpression'(path) {
-        if (compareAny(path.get('right'), EXCLUDE))
+        if (isExclude(path.get('right')))
             return;
         
         push(path);
@@ -144,21 +154,20 @@ export const traverse = ({push}) => ({
         push(path);
     },
     'ContinueStatement|BreakStatement'(path) {
-        if (!path.parentPath.isBlockStatement())
-            return;
-        
-        const {body} = path.parentPath.node;
-        
-        if (compare(body[0], LINE))
+        if (compare(path.getPrevSibling(), LINE))
             return;
         
         push(path);
     },
     LogicalExpression(path) {
-        if (compareAny(path.get('left'), EXCLUDE))
-            return;
+        const leftPath = path.get('left');
+        const rightPath = path.get('right');
         
-        push(path);
+        if (!isExclude(leftPath))
+            push(leftPath);
+        
+        if (!isExclude(rightPath))
+            push(rightPath);
     },
     BlockStatement(path) {
         if (path.node.body.length)
@@ -167,6 +176,10 @@ export const traverse = ({push}) => ({
         push(path);
     },
     SequenceExpression(path) {
+        if (compare(path, `(${LINE}, __z)`)) {
+            return;
+        }
+        
         const expressions = path.get('expressions');
         
         for (const expPath of expressions) {
@@ -176,17 +189,17 @@ export const traverse = ({push}) => ({
             push(expPath);
         }
     },
-    IfStatement(path) {
+    'IfStatement|ConditionalExpression'(path) {
         const consequentPath = path.get('consequent');
         const alternatePath = path.get('alternate');
         
-        if (!consequentPath.isBlockStatement() && !compareAny(consequentPath, EXCLUDE))
+        if (!consequentPath.isBlockStatement() && !isExclude(consequentPath))
             push(consequentPath);
         
         if (!alternatePath.node)
             return;
         
-        if (!alternatePath.isBlockStatement())
+        if (!alternatePath.isBlockStatement() && !isExclude(alternatePath))
             push(alternatePath);
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escover",
-  "version": "1.13.0",
+  "version": "1.17.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Coverage for EcmaScript Modules",
   "main": "lib/escover.js",

package/lib/instrument/plugin-mark/throw.js

@@ -1,17 +0,0 @@
-import {
-    types,
-    operator,
-} from 'putout';
-const {SequenceExpression} = types;
-
-const {replaceWith} = operator;
-
-export const addMarkToThrow = (path, lineNode) => {
-    const argumentPath = path.get('argument');
-    
-    return replaceWith(argumentPath, SequenceExpression([
-        lineNode.expression,
-        argumentPath.node,
-    ]));
-};
-