escover 1.10.0 → 1.14.0

package/ChangeLog

@@ -1,3 +1,31 @@
+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:
+- escover: add ability to read lcov
+- coverage-file: add ability to parse lcov
+- escover: mark: add support of break
+
+
+2022.01.19, v1.12.0
+
+feature:
+- escover: add lcov support
+
+
+2022.01.19, v1.11.0
+
+feature:
+- escover: mark: add support of continue
+- escover: coverage-file: read -> readCoverage
+
+
 2022.01.19, v1.10.0
 
 feature:

package/README.md

@@ -31,7 +31,11 @@ which are needed to load module again, and apply mocks.
 
 ### 🤷‍  How to get coverage when mocks are used?
 
-☝️ Use 🎩 `ESCover`! It supports loaders, `ESM` and collects coverage as a loader!
+☝️ Use 🎩`ESCover`! It supports loaders, `ESM` and collects coverage as a loader!
+
+### 🤷‍  What with [`coveralls`](https://coveralls.io/)? Does [`lcov`](https://github.com/StevenLooman/mocha-lcov-reporter) supported?
+
+☝️ Sure! `coverage/lcov.info` is main coverage file for 🎩`ESCover`.
 
 ## Install
 
@@ -55,6 +59,15 @@ When everything is covered:
 
 ![image](https://user-images.githubusercontent.com/1573141/149822261-ff9bc3b4-6ee4-452c-9ada-3cc922b630ec.png)
 
+## What formatters exists?
+
+There is two types of formatters:
+
+- `lines` adds links to each line;
+- `files` shows information in table;
+
+You can choose formatter with `ESCOVER_FORMAT` env variable.
+
 ## What if I want to use 🎩`ESCover` with `mock-import`?
 
 Experimental `loaders` supports only one, for now. So [zenload](https://github.com/coderaiser/zenload) should be used.

package/bin/escover.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
 import {cli} from '../lib/cli/cli.js';
-import {read} from '../lib/coverage-file/coverage-file.js';
+import {readCoverage} from '../lib/coverage-file/coverage-file.js';
+import {readConfig} from '../lib/config.js';
 
 cli({
     argv: process.argv,
     exit: process.exit,
-    read,
+    readCoverage,
+    readConfig,
 });
 

package/lib/cli/cli.js

@@ -8,7 +8,7 @@ import reportFiles from '../formatters/files.js';
 
 const {ESCOVER_FORMAT, NODE_OPTIONS = ''} = process.env;
 
-export const cli = ({argv, exit, read}) => {
+export const cli = ({argv, exit, readCoverage}) => {
     const args = yargsParser(argv.slice(2), {
         string: [
             'format',
@@ -36,7 +36,7 @@ export const cli = ({argv, exit, read}) => {
         execute('"' + cmd.join(`" "`) + '"', exit);
     }
     
-    const coverage = read();
+    const coverage = readCoverage();
     
     let output = '';
     

package/lib/coverage-file/coverage-file.js

@@ -3,46 +3,47 @@ import {
     readFileSync,
 } from 'fs';
 import tryCatch from 'try-catch';
+import {join} from 'path';
 import {getFileEntries} from '../c4.js';
 import {transform} from '../transform.js';
 import {merge} from '../merge.js';
 import {findCacheDir} from './find-cache-dir.js';
-
-const {
-    stringify,
-    parse,
-} = JSON;
+import {
+    generateLcov,
+    parseLcov,
+} from './lcov.js';
 
 const NAME = 'escover';
-const buildName = (a) => `${a}/${NAME}.json`;
+const LCOV = 'lcov.info';
 
-export const write = () => {
+export const writeCoverage = () => {
     const files = getFileEntries();
     
     if (!files.size)
         return;
     
     const parsed = transform(files);
-    
     const merged = merge(parsed);
-    const name = findCacheDir({
+    const lcov = generateLcov(merged);
+    
+    const dir = findCacheDir({
         name: NAME,
         create: true,
     });
     
-    writeFileSync(buildName(name), stringify(merged, null, 4));
+    writeFileSync(join(dir, LCOV), lcov);
 };
 
-export const read = () => {
-    const name = findCacheDir({
+export const readCoverage = () => {
+    const dir = findCacheDir({
         name: NAME,
     });
     
-    const [error, data] = tryCatch(readFileSync, buildName(name), 'utf8');
+    const [error, data] = tryCatch(readFileSync, join(dir, LCOV), 'utf8');
     
     if (error)
         return [];
     
-    return parse(data);
+    return parseLcov(data);
 };
 

package/lib/coverage-file/lcov.js

@@ -0,0 +1,52 @@
+const {entries} = Object;
+
+export const generateLcov = (files) => {
+    const result = [];
+    
+    for (const {name, lines} of files) {
+        result.push(`SF:${name}`);
+        for (const [line, covered] of entries(lines)) {
+            const count = covered ? 1 : 0;
+            result.push(`DA:${line},${count}`);
+        }
+        
+        result.push('end_of_record');
+    }
+    
+    return result.join('\n');
+};
+
+const isEnd = (a) => a === 'end_of_record';
+
+export const parseLcov = (lcov) => {
+    const files = [];
+    let name = '';
+    let lines = {};
+    
+    for (const current of lcov.split('\n')) {
+        const [cmd, arg] = current.split(':');
+        
+        if (cmd === 'SF') {
+            name = arg;
+            lines = {};
+            continue;
+        }
+        
+        if (cmd === 'DA') {
+            const [line, covered] = arg.split(',');
+            lines[line] = Boolean(Number(covered));
+            continue;
+        }
+        
+        if (isEnd(cmd)) {
+            files.push({
+                name,
+                lines,
+            });
+            continue;
+        }
+    }
+    
+    return files;
+};
+

package/lib/exit.js

@@ -1,6 +1,6 @@
 import once from 'once';
-import {write} from './coverage-file/coverage-file.js';
+import {writeCoverage} from './coverage-file/coverage-file.js';
 
 export const exit = once(() => {
-    write();
+    writeCoverage();
 });

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

@@ -56,19 +56,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

@@ -3,9 +3,9 @@ import {
     types,
     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,
@@ -16,6 +16,8 @@ const {
 const {
     replaceWith,
     compareAny,
+    compare,
+    replaceWithMultiple,
 } = operator;
 
 const LINE = `__c4['🧨'](__l, __c)`;
@@ -36,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;
@@ -53,8 +53,9 @@ export const fix = (path, {options}) => {
         return;
     }
     
-    if (path.isCallExpression()) {
+    if (path.isCallExpression() || path.isNewExpression()) {
         const {node} = path;
+        
         replaceWith(path, SequenceExpression([
             lineNode.expression,
             node,
@@ -82,24 +83,19 @@ export const fix = (path, {options}) => {
         return;
     }
     
-    if (path.isNewExpression()) {
-        replaceWith(path, SequenceExpression([
-            lineNode.expression,
-            node,
-        ]));
-        return;
-    }
+    if (path.isArrowFunctionExpression())
+        return addMarkToArrowFunction(path, lineNode);
     
-    if (path.isReturnStatement())
-        return addMarkToReturn(path, lineNode);
+    if (path.isReturnStatement() || path.isThrowStatement())
+        return addMarkToArgument(path, lineNode);
     
-    if (path.isArrowFunctionExpression()) {
-        return addMarkToArrowFunction(path, lineNode);
+    if (path.isContinueStatement() || path.isBreakStatement()) {
+        return replaceWithMultiple(path, [
+            lineNode,
+            path.node,
+        ]);
     }
     
-    if (path.isThrowStatement())
-        return addMarkToThrow(path, lineNode);
-    
     replaceWith(path, BlockStatement([
         node,
     ]));
@@ -107,24 +103,39 @@ 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) => {
+    return compareAny(node, [
+        ...EXCLUDE,
+        SEQUENCE,
+    ]);
+};
 
-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);
@@ -135,8 +146,14 @@ export const traverse = ({push}) => ({
         
         push(path);
     },
+    'ContinueStatement|BreakStatement'(path) {
+        if (compare(path.getPrevSibling(), LINE))
+            return;
+        
+        push(path);
+    },
     LogicalExpression(path) {
-        if (compareAny(path.get('left'), EXCLUDE))
+        if (isExclude(path.get('left')))
             return;
         
         push(path);
@@ -148,6 +165,9 @@ export const traverse = ({push}) => ({
         push(path);
     },
     SequenceExpression(path) {
+        if (compare(path, `(${LINE}, __z)`))
+            return;
+        
         const expressions = path.get('expressions');
         
         for (const expPath of expressions) {
@@ -161,7 +181,7 @@ export const traverse = ({push}) => ({
         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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escover",
-  "version": "1.10.0",
+  "version": "1.14.0",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Coverage for EcmaScript Modules",
   "main": "lib/escover.js",
@@ -27,6 +27,7 @@
     "fix:lint": "madrun fix:lint",
     "report": "madrun report",
     "watcher": "madrun watcher",
+    "watch:test": "madrun watch:test",
     "watch:lint": "madrun watch:lint",
     "watch:tape": "madrun watch:tape",
     "prewisdom": "madrun prewisdom"
@@ -40,6 +41,7 @@
     "once": "^1.4.0",
     "picomatch": "^2.3.1",
     "putout": "^24.0.2",
+    "strip-ansi": "^7.0.1",
     "table": "^6.8.0",
     "try-catch": "^3.0.0",
     "yargs-parser": "^21.0.0",

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,
-    ]));
-};
-