escover 1.0.0

package/README.md

@@ -0,0 +1,38 @@
+# 🎩`ESCover` [![License][LicenseIMGURL]][LicenseURL] [![NPM version][NPMIMGURL]][NPMURL] [![Build Status][BuildStatusIMGURL]][BuildStatusURL] [![Coverage Status][CoverageIMGURL]][CoverageURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/escover.svg?style=flat
+[BuildStatusURL]: https://github.com/coderaiser/escover/actions?query=workflow%3A%22Node+CI%22 "Build Status"
+[BuildStatusIMGURL]: https://github.com/coderaiser/escover/workflows/Node%20CI/badge.svg
+[LicenseIMGURL]: https://img.shields.io/badge/license-MIT-317BF9.svg?style=flat
+[NPMURL]: https://npmjs.org/package/escover "npm"
+[LicenseURL]: https://tldrlegal.com/license/mit-license "MIT License"
+[CoverageURL]: https://coveralls.io/github/coderaiser/escover?branch=master
+[CoverageIMGURL]: https://coveralls.io/repos/coderaiser/escover/badge.svg?branch=master&service=github
+
+Explosive coverage tool
+
+## Install
+
+```
+npm i escover -g
+```
+
+Then run using:
+
+```sh
+NODE_OPTIONS="'--loader escover'" escover npm test
+```
+
+## How it looks like?
+
+When everything is covered:
+
+![image](https://user-images.githubusercontent.com/1573141/147943954-ef708577-2856-4de0-9397-dead487b8c08.png)
+
+When some lines missing coverage:
+
+![image](https://user-images.githubusercontent.com/1573141/147944130-9b901646-05ff-4a76-86c9-30631b0a0dd4.png)
+
+## License
+
+MIT

package/bin/c4.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+
+import {readFileSync} from 'fs';
+
+const {parse} = JSON;
+const coverageFile = parse(readFileSync('./coverage.json', 'utf8'));
+
+const files = [];
+const coverage = {
+    files,
+    coveredCount: 0,
+    uncoveredCount: 0,
+};
+
+console.log('# TAP version 13');
+console.log('');
+
+for (const {name, lines} of coverageFile) {
+    const uncoveredLines = [];
+    
+    for (const [line, covered] of Object.entries(lines)) {
+        if (covered)
+            continue;
+        
+        uncoveredLines.push(line);
+    }
+    
+    const file = {
+        name,
+        covered: !uncoveredLines.length,
+        uncoveredLines,
+    };
+    
+    if (file.covered)
+        ++coverage.coveredCount;
+    
+    if (!file.covered)
+        ++coverage.uncoveredCount;
+    
+    files.push(file);
+}
+
+for (const {name, covered, uncoveredLines} of files) {
+    if (!covered) {
+        console.log(`# ${name}`);
+        console.log('❌ should be covered');
+        console.log('---');
+        console.log(`lines: ${chalk.red(uncoveredLines.join(','))}`);
+    }
+}
+
+if (coverage.uncoveredCount)
+    console.log('');
+
+console.log(`1..${files.length}`);
+console.log(`# files: ${files.length}`);
+console.log(`# covered: ${coverage.coveredCount}`);
+
+if (!coverage.uncoveredCount) {
+    console.log('');
+    console.log('# ☘️  ok');
+}
+
+if (coverage.uncoveredCount) {
+    console.log(`# 🧨 fail: ${coverage.uncoveredCount}`);
+}
+

package/c4.json

@@ -0,0 +1,15 @@
+[{
+    "name": "changelog.js",
+    "lines": {
+        "1": false,
+        "7": false,
+        "9": false
+    }
+}, {
+    "name": "simple.js",
+    "lines": {
+        "1": true,
+        "7": true,
+        "9": true
+    }
+}]

package/coverage.json

@@ -0,0 +1 @@
+[]

package/example/example.js

@@ -0,0 +1,4 @@
+export const sum = (a, b) => a + b;
+
+export const mul = (a, b) => a * b;
+

package/lib/c4.js

@@ -0,0 +1,36 @@
+import montag from 'montag';
+import process from 'process';
+import {instrument} from './instrument/index.js';
+import {exclude} from './exclude.js';
+import {save} from './save.js';
+import {createFileEntry} from './report.js';
+
+global.__createC4 = createFileEntry;
+
+export async function load(url, context, defaultLoad) {
+    const {format, source: rawSource} = await defaultLoad(url, context, defaultLoad);
+    
+    if (/commonjs|builtin/.test(format))
+        return {
+            format,
+        };
+    
+    if (exclude(url, ['.spec.js', 'node_modules']))
+        return {
+            format,
+            source: rawSource,
+        };
+    
+    const source = montag`
+        const __c4 = global.__createC4('${url}');
+        ${instrument(url, rawSource)}
+    `;
+    
+    return {
+        format,
+        source: `${source}\n console.log('🧨', '${url}')`,
+    };
+}
+
+process.once('exit', save);
+

package/lib/exclude.js

@@ -0,0 +1,8 @@
+export const exclude = (url, names) => {
+    for (const name of names) {
+        if (url.includes(name))
+            return true;
+    }
+    
+    return false;
+};

package/lib/instrument/fixture/declare-fix.js

@@ -0,0 +1,9 @@
+const {__c4} = global;
+__c4.mark(1, 0), cli({
+    stdout,
+    stderr,
+    exit,
+    cwd: (__c4.mark(5, 9), process.cwd()),
+    argv: (__c4.mark(6, 10), process.argv.slice(2))
+});
+

package/lib/instrument/fixture/declare.js

@@ -0,0 +1,8 @@
+cli({
+    stdout,
+    stderr,
+    exit,
+    cwd: process.cwd(),
+    argv: process.argv.slice(2)
+})
+

package/lib/instrument/index.js

@@ -0,0 +1,21 @@
+import putout, {} from 'putout';
+
+import * as markLine from './plugin-mark-line/index.js';
+
+export const instrument = (url, source) => {
+    const __c4 = global.__createC4(url);
+    const options = {
+        rules: {
+            'mark-line': ['on', {
+                __c4,
+            }],
+        },
+        plugins: [
+            ['mark-line', markLine],
+        ],
+    };
+    
+    const {code} = putout(source, options);
+    return code;
+};
+

package/lib/instrument/plugin-mark-line/arrow.js

@@ -0,0 +1,14 @@
+import {types} from 'putout';
+
+const {SequenceExpression} = types;
+
+export const addMarkToArrowFunction = (path, lineNode) => {
+    const {node} = path;
+    const {expression} = lineNode;
+    
+    node.body = SequenceExpression([
+        expression,
+        node.body,
+    ]);
+};
+

package/lib/instrument/plugin-mark-line/fixture/arrow-fix.js

@@ -0,0 +1,6 @@
+export const nothing = (a, b) => {
+    return __c4.mark(2, 4);
+};
+export const sum = (a, b) => {
+    return __c4.mark(5, 4), a + b;
+};

package/lib/instrument/plugin-mark-line/fixture/arrow.js

@@ -0,0 +1,6 @@
+export const nothing = (a, b) => {
+    return;
+};
+export const sum = (a, b) => {
+    return a + b;
+};

package/lib/instrument/plugin-mark-line/fixture/logical-fix.js

@@ -0,0 +1,3 @@
+if ((__c4.mark(1, 4), a) || (__c4.mark(1, 9), b)) {
+  __c4.mark(1, 12);
+}

package/lib/instrument/plugin-mark-line/fixture/logical.js

@@ -0,0 +1,2 @@
+if (a || b) {
+}

package/lib/instrument/plugin-mark-line/fixture/mark-line-fix.js

@@ -0,0 +1,30 @@
+const a = () => {
+    a = 5;
+    __c4.mark(3, 4), console.log(5);
+};
+
+
+function x() {
+    
+    if (a > 2) {
+        __c4.mark(9, 14), a();
+    } else {
+        __c4.mark(10, 9), b();
+    }
+}
+
+for (const x of y) {
+    __c4.mark(13, 19);
+}
+
+const ax = ((__c4.mark(16, 12), a()), (__c4.mark(16, 17), b()));
+const bx = (c, (__c4.mark(17, 15), d()));
+
+if ((__c4.mark(19, 4), a) || (__c4.mark(19, 9), b)) {
+    __c4.mark(19, 12);
+}
+
+
+function x1(a, b = (__c4.mark(23, 15), b)) {
+    __c4.mark(23, 22);
+}

package/lib/instrument/plugin-mark-line/fixture/mark-line.js

@@ -0,0 +1,24 @@
+const a = () => {
+    a = 5;
+    console.log(5);
+};
+
+
+function x() {
+    
+    if (a > 2)a()
+    else b();
+}
+
+for (const x of y) {
+}
+
+const ax = (a(), b());
+const bx = (c, d());
+
+if (a || b) {
+}
+
+
+function x1(a, b = 5) {
+}

package/lib/instrument/plugin-mark-line/fixture/new-fix.js

@@ -0,0 +1 @@
+const files = (__c4.mark(1, 14), new Map());

package/lib/instrument/plugin-mark-line/fixture/new.js

@@ -0,0 +1 @@
+const files = new Map();

package/lib/instrument/plugin-mark-line/fixture/no-loc-fix.js

@@ -0,0 +1,8 @@
+__c4.mark(1, 0), cli({
+    stdout,
+    stderr,
+    exit,
+    cwd: (__c4.mark(5, 9), process.cwd()),
+    argv: (__c4.mark(6, 10), process.argv.slice(2))
+});
+

package/lib/instrument/plugin-mark-line/fixture/no-loc.js

@@ -0,0 +1,8 @@
+cli({
+    stdout,
+    stderr,
+    exit,
+    cwd: process.cwd(),
+    argv: process.argv.slice(2)
+})
+

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

@@ -0,0 +1,169 @@
+import {
+    template,
+    types,
+    operator,
+} from 'putout';
+import {addMarkToReturn} from './return.js';
+import {addMarkToArrowFunction} from './arrow.js';
+
+const {
+    NumericLiteral,
+    SequenceExpression,
+    BlockStatement,
+} = types;
+
+const {
+    replaceWithMultiple,
+    replaceWith,
+    compareAny,
+} = operator;
+
+const LINE = '__c4.mark(__l, __c)';
+const buildLineNode = template(LINE, {
+    placeholderPattern: /^__[a-z]$/,
+});
+
+function getLineNode(__c4, {line, column}) {
+    __c4.init(line, column);
+    
+    return buildLineNode({
+        __l: NumericLiteral(line),
+        __c: NumericLiteral(column),
+    });
+}
+
+export const report = () => 'Mark line';
+
+export const fix = (path, {options}) => {
+    const {
+        parentPath,
+        node,
+    } = path;
+    
+    const {start} = path.node.loc || parentPath.node.loc || {};
+    
+    if (!start)
+        return;
+    
+    const {
+        __c4 = {
+            mark: () => {},
+            init: () => {},
+        },
+    } = options;
+    
+    const lineNode = getLineNode(__c4, start);
+    
+    if (path.isBlockStatement()) {
+        path.node.body.unshift(lineNode);
+        return;
+    }
+    
+    if (path.isCallExpression()) {
+        const {node} = path;
+        replaceWith(path, SequenceExpression([
+            lineNode.expression,
+            node,
+        ]));
+        return;
+    }
+    
+    if (path.isLogicalExpression()) {
+        replaceWith(path.get('left'), SequenceExpression([
+            lineNode.expression,
+            path.node.left,
+        ]));
+        replaceWith(path.get('right'), SequenceExpression([
+            getLineNode(__c4, path.node.right.loc.start).expression,
+            path.node.right,
+        ]));
+        return;
+    }
+    
+    if (path.isAssignmentPattern()) {
+        replaceWithMultiple(path.get('right'), [
+            lineNode,
+            node.left,
+        ]);
+        return;
+    }
+    
+    if (path.isNewExpression()) {
+        replaceWith(path, SequenceExpression([
+            lineNode.expression,
+            node,
+        ]));
+        return;
+    }
+    
+    if (path.isReturnStatement())
+        return addMarkToReturn(path, lineNode);
+    
+    if (path.isArrowFunctionExpression())
+        return addMarkToArrowFunction(path, lineNode);
+    
+    replaceWith(path, BlockStatement([
+        node,
+    ]));
+};
+
+const EXCLUDE = [
+    LINE,
+    `(${LINE}, __z)`,
+    `return (${LINE}, __z)`,
+    `return ${LINE}`,
+];
+
+export const exclude = () => EXCLUDE;
+
+export const include = () => [
+    'AssignmentPattern',
+    'CallExpression',
+    'NewExpression',
+    'ReturnStatement',
+];
+
+export const traverse = ({push}) => ({
+    ArrowFunctionExpression(path) {
+        if (path.get('body').isBlockStatement())
+            return;
+        
+        push(path);
+    },
+    LogicalExpression(path) {
+        if (compareAny(path.get('left'), EXCLUDE))
+            return;
+        
+        push(path);
+    },
+    BlockStatement(path) {
+        if (path.node.body.length)
+            return;
+        
+        push(path);
+    },
+    SequenceExpression(path) {
+        const expressions = path.get('expressions');
+        
+        for (const expPath of expressions) {
+            if (!expPath.isCallExpression())
+                continue;
+            
+            push(expPath);
+        }
+    },
+    IfStatement(path) {
+        const consequentPath = path.get('consequent');
+        const alternatePath = path.get('alternate');
+        
+        if (!consequentPath.isBlockStatement())
+            push(consequentPath);
+        
+        if (!alternatePath.node)
+            return;
+        
+        if (!alternatePath.isBlockStatement())
+            push(alternatePath);
+    },
+});
+

package/lib/instrument/plugin-mark-line/return.js

@@ -0,0 +1,17 @@
+import {types} from 'putout';
+const {SequenceExpression} = types;
+
+export const addMarkToReturn = (path, lineNode) => {
+    const {node} = path;
+    const {expression} = lineNode;
+    
+    if (!node.argument) {
+        node.argument = expression;
+        return;
+    }
+    
+    node.argument = SequenceExpression([
+        expression,
+        node.argument,
+    ]);
+};

package/lib/report.js

@@ -0,0 +1,17 @@
+const files = new Map();
+
+export const createFileEntry = (url) => {
+    const lines = files.get(url) || new Map();
+    files.set(url, lines);
+    
+    return {
+        mark: (line, column) => {
+            lines.set(`${line}:${column}`, true);
+        },
+        init: (line, column) => {
+            lines.set(`${line}:${column}`, false);
+        },
+    };
+};
+
+export const getFiles = () => files;

package/lib/save.js

@@ -0,0 +1,27 @@
+import {writeFileSync} from 'fs';
+import once from 'once';
+import {getFiles} from './report.js';
+
+const {stringify} = JSON;
+
+export const save = once(() => {
+    const files = getFiles();
+    const report = [];
+    for (const [name, places] of files.entries()) {
+        const lines = {};
+        const current = {
+            name,
+            lines,
+        };
+        for (const [place, covered] of places.entries()) {
+            const [line] = place.split(':');
+            
+            lines[line] = covered;
+        }
+        
+        report.push(current);
+    }
+    
+    writeFileSync('./coverage.json', stringify(report, null, 4));
+});
+

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "escover",
+  "version": "1.0.0",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "Coverage for EcmaScript Modules",
+  "main": "lib/escover.js",
+  "type": "module",
+  "bin": {
+    "escover": "bin/escover.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/coderaiser/escover.git"
+  },
+  "keywords": [
+    "coverage",
+    "putout",
+    "loader"
+  ],
+  "scripts": {
+    "test": "madrun test",
+    "coverage": "madrun coverage",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "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",
+    "watch:coverage": "madrun watch:coverage"
+  },
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "montag": "^1.2.1",
+    "once": "^1.4.0",
+    "putout": "^23.5.0"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@putout/test": "^4.1.0",
+    "c8": "^7.8.0",
+    "eslint": "^8.3.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-putout": "^12.2.0",
+    "madrun": "^8.8.1",
+    "mock-import": "^2.0.0",
+    "supertape": "^6.0.5",
+    "zenload": "^1.0.0"
+  }
+}