monocart-coverage-reports 2.3.4 → 2.4.1

package/lib/converter/converter.js

@@ -17,17 +17,36 @@ const {
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
 const { decode } = require('../packages/monocart-coverage-vendor.js');
 
-const InfoLine = require('./info-line.js');
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
+const InfoStatement = require('./info-statement.js');
+
+// ========================================================================================================
+
+// debug info
+const logMappingErrors = (type, result) => {
+
+    // const {
+    //     errors, start, end, sourcePath
+    // } = result;
+    // // if (!sourcePath.endsWith('monocart-v8.js') || type !== 'byte') {
+    // //     return;
+    // // }
+    // const list = [
+    //     Util.EC.red('[Mapping]'),
+    //     Util.EC.magenta(type),
+    //     errors.join(' -> '),
+    //     Util.EC.blue(`${start} ~ ${end}`),
+    //     sourcePath
+    // ];
+    // console.log(list.join(' '));
+
+};
 
 // ========================================================================================================
 
 const handleIgnoredRanges = (list, ignoredRanges) => {
     list.forEach((item) => {
-        if (item.count > 0) {
-            return;
-        }
         const range = Util.findInRanges(item.start, item.end, ignoredRanges, 'start', 'end');
         if (range) {
             // console.log(item, range);
@@ -36,7 +55,6 @@ const handleIgnoredRanges = (list, ignoredRanges) => {
     });
 };
 
-// ========================================================================================================
 
 const applyBytesToLines = (bytes, locator, lineMap) => {
     bytes.forEach((range) => {
@@ -68,10 +86,10 @@ const applyBytesToLines = (bytes, locator, lineMap) => {
             it.count = count;
 
             // default is covered, so only focus on
-            // 1, last covered count
+            // 1, biggest covered count
             // 2, uncovered entire and pieces
             if (count > 0) {
-                lineItem.coveredCount = count;
+                lineItem.coveredCount = Math.max(lineItem.coveredCount, count);
             } else {
                 if (it.entire) {
                     lineItem.uncoveredEntire = it;
@@ -82,6 +100,37 @@ const applyBytesToLines = (bytes, locator, lineMap) => {
         });
 
     });
+
+    // no ignore items
+    lineMap.forEach((lineItem, line) => {
+
+        const {
+            uncoveredEntire, uncoveredPieces, coveredCount
+        } = lineItem;
+
+        // default count to 1, both js and css
+        let count = 1;
+        // full covered true/false for entire line
+        let covered = true;
+
+        if (uncoveredEntire) {
+            count = 0;
+            covered = false;
+        } else {
+            count = coveredCount;
+            const uncoveredLen = uncoveredPieces.length;
+            if (uncoveredLen > 0) {
+                covered = false;
+                // uncovered
+                count = `1/${uncoveredLen + 1}`;
+            }
+        }
+
+        lineItem.covered = covered;
+        lineItem.count = count;
+
+    });
+
 };
 
 const handleLinesCoverage = (bytes, locator, ignoredRanges) => {
@@ -115,120 +164,60 @@ const handleLinesCoverage = (bytes, locator, ignoredRanges) => {
 
     applyBytesToLines(bytes, locator, lineMap);
 
-    const lines = [];
+    const summaryLines = {
+        total: 0,
+        covered: 0,
+        blank: blankCount,
+        comment: commentCount
+    };
     // data lines for codecov
     // https://docs.codecov.com/docs/codecov-custom-coverage-format
     const dataLines = {};
 
     // no ignore items
     lineMap.forEach((lineItem, line) => {
-
-        const {
-            uncoveredEntire, uncoveredPieces, coveredCount
-        } = lineItem;
-
-        // default count to 1, both js and css
-        let count = 1;
-        // full covered true/false for entire line
-        let covered = true;
-
-        if (uncoveredEntire) {
-            count = 0;
-            covered = false;
-        } else {
-
-            count = coveredCount;
-            const uncoveredLen = uncoveredPieces.length;
-            if (uncoveredLen > 0) {
-                covered = false;
-
-                // uncovered
-                count = `1/${uncoveredLen + 1}`;
-
-            }
-
-        }
-
+        const { count, covered } = lineItem;
         // data lines
         dataLines[line] = count;
 
-        // exclude indent?
-        const infoLine = new InfoLine(line, lineItem.length, count, covered);
-        lines.push(infoLine);
+        summaryLines.total += 1;
+        if (covered) {
+            summaryLines.covered += 1;
+        }
     });
 
     return {
-        lines,
         dataLines,
-        blankCount,
-        commentCount
+        summaryLines
     };
 };
 
 // ========================================================================================================
 
-const calculateV8Functions = (functions) => {
-
-    const v8Functions = {
-        total: 0,
-        covered: 0
-    };
-
-    functions.forEach((fn) => {
-        if (fn.ignored) {
-            return;
-        }
-
-        v8Functions.total += 1;
-        if (fn.count > 0) {
-            v8Functions.covered += 1;
-        }
-    });
-
-    return v8Functions;
-};
+const calculateV8Summary = (list) => {
 
-const calculateV8Branches = (branches) => {
-    const v8Branches = {
+    const summary = {
         total: 0,
         covered: 0
     };
 
-    branches.forEach((branch) => {
-        if (branch.ignored) {
+    list.forEach((item) => {
+        if (item.ignored) {
             return;
         }
-        v8Branches.total += 1;
-        if (branch.count > 0) {
-            v8Branches.covered += 1;
-        }
-    });
-
-    return v8Branches;
-};
-
-const calculateV8Lines = (lines, blankCount, commentCount) => {
-    const v8Lines = {
-        total: 0,
-        covered: 0,
-        blank: blankCount,
-        comment: commentCount
-    };
 
-    // the lines not includes ignored
-    lines.forEach((ln) => {
-        v8Lines.total += 1;
-        // full line covered
-        if (ln.covered) {
-            v8Lines.covered += 1;
+        summary.total += 1;
+        if (item.count > 0) {
+            summary.covered += 1;
         }
     });
 
-    return v8Lines;
+    return summary;
 };
 
 // ========================================================================================================
 // istanbul coverage format
+// https://github.com/istanbuljs/istanbuljs/blob/master/docs/raw-output.md
 /**
  * * `path` - the file path for which coverage is being tracked
  * * `statementMap` - map of statement locations keyed by statement index
@@ -244,6 +233,7 @@ const collectFileCoverage = (v8Data, state, options) => {
         bytes,
         functions,
         branches,
+        statements,
 
         sourcePath,
         locator
@@ -254,7 +244,8 @@ const collectFileCoverage = (v8Data, state, options) => {
     const data = {
         bytes: dedupeCountRanges(bytes),
         functions: [],
-        branches: []
+        branches: [],
+        statements: []
     };
 
     // ==========================================
@@ -267,10 +258,10 @@ const collectFileCoverage = (v8Data, state, options) => {
         // data bytes is start/end/count object
         handleIgnoredRanges(data.bytes, ignoredRanges);
 
-        // functions is InfoFunction start/end/count instance
+        // functions start/end/count instance
         handleIgnoredRanges(functions, ignoredRanges);
 
-        // branches is InfoBranch start/end/count instance
+        // branches start/end/count instance
         handleIgnoredRanges(branches, ignoredRanges);
 
         // branch locations start/end/count object
@@ -285,10 +276,24 @@ const collectFileCoverage = (v8Data, state, options) => {
             }
         });
 
+        // statements start/end/count instance
+        handleIgnoredRanges(statements, ignoredRanges);
+
         // console.log(ignoredRanges);
 
     }
 
+    // ==========================================
+    // lines
+    // after bytes with ignored, before calculateV8Lines
+    const { dataLines, summaryLines } = handleLinesCoverage(data.bytes, locator, ignoredRanges);
+
+    data.lines = dataLines;
+
+    // console.log('statements', state.sourcePath, statements.length);
+
+    // ==========================================
+
     data.functions = functions.map((info) => {
         return info.getRange();
     });
@@ -300,23 +305,24 @@ const collectFileCoverage = (v8Data, state, options) => {
     }).flat();
     sortRanges(data.branches);
 
+    data.statements = statements.map((info) => {
+        return info.getRange();
+    });
+    sortRanges(data.statements);
+
     // ==========================================
-    // lines
-    // after bytes with ignored, before calculateV8Lines
-    const {
-        lines, dataLines, blankCount, commentCount
-    } = handleLinesCoverage(data.bytes, locator, ignoredRanges);
 
-    data.lines = dataLines;
+    const summary = {
+        functions: calculateV8Summary(data.functions),
+        branches: calculateV8Summary(data.branches),
+        statements: calculateV8Summary(data.statements),
+        lines: summaryLines
+    };
 
     // ==========================================
     // v8 data and summary
     v8Data.data = data;
-    v8Data.summary = {
-        functions: calculateV8Functions(data.functions),
-        branches: calculateV8Branches(data.branches),
-        lines: calculateV8Lines(lines, blankCount, commentCount)
-    };
+    v8Data.summary = summary;
 
     // ==========================================
     // istanbul
@@ -332,14 +338,13 @@ const collectFileCoverage = (v8Data, state, options) => {
         b: {}
     };
 
-    // the lines not includes ignored
-    lines.forEach((line, index) => {
-        istanbulData.statementMap[`${index}`] = line.generate();
-        istanbulData.s[`${index}`] = line.count;
+    statements.filter((it) => !it.ignored).forEach((statement, index) => {
+        istanbulData.statementMap[`${index}`] = statement.generate(locator);
+        istanbulData.s[`${index}`] = statement.count;
     });
 
     functions.filter((it) => !it.ignored).forEach((fn, index) => {
-        istanbulData.fnMap[`${index}`] = fn.generate(locator);
+        istanbulData.fnMap[`${index}`] = fn.generate(locator, index);
         istanbulData.f[`${index}`] = fn.count;
     });
 
@@ -349,7 +354,6 @@ const collectFileCoverage = (v8Data, state, options) => {
         istanbulData.b[`${index}`] = counts;
     });
 
-    // istanbul data
     return istanbulData;
 
 };
@@ -361,11 +365,17 @@ const addJsBytesCoverage = (state, range) => {
         startOffset, endOffset, count
     } = range;
     // add bytes range
-    state.bytes.push({
+    const byte = {
         start: startOffset,
         end: endOffset,
         count
-    });
+    };
+    // for debug
+    if (Util.isDebug() && state.original) {
+        byte.generatedStart = range.generatedStart;
+        byte.generatedEnd = range.generatedEnd;
+    }
+    state.bytes.push(byte);
 };
 
 const addCssBytesCoverage = (state, range) => {
@@ -391,11 +401,14 @@ const handleFunctionsCoverage = (state) => {
 
     const { functions, astInfo } = state;
     astInfo.functions.forEach((it) => {
-        const {
-            start, end, functionName, count
-        } = it;
-        const functionInfo = new InfoFunction(start, end, count, functionName);
-        functions.push(functionInfo);
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid function', start, end);
+            return;
+        }
+
+        functions.push(new InfoFunction(it, state.original));
     });
 
 };
@@ -409,11 +422,35 @@ const handleBranchesCoverage = (state) => {
 
     const { branches, astInfo } = state;
     astInfo.branches.forEach((it) => {
-        const {
-            start, end, locations, type
-        } = it;
-        const branchInfo = new InfoBranch(start, end, locations, type);
-        branches.push(branchInfo);
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid branch', state.sourcePath, it);
+            return;
+        }
+
+        branches.push(new InfoBranch(it, state.original));
+    });
+
+};
+
+const handleStatementsCoverage = (state) => {
+
+    // statement only for js
+    if (!state.js) {
+        return;
+    }
+
+    const { statements, astInfo } = state;
+    astInfo.statements.forEach((it) => {
+
+        const { start, end } = it;
+        if (start >= end) {
+            // console.log('invalid statement', start, end);
+            return;
+        }
+
+        statements.push(new InfoStatement(it, state.original));
     });
 
 };
@@ -447,10 +484,22 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
 
     // console.log(state.astInfo.functions);
 
+    const updateFunctionBodyRange = (start, end, bodyStart, bodyEnd, originalFunction) => {
+        if (bodyStart !== start || bodyEnd !== end) {
+            const result = findOriginalRange(bodyStart, bodyEnd, state, originalStateMap);
+            if (result.error) {
+                logMappingErrors('function body', result);
+            } else {
+                originalFunction.bodyStart = result.start;
+                originalFunction.bodyEnd = result.end;
+            }
+        }
+    };
+
     // function count
     state.astInfo.functions.forEach((it) => {
         const {
-            start, end, wrap
+            start, end, bodyStart, bodyEnd, wrap
         } = it;
 
         // remove webpack wrap functions for functions count, not for ranges here
@@ -458,31 +507,27 @@ const handleOriginalFunctionsCoverage = (state, originalStateMap) => {
             return;
         }
 
-        // rename to startOffset and endOffset
-        const range = {
-            startOffset: start,
-            endOffset: end
-        };
-
-        const result = findOriginalRange(range, state, originalStateMap);
+        const result = findOriginalRange(start, end, state, originalStateMap);
         if (result.error) {
+            logMappingErrors('function', result);
             return;
         }
-        const { originalRange, originalState } = result;
 
-        // add back to original ast
-        originalState.astInfo.functions.push({
+        const originalFunction = {
             ... it,
             generatedStart: start,
             generatedEnd: end,
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        });
+            start: result.start,
+            end: result.end,
+            bodyStart: result.start,
+            bodyEnd: result.end
+        };
 
-        // if (originalState.sourcePath.endsWith('store.js')) {
-        //     console.log('==========================================================');
-        //     console.log(it, result.startMapping, result.endMapping);
-        // }
+        // body start and end
+        updateFunctionBodyRange(start, end, bodyStart, bodyEnd, originalFunction);
+
+        // add back to original ast
+        result.originalState.astInfo.functions.push(originalFunction);
 
     });
 
@@ -498,26 +543,20 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
     // console.log(state.astInfo.branches);
 
     // function count
-    state.astInfo.branches.forEach((it) => {
-
-        const { type, locations } = it;
+    state.astInfo.branches.forEach((group) => {
 
-        // rename to startOffset and endOffset
-        const bRange = {
-            startOffset: it.start,
-            endOffset: it.end
-        };
+        const { type, locations } = group;
 
         // start
-        const result = findOriginalRange(bRange, state, originalStateMap);
+        const result = findOriginalRange(group.start, group.end, state, originalStateMap);
         if (result.error) {
-            // not in the original files
+            logMappingErrors('branch group', result);
             return;
         }
-        const { originalRange, originalState } = result;
 
-        const groupStart = originalRange.startOffset;
-        const groupEnd = originalRange.endOffset;
+        // new group start and end
+        const groupStart = result.start;
+        const groupEnd = result.end;
 
         let hasError;
         const newLocations = locations.map((oLoc) => {
@@ -532,29 +571,19 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
                 return newLoc;
             }
 
-            const { start, end } = newLoc;
-
-            const lRange = {
-                startOffset: start,
-                endOffset: end
-            };
-            const res = findOriginalRange(lRange, state, originalStateMap);
-            if (res.error) {
+            const locResult = findOriginalRange(newLoc.start, newLoc.end, state, originalStateMap);
+            if (locResult.error) {
                 // It should not happen unless it is minify files, the SourceMap has some order problems
-
+                logMappingErrors('branch', locResult);
                 hasError = true;
-
-                // console.log('====================================', state.sourcePath, loc);
-                // console.log(res.errors);
-                // Util.logError(`Not found original branch. start: ${start}, end: ${end}`);
-
                 return newLoc;
             }
 
             // mapping to new range
-            const oRage = res.originalRange;
-            newLoc.start = oRage.startOffset;
-            newLoc.end = oRage.endOffset;
+            newLoc.start = locResult.start;
+            newLoc.end = locResult.end;
+            newLoc.generatedStart = newLoc.start;
+            newLoc.generatedEnd = newLoc.end;
 
             return newLoc;
         });
@@ -565,7 +594,7 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
         }
 
         // add back to original ast
-        originalState.astInfo.branches.push({
+        result.originalState.astInfo.branches.push({
             type,
             start: groupStart,
             end: groupEnd,
@@ -576,6 +605,50 @@ const handleOriginalBranchesCoverage = (state, originalStateMap) => {
 
 };
 
+const handleOriginalStatementsCoverage = (state, originalStateMap) => {
+
+    // statements only for js
+    if (!state.js) {
+        return;
+    }
+
+    // statement count
+    state.astInfo.statements.forEach((it) => {
+        const { start, end } = it;
+
+        const result = findOriginalRange(start, end, state, originalStateMap);
+        if (result.error) {
+            logMappingErrors('statement', result);
+            return;
+        }
+
+        // add back to original ast
+        result.originalState.astInfo.statements.push({
+            ... it,
+            generatedStart: start,
+            generatedEnd: end,
+            start: result.start,
+            end: result.end
+        });
+
+    });
+
+    originalStateMap.forEach((originalState) => {
+        const statements = originalState.astInfo.statements;
+        if (Util.isList(statements)) {
+            return;
+        }
+        // fake source nothing matched
+        statements.push({
+            start: 0,
+            end: originalState.source.length,
+            count: 1
+        });
+
+    });
+
+};
+
 const handleOriginalBytesCoverage = (state, originalStateMap) => {
 
     const { js, coverageList } = state;
@@ -592,18 +665,23 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
                     return;
                 }
 
-                const result = findOriginalRange(range, state, originalStateMap);
+                const {
+                    startOffset, endOffset, count
+                } = range;
+
+                const result = findOriginalRange(startOffset, endOffset, state, originalStateMap);
                 if (result.error) {
+                    logMappingErrors('byte', result);
                     return;
                 }
 
-                const { originalRange, originalState } = result;
-                addJsBytesCoverage(originalState, originalRange);
-
-                // if (originalRange.startOffset === 110 && originalRange.endOffset === 271) {
-                //     console.log('===============================', originalState.sourcePath);
-                //     console.log(result.startMapping, result.endMapping);
-                // }
+                addJsBytesCoverage(result.originalState, {
+                    generatedStart: startOffset,
+                    generatedEnd: endOffset,
+                    startOffset: result.start,
+                    endOffset: result.end,
+                    count
+                });
 
             });
         });
@@ -633,7 +711,15 @@ const handleOriginalBytesCoverage = (state, originalStateMap) => {
         const endMapping = decodedMappings[len - 1];
         // console.log(startMapping, endMapping);
         const startOffset = startMapping.generatedOffset;
-        const endOffset = endMapping.generatedEndOffset || endMapping.generatedOffset;
+
+        if (!endMapping.generatedEndOffset) {
+            // line last one
+            const line = state.locator.getLine(endMapping.generatedLine + 1);
+            // last column
+            const toEndLength = line.length - endMapping.generatedColumn;
+            endMapping.generatedEndOffset = endMapping.generatedOffset + toEndLength;
+        }
+        const endOffset = endMapping.generatedEndOffset;
 
         // console.log('===========================================================', originalState.sourcePath);
         // console.log(originalState.source.length, endMapping);
@@ -674,11 +760,22 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
     });
 
     const allDecodedMappings = [];
-    let generatedIndex = 0;
     decodedList.forEach((segments, generatedLine) => {
         let info = null;
         segments.forEach((segment) => {
+
+            // const COLUMN = 0;
+            // const SOURCES_INDEX = 1;
+            // const SOURCE_LINE = 2;
+            // const SOURCE_COLUMN = 3;
+            // const NAMES_INDEX = 4;
             const [generatedColumn, sourceIndex, originalLine, originalColumn] = segment;
+            // the segment length could be 1, 4 or 5
+
+            if (typeof sourceIndex === 'undefined') {
+                return;
+            }
+
             const generatedOffset = generatedLocator.locationToOffset({
                 // 1-base
                 line: generatedLine + 1,
@@ -689,7 +786,6 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
                 generatedOffset,
                 generatedLine,
                 generatedColumn,
-                generatedIndex,
 
                 sourceIndex,
                 originalLine,
@@ -697,23 +793,11 @@ const decodeSourceMappings = (state, originalDecodedMap) => {
             };
 
             allDecodedMappings.push(info);
-            generatedIndex += 1;
-
-            if (typeof sourceIndex === 'undefined') {
-                return;
-            }
 
             originalDecodedMap.get(sourceIndex).push(info);
 
         });
 
-        // line last one
-        if (info) {
-            const line = generatedLocator.getLine(info.generatedLine + 1);
-            // last column
-            info.generatedEndOffset = info.generatedOffset + (line.length - info.generatedColumn);
-        }
-
     });
 
     // defaults to sort by generated offset, not need sort
@@ -802,9 +886,11 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             bytes: [],
             functions: [],
             branches: [],
+            statements: [],
             astInfo: {
                 functions: [],
-                branches: []
+                branches: [],
+                statements: []
             },
             // coverage data
             v8Data: {}
@@ -857,6 +943,7 @@ const generateCoverageForDist = (state) => {
 
     handleFunctionsCoverage(state);
     handleBranchesCoverage(state);
+    handleStatementsCoverage(state);
     handleBytesCoverage(state);
 
 };
@@ -888,12 +975,14 @@ const unpackSourceMap = (state, options) => {
     // handle functions before handle original state functions
     handleOriginalFunctionsCoverage(state, originalStateMap);
     handleOriginalBranchesCoverage(state, originalStateMap);
+    handleOriginalStatementsCoverage(state, originalStateMap);
 
     // handle lines info before handle ranges to update line count
     originalStateMap.forEach((originalState) => {
 
         handleFunctionsCoverage(originalState);
         handleBranchesCoverage(originalState);
+        handleStatementsCoverage(originalState);
 
         // if (originalState.sourcePath.endsWith('demo.js')) {
         //     console.log('=================================', originalState.sourcePath);
@@ -901,7 +990,7 @@ const unpackSourceMap = (state, options) => {
 
     });
 
-    // handle ranges after lines ready
+    // handle bytes ranges
     handleOriginalBytesCoverage(state, originalStateMap);
 
     // collect coverage for original list
@@ -912,7 +1001,7 @@ const unpackSourceMap = (state, options) => {
 const unpackDistFile = (item, state, options) => {
 
     if (state.sourceMap) {
-        if (Util.loggingType === 'debug') {
+        if (Util.isDebug()) {
             // js self
             item.debug = true;
             generateCoverageForDist(state);
@@ -1217,7 +1306,7 @@ const convertV8List = (v8list, options) => {
         if (js) {
             coverageList = filterCoverageList(item);
             // remove original functions
-            if (Util.loggingType !== 'debug') {
+            if (!Util.isDebug()) {
                 delete item.functions;
             }
             astInfo = getJsAstInfo(item, coverageList);
@@ -1225,11 +1314,12 @@ const convertV8List = (v8list, options) => {
             // convent css covered ranges to rules ranges and include uncovered ranges
             astInfo = getCssAstInfo(item, coverageList);
             // remove original ranges
-            if (Util.loggingType !== 'debug') {
+            if (!Util.isDebug()) {
                 delete item.ranges;
             }
         }
 
+        // console.log(sourcePath, astInfo.statements.length);
         // ============================
 
         // current file and it's sources from sourceMap
@@ -1246,6 +1336,7 @@ const convertV8List = (v8list, options) => {
             bytes: [],
             functions: [],
             branches: [],
+            statements: [],
             astInfo,
             // for sub source files
             coverageList,