monocart-coverage-reports 2.0.8 → 2.0.9

package/lib/converter/converter.js

@@ -5,9 +5,17 @@
  *   @false means that there is a single range and its count is the number of times the function was called.
  *   @true means that the ranges form a tree of blocks representing how many times each statement or expression inside was executed.
  *        It detects skipped or repeated statements. The root range counts the number of function calls.
- *
  * @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
  */
+// https://github.com/bcoe/v8-coverage
+/**
+* @ranges is always non-empty. The first range is called the "root range".
+* @isBlockCoverage indicates if the function has block coverage information.
+    If this is false, it usually means that the functions was never called.
+    It seems to be equivalent to ranges.length === 1 && ranges[0].count === 0.
+* @functionName can be an empty string. This is common for the FunctionCov representing the whole module.
+*/
+
 // if you have a line of code that says `var x= 10; console.log(x);` that's one line and 2 statements.
 
 const path = require('path');
@@ -101,7 +109,6 @@ const updateLinesCount = (bytes, locator, lineMap) => {
 
     // if (state.sourcePath.endsWith('component.js')) {
     //     console.log('===========================================', state.sourcePath);
-    //     console.log(coverageInfo.lines);
     // }
 
 };
@@ -209,21 +216,6 @@ const calculateV8Lines = (lines, blankCount, commentCount) => {
 };
 
 // ========================================================================================================
-
-const createEmptyCoverageInfo = () => {
-    return {
-        // v8 UI
-        data: {
-            bytes: [],
-            functions: [],
-            branches: []
-        },
-        // istanbul
-        functions: [],
-        branches: []
-    };
-};
-
 // istanbul coverage format
 /**
  * * `path` - the file path for which coverage is being tracked
@@ -237,34 +229,69 @@ const createEmptyCoverageInfo = () => {
 const collectFileCoverage = (item, state, coverageData, options) => {
 
     const { sourcePath } = item;
-    const { coverageInfo, locator } = state;
-
     const {
-        data,
+        bytes,
         functions,
-        branches
-    } = coverageInfo;
+        branches,
+        locator
+    } = state;
 
     // ==========================================
-    // v8
-    data.bytes = dedupeCountRanges(data.bytes);
+    // v8 data
+    const data = {
+        bytes: dedupeCountRanges(bytes),
+        functions: [],
+        branches: []
+    };
 
+    // ==========================================
+    // ignore
     const ignoredRanges = getIgnoredRanges(locator, options);
     if (ignoredRanges) {
 
+        // data bytes is start/end/count object
         handleIgnoredRanges(data.bytes, ignoredRanges);
-        handleIgnoredRanges(data.functions, ignoredRanges);
-        handleIgnoredRanges(data.branches, ignoredRanges);
+
+        // functions is InfoFunction start/end/count instance
+        handleIgnoredRanges(functions, ignoredRanges);
+
+        // branches is InfoBranch start/end/count instance
+        handleIgnoredRanges(branches, ignoredRanges);
+
+        // branch locations start/end/count object
+        branches.forEach((group) => {
+            if (group.ignored) {
+                // all branch group ignored
+                group.locations.forEach((it) => {
+                    it.ignored = true;
+                });
+            } else {
+                handleIgnoredRanges(group.locations, ignoredRanges);
+            }
+        });
 
         // console.log(ignoredRanges);
 
     }
 
+    data.functions = functions.map((info) => {
+        return info.getRange();
+    });
+
+    // branch group with locations to flat branches
+    data.branches = branches.map((info) => {
+        return info.getRanges();
+    }).flat();
+
+    // ==========================================
+    // lines
     // after bytes with ignored, before calculateV8Lines
     const {
         lines, blankCount, commentCount
     } = handleLinesCoverage(data.bytes, locator);
 
+    // ==========================================
+    // v8 data and summary
     item.data = data;
     item.summary = {
         functions: calculateV8Functions(data.functions),
@@ -286,19 +313,20 @@ const collectFileCoverage = (item, state, coverageData, options) => {
         b: {}
     };
 
-    lines.forEach((line, index) => {
+    lines.filter((it) => !it.ignored).forEach((line, index) => {
         istanbulCoverage.statementMap[`${index}`] = line.generate();
         istanbulCoverage.s[`${index}`] = line.count;
     });
 
-    functions.forEach((fn, index) => {
-        istanbulCoverage.fnMap[`${index}`] = fn.generate();
+    functions.filter((it) => !it.ignored).forEach((fn, index) => {
+        istanbulCoverage.fnMap[`${index}`] = fn.generate(locator);
         istanbulCoverage.f[`${index}`] = fn.count;
     });
 
-    branches.forEach((branch, index) => {
-        istanbulCoverage.branchMap[`${index}`] = branch.generate();
-        istanbulCoverage.b[`${index}`] = branch.generateCounts();
+    branches.filter((it) => !it.ignored).forEach((branch, index) => {
+        const { map, counts } = branch.generate(locator);
+        istanbulCoverage.branchMap[`${index}`] = map;
+        istanbulCoverage.b[`${index}`] = counts;
     });
 
     // append to dist file state
@@ -309,13 +337,11 @@ const collectFileCoverage = (item, state, coverageData, options) => {
 // ========================================================================================================
 
 const addJsBytesCoverage = (state, range) => {
-    const { coverageInfo } = state;
-    const { data } = coverageInfo;
     const {
         startOffset, endOffset, count
     } = range;
     // add bytes range
-    data.bytes.push({
+    state.bytes.push({
         start: startOffset,
         end: endOffset,
         count
@@ -323,75 +349,35 @@ const addJsBytesCoverage = (state, range) => {
 };
 
 const addCssBytesCoverage = (state, range) => {
-    const { coverageInfo } = state;
-    const { data } = coverageInfo;
     const {
         start, end, count
     } = range;
     // add css bytes range, already start, end
-    data.bytes.push({
+    state.bytes.push({
         start,
         end,
         count
     });
 };
 
-const updateOffsetToLocation = (locator, loc) => {
-    const sLoc = locator.offsetToLocation(loc.start);
-    loc.start = {
-        line: sLoc.line,
-        column: sLoc.column
-    };
-    const eLoc = locator.offsetToLocation(loc.end);
-    loc.end = {
-        line: eLoc.line,
-        column: eLoc.column
-    };
-};
-
 // ========================================================================================================
 
 const handleFunctionsCoverage = (state) => {
 
     // functions only for js
     if (!state.js) {
-        // use css rules data for functions
         return;
     }
 
-    const {
-        locator, coverageInfo, astInfo
-    } = state;
-
-    const v8Functions = coverageInfo.data.functions;
-    const istanbulFunctions = coverageInfo.functions;
-
+    const { functions, astInfo } = state;
     astInfo.functions.forEach((it) => {
         const {
             start, end, functionName, count
         } = it;
-
-        v8Functions.push({
-            start,
-            end,
-            count
-        });
-
-        const loc = {
-            start,
-            end
-        };
-        updateOffsetToLocation(locator, loc);
-        const functionInfo = new InfoFunction(loc, count, functionName);
-        istanbulFunctions.push(functionInfo);
+        const functionInfo = new InfoFunction(start, end, count, functionName);
+        functions.push(functionInfo);
     });
 
-    // if (state.sourcePath.endsWith('store.js')) {
-    //     console.log('==========================================================');
-    //     console.log(astInfo.functions);
-    //     console.log(functions);
-    // }
-
 };
 
 const handleBranchesCoverage = (state) => {
@@ -401,52 +387,13 @@ const handleBranchesCoverage = (state) => {
         return;
     }
 
-    const {
-        locator, coverageInfo, astInfo
-    } = state;
-
-    const v8Branches = coverageInfo.data.branches;
-    const isTanbulBranches = coverageInfo.branches;
+    const { branches, astInfo } = state;
     astInfo.branches.forEach((it) => {
-
-        const branchType = it.type;
-        const branchLoc = {
-            ... it.loc
-        };
-        updateOffsetToLocation(locator, branchLoc);
-
-        // locations
-        // [ { start:{line,column}, end:{line,column}, count }, ...]
-        const locations = it.locations.map((oLoc) => {
-            const newLoc = {
-                ... oLoc
-            };
-            if (newLoc.none) {
-
-                // the branch count is not very accurate
-                v8Branches.push({
-                    start: it.loc.start,
-                    end: it.loc.end,
-                    count: oLoc.count,
-                    none: true
-                });
-
-                return newLoc;
-            }
-
-            // the branch count is not very accurate
-            v8Branches.push({
-                start: oLoc.start,
-                end: oLoc.end,
-                count: oLoc.count
-            });
-
-            updateOffsetToLocation(locator, newLoc);
-            return newLoc;
-        });
-
-        const branchInfo = new InfoBranch(branchLoc, locations, branchType);
-        isTanbulBranches.push(branchInfo);
+        const {
+            start, end, locations, type
+        } = it;
+        const branchInfo = new InfoBranch(start, end, locations, type);
+        branches.push(branchInfo);
     });
 
 };
@@ -533,14 +480,12 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
     // function count
     state.astInfo.branches.forEach((it) => {
 
-        const {
-            type, loc, locations
-        } = it;
+        const { type, locations } = it;
 
         // rename to startOffset and endOffset
         const bRange = {
-            startOffset: loc.start,
-            endOffset: loc.end
+            startOffset: it.start,
+            endOffset: it.end
         };
 
         // start
@@ -551,10 +496,8 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
         }
         const { originalRange, originalState } = result;
 
-        const newBranchLoc = {
-            start: originalRange.startOffset,
-            end: originalRange.endOffset
-        };
+        const groupStart = originalRange.startOffset;
+        const groupEnd = originalRange.endOffset;
 
         let hasError;
         const newLocations = locations.map((oLoc) => {
@@ -564,6 +507,8 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
             };
 
             if (newLoc.none) {
+                newLoc.start = groupStart;
+                newLoc.end = groupEnd;
                 return newLoc;
             }
 
@@ -586,6 +531,7 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
                 return newLoc;
             }
 
+            // mapping to new range
             const oRage = res.originalRange;
             newLoc.start = oRage.startOffset;
             newLoc.end = oRage.endOffset;
@@ -593,6 +539,7 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
             return newLoc;
         });
 
+        // ignored group when found error
         if (hasError) {
             return;
         }
@@ -600,7 +547,8 @@ const handleOriginalBranchesCoverage = (state, originalMap) => {
         // add back to original ast
         originalState.astInfo.branches.push({
             type,
-            loc: newBranchLoc,
+            start: groupStart,
+            end: groupEnd,
             locations: newLocations
         });
 
@@ -794,7 +742,10 @@ const initOriginalList = (state, originalDecodedMap, options) => {
             source: sourceContent,
             locator,
             decodedMappings,
-            coverageInfo: createEmptyCoverageInfo(),
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
             astInfo: {
                 functions: [],
                 branches: []
@@ -814,6 +765,7 @@ const collectOriginalList = (item, state, originalMap, options) => {
 
     // collect original files
     const sourceList = [];
+
     originalMap.forEach((originalState) => {
 
         const {
@@ -822,7 +774,8 @@ const collectOriginalList = (item, state, originalMap, options) => {
 
         // add file item
         const url = fileUrls[sourcePath] || sourcePath;
-        const id = Util.calculateSha1(url + source);
+        // add dist for id
+        const id = Util.calculateSha1(distFile + url + source);
 
         const sourceItem = {
             url,
@@ -834,7 +787,7 @@ const collectOriginalList = (item, state, originalMap, options) => {
             source
         };
 
-        // generate coverage, coverageInfo for current file, state for dist file
+        // generate coverage for current file, state for dist file
         collectFileCoverage(sourceItem, originalState, state.coverageData, options);
 
         sourceList.push(sourceItem);
@@ -894,7 +847,6 @@ const unpackSourceMap = async (item, state, options) => {
 
         // if (originalState.sourcePath.endsWith('demo.js')) {
         //     console.log('=================================', originalState.sourcePath);
-        //     console.log(originalState.coverageInfo.lineMap);
         // }
 
     });
@@ -949,7 +901,7 @@ const dedupeV8List = (v8list) => {
 
 const convertV8List = async (v8list, options) => {
 
-    // global file sources and coverage data
+    // global file sources and coverage
     const fileSources = {};
     const coverageData = {};
     let sourceList = [];
@@ -978,9 +930,6 @@ const convertV8List = async (v8list, options) => {
             delete item.sourceMap;
         }
 
-        // ============================
-        const coverageInfo = createEmptyCoverageInfo();
-
         // ============================
         // move functions and ranges to coverageList
         let coverageList = [];
@@ -1011,9 +960,12 @@ const convertV8List = async (v8list, options) => {
             sourceMap,
             coverageList,
             locator,
-            coverageInfo,
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
             astInfo,
-            // for istanbul data
+            // for istanbul
             fileSources: {},
             coverageData: {}
         };

package/lib/converter/info-branch.js

@@ -1,29 +1,74 @@
+const Util = require('../utils/util.js');
 module.exports = class InfoBranch {
-    constructor(loc, locations, type) {
-        this.loc = loc;
-        this.line = loc.start.line;
-        // [ { start:{line,column}, end:{line,column}, count }, ...]
+    constructor(start, end, locations, type) {
+        this.start = start;
+        this.end = end;
         this.locations = locations;
         this.type = type || 'branch';
     }
 
-    generate() {
-        return {
-            loc: this.loc,
+    getRanges() {
+        return this.locations.map((item) => {
+            const range = {
+                start: item.start,
+                end: item.end,
+                count: item.count
+            };
+            if (item.none) {
+                range.none = true;
+            }
+            if (item.ignored) {
+                range.ignored = true;
+            }
+            return range;
+        });
+    }
+
+    generate(locator) {
+        const groupLoc = {
+            start: this.start,
+            end: this.end
+        };
+        Util.updateOffsetToLocation(locator, groupLoc);
+        const line = groupLoc.start.line;
+
+        // remove ignored
+        const locations = this.locations.filter((it) => !it.ignored);
+
+        // [ { start:{line,column}, end:{line,column}, count }, ...]
+        locations.forEach((item) => {
+            Util.updateOffsetToLocation(locator, item);
+        });
+
+        const map = {
+            loc: groupLoc,
             type: this.type,
-            locations: this.locations.map((item) => {
-                const { start, end } = item;
+            locations: locations.map((item) => {
+                const {
+                    start, end, none
+                } = item;
+                if (none) {
+                    // none with group start/end, should be empty for istanbul
+                    return {
+                        start: {},
+                        end: {}
+                    };
+                }
                 return {
-                    start: start || {},
-                    end: end || {}
+                    start,
+                    end
                 };
 
             }),
-            line: this.line
+            line: line
         };
-    }
 
-    generateCounts() {
-        return this.locations.map((item) => item.count);
+        const counts = locations.map((item) => item.count);
+
+        return {
+            map,
+            counts
+        };
     }
+
 };

package/lib/converter/info-function.js

@@ -1,17 +1,40 @@
+const Util = require('../utils/util.js');
 module.exports = class InfoFunction {
-    constructor(loc, count, name) {
-        this.loc = loc;
-        this.line = loc.start.line;
+    constructor(start, end, count, name) {
+        this.start = start;
+        this.end = end;
         this.count = count;
         this.name = name || '(anonymous)';
     }
 
-    generate() {
+    getRange() {
+        const range = {
+            start: this.start,
+            end: this.end,
+            count: this.count
+        };
+        if (this.ignored) {
+            range.ignored = true;
+        }
+        return range;
+    }
+
+    generate(locator) {
+
+        const loc = {
+            start: this.start,
+            end: this.end
+        };
+
+        Util.updateOffsetToLocation(locator, loc);
+
+        const line = loc.start.line;
+
         return {
             name: this.name,
-            decl: this.loc,
-            loc: this.loc,
-            line: this.line
+            decl: loc,
+            loc: loc,
+            line: line
         };
     }
 };