escover 1.9.0 → 1.13.0

package/ChangeLog

@@ -1,3 +1,30 @@
+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:
+- escover: add .. when to many lines to display
+
+
 2022.01.19, v1.9.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.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

@@ -0,0 +1,49 @@
+import {
+    writeFileSync,
+    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';
+import {
+    generateLcov,
+    parseLcov,
+} from './lcov.js';
+
+const NAME = 'escover';
+const LCOV = 'lcov.info';
+
+export const writeCoverage = () => {
+    const files = getFileEntries();
+    
+    if (!files.size)
+        return;
+    
+    const parsed = transform(files);
+    const merged = merge(parsed);
+    const lcov = generateLcov(merged);
+    
+    const dir = findCacheDir({
+        name: NAME,
+        create: true,
+    });
+    
+    writeFileSync(join(dir, LCOV), lcov);
+};
+
+export const readCoverage = () => {
+    const dir = findCacheDir({
+        name: NAME,
+    });
+    
+    const [error, data] = tryCatch(readFileSync, join(dir, LCOV), 'utf8');
+    
+    if (error)
+        return [];
+    
+    return parseLcov(data);
+};
+

package/lib/coverage-file/find-cache-dir.js

@@ -0,0 +1,14 @@
+import {join} from 'path';
+import {cwd} from 'process';
+import {mkdirSync} from 'fs';
+
+export function findCacheDir() {
+    const name = join(cwd(), 'coverage');
+    
+    mkdirSync(name, {
+        recursive: true,
+    });
+    
+    return name;
+}
+

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.js';
+import {writeCoverage} from './coverage-file/coverage-file.js';
 
 export const exit = once(() => {
-    write();
+    writeCoverage();
 });

package/lib/formatters/files.js

@@ -50,13 +50,13 @@ export default (coverageFile) => {
 };
 
 export function formatLines(array) {
-    console.log(array);
     const lines = array.slice(0, 10).join(', ');
     
     if (array.length <= 10)
         return lines;
     
-    return `${lines}...`;
+    const latest = array[array.length - 1];
+    return `${lines}..${latest}`;
 }
 
 function parseUncoveredLines(lines) {
@@ -79,11 +79,12 @@ function parseCoverageFile(coverageFile) {
         const uncoveredLines = parseUncoveredLines(lines);
         
         const linesCount = keys(lines).length;
-        const percentLines = getPercentLines(linesCount, uncoveredLines);
+        const uncoveredLinesCount = uncoveredLines.length;
+        const percentLines = getLinesPercent(linesCount, uncoveredLinesCount);
         
         files.push({
             filename,
-            covered: !uncoveredLines.length,
+            covered: !uncoveredLinesCount,
             lines: uncoveredLines,
             percentLines,
         });
@@ -92,9 +93,9 @@ function parseCoverageFile(coverageFile) {
     return files;
 }
 
-function getPercentLines(linesCount, uncoveredLines) {
+export function getLinesPercent(linesCount, uncoveredLinesCount) {
     if (!linesCount)
         return 100;
     
-    return 100 - Math.round(100 / linesCount * uncoveredLines.length);
+    return 100 - Math.round(100 / linesCount * uncoveredLinesCount);
 }

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

@@ -3,6 +3,7 @@ import {
     types,
     operator,
 } from 'putout';
+
 import {addMarkToReturn} from './return.js';
 import {addMarkToArrowFunction} from './arrow.js';
 import {addMarkToThrow} from './throw.js';
@@ -16,6 +17,8 @@ const {
 const {
     replaceWith,
     compareAny,
+    compare,
+    replaceWithMultiple,
 } = operator;
 
 const LINE = `__c4['🧨'](__l, __c)`;
@@ -93,13 +96,18 @@ export const fix = (path, {options}) => {
     if (path.isReturnStatement())
         return addMarkToReturn(path, lineNode);
     
-    if (path.isArrowFunctionExpression()) {
+    if (path.isArrowFunctionExpression())
         return addMarkToArrowFunction(path, lineNode);
-    }
     
     if (path.isThrowStatement())
         return addMarkToThrow(path, lineNode);
     
+    if (path.isContinueStatement() || path.isBreakStatement())
+        return replaceWithMultiple(path, [
+            lineNode,
+            path.node,
+        ]);
+    
     replaceWith(path, BlockStatement([
         node,
     ]));
@@ -135,6 +143,17 @@ export const traverse = ({push}) => ({
         
         push(path);
     },
+    'ContinueStatement|BreakStatement'(path) {
+        if (!path.parentPath.isBlockStatement())
+            return;
+        
+        const {body} = path.parentPath.node;
+        
+        if (compare(body[0], LINE))
+            return;
+        
+        push(path);
+    },
     LogicalExpression(path) {
         if (compareAny(path.get('left'), EXCLUDE))
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escover",
-  "version": "1.9.0",
+  "version": "1.13.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/coverage-file.js

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