monocart-coverage-reports 2.4.2 → 2.4.4

package/README.md

@@ -24,6 +24,8 @@
 * [Node.js V8 Coverage Report for Server Side](#nodejs-v8-coverage-report-for-server-side)
 * [Multiprocessing Support](#multiprocessing-support)
 * [Merge Coverage Reports](#merge-coverage-reports)
+* [Resolve `sourcePath` for the Source Files](#resolve-sourcepath-for-the-source-files)
+* [Adding Empty Coverage for Untested Files](#adding-empty-coverage-for-untested-files)
 * [Ignoring Uncovered Codes](#ignoring-uncovered-codes)
 * [Chromium Coverage API](#chromium-coverage-api)
 * [V8 Coverage Data Format](#v8-coverage-data-format)
@@ -70,8 +72,6 @@ console.log(coverageResults.summary);
     - [V8 coverage-report.json](https://cenfun.github.io/monocart-coverage-reports/v8-and-istanbul/coverage-report.json)
 - `codecov` (V8 data only)
     - coverage data for [Codecov](https://docs.codecov.com/docs/codecov-custom-coverage-format), see [example](https://app.codecov.io/github/cenfun/monocart-coverage-reports) 
-    
-    ![](test/console-summary.png)
 
 > Istanbul [build-in reports](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-reports/lib)
 - `clover`
@@ -95,6 +95,7 @@ console.log(coverageResults.summary);
 
 > Other reports
 - `console-summary` shows coverage summary in console
+![](test/console-summary.png)
 - `raw` only keep all original data, which can be used for other reports input with `inputDir`
     - see [Merge Coverage Reports](#merge-coverage-reports)
 
@@ -258,16 +259,14 @@ mcr "node ./test/test-node-env.js" -c test/cli-options.js
 | Coverage data | [Istanbul](https://github.com/gotwarlost/istanbul/blob/master/coverage.json.md) (Object) | [V8](#v8-coverage-data-format) (Array) | [V8](#v8-coverage-data-format) (Array) |
 | Output | [Istanbul reports](#available-reports) | [V8 reports](#available-reports)  | [Istanbul reports](#available-reports) |
 | - Bytes | ❌ | ✅ | ❌ |
-| - Statements | ✅ | ❌ | ☑️❔ |
-| - Branches | ✅ | ☑️❔ | ☑️❔ |
+| - Statements | ✅ | ✅ | ✅ |
+| - Branches | ✅ | ✅ | ✅ |
 | - Functions | ✅ | ✅ | ✅ |
 | - Lines | ✅ | ✅ | ✅ |
 | - Execution counts | ✅ | ✅ | ✅ |
 | CSS coverage | ❌ | ✅ | ✅ |
 | Minified code | ❌ | ✅ | ❌ |
 
-❔ - Partial or conditional support
-
 ## Compare Workflows
 - Istanbul Workflows
     - 1, [Collecting Istanbul coverage data](#collecting-istanbul-coverage-data)
@@ -451,7 +450,10 @@ const coverageOptions = {
 };
 await new CoverageReport(coverageOptions).generate();
 ```
-If the source file comes from the sourcemap, then its path is a virtual path. Using the `sourcePath` option to convert it.
+
+## Resolve `sourcePath` for the Source Files
+If the source file comes from the sourcemap, then its path is a virtual path. Using the `sourcePath` option to resolve a custom path.
+For example, we have tested multiple dist files, which contain some common files. We hope to merge the coverage of the same files, so we need to unify the `sourcePath` in order to be able to merge the coverage data.
 ```js
 const coverageOptions = {
     sourcePath: (filePath) => {
@@ -468,6 +470,44 @@ const coverageOptions = {
 ```
 see example: [./test/test-merge.js](./test/test-merge.js)
 
+## Adding Empty Coverage for Untested Files
+By default the untested files will not be included in the coverage report, we can first add empty coverage data for all files, so the files with coverage data will be merged, and untested files will retain 0% coverage.
+```js
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const MCR = require('monocart-coverage-reports');
+
+const dir = "./src";
+const coverageData = [];
+const fileList = fs.readdirSync(dir);
+for (const filename of fileList) {
+    const filePath = path.resolve(dir, filename);
+    const source = fs.readFileSync(filePath).toString('utf-8');
+    const sourcePath = path.relative(process.cwd(), filePath);
+    const url = pathToFileURL(sourcePath).toString();
+    const extname = path.extname(filename);
+    if (['.css'].includes(extname)) {
+        coverageData.push({
+            empty: true,
+            type: 'css',
+            url,
+            text: source
+        });
+    } else {
+        coverageData.push({
+            empty: true,
+            type: 'js',
+            url,
+            source
+        });
+    }
+}
+const options = require('path-to/same-options.js');
+await MCR(options).add(coverageData);
+```
+see example: [./test/cli-options.js](./test/cli-options.js)
+
 ## Ignoring Uncovered Codes
 To ignore codes, use the special comment which starts with `v8 ignore `:
 - Ignoring all until stop
@@ -575,15 +615,15 @@ see source code [v8-to-istanbul.js](https://github.com/istanbuljs/v8-to-istanbul
 ### How Monocart Works
 We implemented new converter instead of v8-to-istanbul:
 - 1, Trying to fix the middle position if not found the exact mapping for the position.
-- 2, Finding all functions and branches by parsing the source code [AST](https://github.com/acornjs/acorn), however the V8 cannot provide effective branch coverage information, so the branches is still not perfect but close to reality.
+- 2, Finding all functions, statements and branches by parsing the source code [AST](https://github.com/acornjs/acorn), however the V8 cannot provide effective branch coverage information for `AssignmentPattern`.
 
 | AST                   | V8             | 
 | :---------------------| :------------- | 
 | AssignmentPattern     | 🛇 Not Support | 
-| ConditionalExpression | ✔ Not Perfect | 
-| IfStatement           | ✔ Not Perfect | 
-| LogicalExpression     | ✔ Not Perfect | 
-| SwitchStatement       | ✔ Not Perfect | 
+| ConditionalExpression | ✔  | 
+| IfStatement           | ✔  | 
+| LogicalExpression     | ✔  | 
+| SwitchStatement       | ✔  | 
 
 ## Debug for Coverage and Sourcemap
 > Sometimes, the coverage is not what we expect. The next step is to figure out why, and we can easily find out the answer step by step through debugging.

package/lib/converter/ast-visitor.js

@@ -117,18 +117,21 @@ const createBranchGroup = (type, node, parents, branchMap) => {
         group.operator = node.operator;
     }
 
-    branchMap.set(start, group);
+    // could be same start
+    const branchKey = `${start}_${end}`;
+
+    branchMap.set(branchKey, group);
     return group;
 };
 
 const addBranch = (group, node, locationMap) => {
     const { start, end } = node;
 
-    const branchStart = group.start;
+    const branchKey = `${group.start}_${group.end}`;
 
     const branchInfo = {
         // for get previous group for LogicalExpression
-        branchStart,
+        branchKey,
         start,
         end,
         // branch count default to 0
@@ -203,23 +206,16 @@ const IfStatement = (group, parentCount) => {
 
 // const b = tf2 || tf1 || a;
 const LogicalExpression = (group, parentCount) => {
-    const { noBlockList, blockCount } = updateBlockLocations(group.locations);
-    if (!noBlockList.length) {
-        return;
-    }
 
-    if (group.operator === '&&') {
-        // console.log(group.start, noBlockList);
-        noBlockList.forEach((item) => {
+    // from left to right
+    group.locations.forEach((item, i) => {
+        if (item.block) {
+            item.count = item.block.count;
+        } else {
             item.count = parentCount;
-        });
-        return;
-    }
-
-    const count = parentCount - blockCount;
-    noBlockList.forEach((item) => {
-        item.count = count;
+        }
     });
+
 };
 
 const SwitchStatement = (group, parentCount) => {
@@ -408,7 +404,7 @@ const collectNodes = (ast) => {
             // =============================================================
             // id: { type: 'Identifier', name: '__webpack_modules__' },
             const name = node.id && node.id.name;
-            if (name === '__webpack_modules__' && node.init) {
+            if (name === '__webpack_modules__' && node.init && node.init.properties) {
                 // mark all as wrap function
                 node.init.properties.forEach((it) => {
                     it.value._wrapKey = it.key && it.key.value;
@@ -501,12 +497,15 @@ const collectNodes = (ast) => {
             const { left, right } = node;
             // console.log(left.start, right.start);
 
+            // could be same branch start
+            // const da = arguments.length > 1 && typeof arguments[1] !== 'undefined' ? arguments[1] : true;
+
             let group;
             // link to same branch start if LogicalExpression
             const prevLocation = locationMap.get(node.start);
             if (prevLocation) {
                 // console.log('link branch ==================', type);
-                group = branchMap.get(prevLocation.branchStart);
+                group = branchMap.get(prevLocation.branchKey);
             } else {
                 group = createBranchGroup('LogicalExpression', node, parents, branchMap);
                 addBranch(group, left, locationMap);
@@ -574,6 +573,26 @@ const getRootFunctionState = (ast, coverageInfo) => {
     return rootState;
 };
 
+const findFunctionRange = (item, coverageInfo) => {
+
+    const { node, reverseParents } = item;
+    const { start, end } = node;
+
+    // try function start/end
+    const functionRange = getFunctionRange(start, end, coverageInfo);
+    if (functionRange) {
+        return functionRange;
+    }
+
+    // try if class MethodDefinition
+    // 0 is function self
+    const parent = reverseParents[1];
+    if (parent && parent.type === 'MethodDefinition') {
+        return getFunctionRange(parent.start, parent.end, coverageInfo);
+    }
+
+};
+
 const collectAstInfo = (ast, coverageInfo) => {
 
     const {
@@ -611,7 +630,8 @@ const collectAstInfo = (ast, coverageInfo) => {
             isFunction: true,
             count: functionItem.count
         };
-        const functionRange = getFunctionRange(start, end, coverageInfo);
+
+        const functionRange = findFunctionRange(item, coverageInfo);
         if (functionRange) {
             if (isWrap) {
                 functionRange.wrap = true;

package/lib/converter/ast.js

@@ -159,8 +159,8 @@ const getJsAstInfo = (item, coverageList) => {
         // most time for node.js file
         allowReturnOutsideFunction: true,
         allowImportExportEverywhere: true,
-        allowSuperOutsideMethod: true,
         allowAwaitOutsideFunction: true,
+        allowSuperOutsideMethod: true,
         // first line: #!/usr/bin/env node
         allowHashBang: true
     };

package/lib/converter/converter.js

@@ -579,11 +579,12 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
                 return newLoc;
             }
 
+            // before new range
+            newLoc.generatedStart = newLoc.start;
+            newLoc.generatedEnd = newLoc.end;
             // mapping to new range
             newLoc.start = locResult.start;
             newLoc.end = locResult.end;
-            newLoc.generatedStart = newLoc.start;
-            newLoc.generatedEnd = newLoc.end;
 
             return newLoc;
         });
@@ -826,7 +827,6 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 
     // add offset and index
     decodedMappings.forEach((item, i) => {
-        item.originalIndex = i;
         item.originalOffset = locator.locationToOffset({
             line: item.originalLine + 1,
             column: item.originalColumn

package/lib/converter/find-original-range.js

@@ -266,13 +266,13 @@ const getOriginalEndOffset = (m, rangeInfo) => {
     return m.originalEndOffset;
 };
 
-const getOriginalText = (m1, m2, rangeInfo) => {
+const getOriginalText = (m1, m2, rangeInfo, direction) => {
     const originalLocator = rangeInfo.originalState.locator;
 
     const o1 = m1.originalOffset;
     const o2 = m2.originalOffset;
 
-    // most of time o1 < o2
+    // o1 < o2: most of time
     if (o1 < o2) {
         // could be multiple lines for original text
         return {
@@ -291,10 +291,28 @@ const getOriginalText = (m1, m2, rangeInfo) => {
         };
     }
 
-    // o1 > o2
+    // o1 > o2: should be wrong sourcemap
+
+    // just reverse offsets if few cross lines
+    const crossLines = m1.originalLine - m2.originalLine;
+    if (crossLines < 2) {
+        return {
+            originalOffset: o2,
+            originalText: originalLocator.getSlice(o2, o1)
+        };
+    }
+
+    // if (direction === 'start') {
+    // should be m2 ?
+    // console.log(direction, rangeInfo.originalState.sourcePath);
+    // console.log(m1, m2);
+    // }
+
+    // should be wrong, ignore m2
+    const originalEndOffset = getOriginalEndOffset(m1, rangeInfo);
     return {
-        originalOffset: o2,
-        originalText: originalLocator.getSlice(o2, o1)
+        originalOffset: o1,
+        originalText: originalLocator.getSlice(o1, originalEndOffset)
     };
 
 };
@@ -350,34 +368,12 @@ const getGeneratedText = (m1, m2, state, offset) => {
 
 };
 
-const checkOriginalMappings = (m1, m2, direction) => {
-    // check original offset order
-    if (m1.originalOffset <= m2.originalOffset) {
-        return;
-    }
-
-    // just reverse offsets if few cross lines
-    const crossLines = m1.originalLine - m2.originalLine;
-    if (crossLines < 2) {
-        return;
-    }
-
-    // console.log('================================================');
-    // console.log(crossLines);
-    // console.log(m1, m2);
-
-    // should be mistake
-    return {
-        error: true,
-        errors: [`invalid original ${direction}: ${EC.yellow(m1.originalOffset)} > ${EC.yellow(m2.originalOffset)}`]
-    };
-};
-
 // ========================================================================================================
 
 const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
-    const { originalState, crossStart } = rangeInfo;
+
     const [m1, m2] = mappings;
+    const { originalState, crossStart } = rangeInfo;
 
     // cross file from start of line
     if (crossStart) {
@@ -387,12 +383,7 @@ const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
     }
 
     const direction = 'start';
-    const errorInfo = checkOriginalMappings(m1, m2, direction);
-    if (errorInfo) {
-        return errorInfo;
-    }
-
-    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo, direction);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
 
     const originalPos = getFixedPosition({
@@ -402,6 +393,17 @@ const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
         originalState
     }, direction);
 
+    // if (start === 2660) {
+    //     console.log('=====================================================');
+    //     console.log('fixed start', originalState.sourcePath);
+    //     console.log({
+    //         generatedText,
+    //         generatedPos,
+    //         originalText,
+    //         originalPos
+    //     });
+    // }
+
     return {
         originalStart: originalOffset + originalPos
     };
@@ -409,18 +411,8 @@ const getFixedOriginalStart = (start, mappings, state, rangeInfo) => {
 
 const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
 
-    const { decodedMappings } = state;
-
-    // end is exclusive, try previous one if exact match
-    const prevMapping = findMapping(decodedMappings, end - 1);
-    if (prevMapping && !Array.isArray(prevMapping)) {
-        return {
-            originalEnd: prevMapping.originalOffset + 1
-        };
-    }
-
-    const { originalState, crossEnd } = rangeInfo;
     const [m1, m2] = mappings;
+    const { originalState, crossEnd } = rangeInfo;
 
     // cross file until e1 line end (not file end)
     if (crossEnd) {
@@ -430,13 +422,41 @@ const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
         };
     }
 
-    const direction = 'end';
-    const errorInfo = checkOriginalMappings(m1, m2, direction);
-    if (errorInfo) {
-        return errorInfo;
+    // end is exclusive
+    // quick check previous one if exact match
+    // most of case is matching "}"
+    if (m1.generatedOffset === end - 1) {
+        return {
+            originalEnd: m1.originalOffset + 1
+        };
+    }
+
+    // quick check next one if exact match
+    // most of case is same string
+    if (m2.generatedOffset === end + 1) {
+        const gt = state.locator.source[end];
+        const oi = m2.originalOffset - 1;
+        const ot = originalState.locator.source[oi];
+        if (gt === ot) {
+            return {
+                originalEnd: oi
+            };
+        }
+
+        // Not applicable
+        // console.log('==================================');
+        // console.log({
+        //     gp: state.sourcePath,
+        //     g: end,
+        //     gt,
+        //     op: originalState.sourcePath,
+        //     o: oi,
+        //     ot
+        // });
     }
 
-    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo);
+    const direction = 'end';
+    const { originalText, originalOffset } = getOriginalText(m1, m2, rangeInfo, direction);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
 
     const originalPos = getFixedPosition({
@@ -446,6 +466,17 @@ const getFixedOriginalEnd = (end, mappings, state, rangeInfo) => {
         originalState
     }, direction);
 
+    // if (end === 2858) {
+    //     console.log('=====================================================');
+    //     console.log('fixed end', originalState.sourcePath);
+    //     console.log({
+    //         generatedText,
+    //         generatedPos,
+    //         originalText,
+    //         originalPos
+    //     });
+    // }
+
     return {
         originalEnd: originalOffset + originalPos
     };
@@ -614,23 +645,13 @@ const getOriginalState = (startMappings, endMappings, originalMap) => {
     };
 };
 
-const findOriginalRange = (start, end, state, originalMap) => {
-
-    const { sourcePath, decodedMappings } = state;
-
-    const createMappingError = (errors) => {
+const getMappingInfo = (decodedMappings, start, end) => {
+    // possible no length
+    if (decodedMappings.length < 2) {
         return {
             error: true,
-            start,
-            end,
-            sourcePath,
-            errors
+            errors: ['invalid decoded mappings (length < 2)']
         };
-    };
-
-    // possible no length
-    if (decodedMappings.length < 2) {
-        return createMappingError(['not found decoded mappings']);
     }
 
     // start: inclusive
@@ -653,6 +674,33 @@ const findOriginalRange = (start, end, state, originalMap) => {
         };
     }
 
+    return {
+        startMappings,
+        endMappings
+    };
+};
+
+const findOriginalRange = (start, end, state, originalMap) => {
+
+    const { sourcePath, decodedMappings } = state;
+
+    const createMappingError = (errors) => {
+        return {
+            error: true,
+            start,
+            end,
+            sourcePath,
+            errors
+        };
+    };
+
+    const mappingInfo = getMappingInfo(decodedMappings, start, end);
+    if (mappingInfo.error) {
+        return createMappingError(mappingInfo.errors);
+    }
+
+    const { startMappings, endMappings } = mappingInfo;
+
     const rangeInfo = getOriginalState(startMappings, endMappings, originalMap);
     if (rangeInfo.error) {
         return createMappingError(rangeInfo.errors);

package/lib/generate.js

@@ -63,7 +63,7 @@ const getReportGroup = (reports, lcov, dataType) => {
     }
 
     // add lcovonly report after default report
-    if (lcov) {
+    if (lcov && !reportMap.lcovonly) {
         reportMap.lcovonly = {};
     }