monocart-coverage-reports 2.3.3 → 2.4.0

package/lib/converter/ast.js

@@ -3,178 +3,156 @@ const {
 } = require('../packages/monocart-coverage-vendor.js');
 const Util = require('../utils/util.js');
 
-const { createBranches, collectBranches } = require('./branches.js');
-const findInRanges = require('./find-in-ranges.js');
+const { collectAstInfo } = require('./ast-visitor.js');
 
-const getFunctionRange = (start, end, state) => {
-
-    const {
-        functionMap, functionNameMap, functionRanges
-    } = state;
-
-    if (!functionRanges.length) {
-        return;
-    }
-
-    // exact matched in functionMap
-    const range = functionMap.get(start);
-    if (range) {
-        return range;
-    }
-    // exact matched in functionNameMap
-    const nameRange = functionNameMap.get(start);
-    if (nameRange) {
-        return nameRange;
-    }
-
-    // find in functionRanges
-    return findInRanges(start, end, functionRanges);
-};
-
-const collectAstInfo = (ast, state) => {
-
-    const functions = [];
-    const branchMap = new Map();
-
-    // root function branches
-    const functionRoot = state.functionRoot;
-    if (functionRoot) {
-        const rootFunctionInfo = {
-            count: functionRoot.count,
-            range: functionRoot
-        };
-        createBranches(rootFunctionInfo, branchMap, ast);
-    }
-
-    // functions branches
-    Util.visitAst(ast, {
-
-        VariableDeclarator(node, parents) {
-            // id: { type: 'Identifier', name: '__webpack_modules__' },
-            const name = node.id && node.id.name;
-            if (name === '__webpack_modules__' && node.init) {
-                // mark all as wrap function
-                node.init.properties.forEach((it) => {
-                    it.value._wrapKey = it.key && it.key.value;
-                });
-                // console.log('==========================', node.type);
-                // console.log(name, parents.length);
-            }
-        },
-
-        // Function include FunctionDeclaration, ArrowFunctionExpression, FunctionExpression
-        Function(node, parents) {
-
-            const {
-                start, end, id
-            } = node;
-            const functionName = id && id.name;
-
-            const functionInfo = {
-                start,
-                end,
-                functionName,
-                // js default to 1
-                count: 1
-            };
-
-            if (node._wrapKey) {
-                functionInfo.wrap = true;
-            }
-
-            const range = getFunctionRange(start, end, state);
-            if (range) {
-                functionInfo.count = range.count;
-                functionInfo.range = range;
-                // set wrap back to range
-                if (functionInfo.wrap) {
-                    range.wrap = true;
-                }
-            }
-
-            functions.push(functionInfo);
-
-            createBranches(functionInfo, branchMap, node.body, node.params, parents);
-
-        }
-
-    });
-
-    const branches = collectBranches(branchMap);
-
-    return {
-        functions,
-        branches
-    };
-
-};
-
-const generateCountState = (coverageList) => {
-    const functionRanges = [];
+const getCoverageInfo = (coverageList) => {
+    const functionMap = new Map();
     const functionNameMap = new Map();
-    let functionRoot;
+    const functionUncoveredRanges = [];
+    let rootRange;
     coverageList.forEach((block) => {
         const {
             functionName, ranges, root
         } = block;
 
-        // first one is function coverage info
-        const functionRange = ranges[0];
+        let functionRange;
+        const blockRanges = [];
+
+        ranges.forEach((range, i) => {
+            if (i === 0) {
+                // function range
+                functionRange = range;
+                return;
+            }
+            blockRanges.push(range);
+        });
+
         functionRange.functionName = functionName;
 
         // blocks
-        const len = ranges.length;
-        if (len > 1) {
-            const blockRanges = [].concat(ranges);
-            // remove first one
-            blockRanges.shift();
-            blockRanges.sort((a, b) => {
-                return a.startOffset - b.startOffset;
-            });
+        if (blockRanges.length) {
             const blockMap = new Map();
             blockRanges.forEach((item) => {
                 blockMap.set(item.startOffset, item);
             });
             functionRange.blockMap = blockMap;
-            functionRange.blockRanges = blockRanges;
+            // uncovered is unique
+            const blockUncoveredRanges = blockRanges.filter((it) => it.count === 0);
+            blockUncoveredRanges.sort((a, b) => {
+                return a.startOffset - b.startOffset;
+            });
+            functionRange.blockUncoveredRanges = blockUncoveredRanges;
+            functionRange.blockCoveredRanges = blockRanges.filter((it) => it.count > 0);
         }
 
-        // root function
+        // root function from vm
         if (root) {
-            functionRoot = functionRange;
+            rootRange = functionRange;
             return;
         }
 
+        // root function from first range
+        if (!rootRange) {
+            rootRange = functionRange;
+        }
+
+        functionMap.set(functionRange.startOffset, functionRange);
         if (functionName) {
             functionNameMap.set(functionRange.startOffset + functionName.length, functionRange);
         }
-        functionRanges.push(functionRange);
+
+        // uncovered is unique
+        if (functionRange.count === 0) {
+            functionUncoveredRanges.push(functionRange);
+        }
 
     });
 
     // sort ranges
-    functionRanges.sort((a, b) => {
+    functionUncoveredRanges.sort((a, b) => {
         return a.startOffset - b.startOffset;
     });
 
-    // keep map index for exact search
-    const functionMap = new Map();
-    functionRanges.forEach((item) => {
-        functionMap.set(item.startOffset, item);
-    });
-
     return {
         functionMap,
         functionNameMap,
-        functionRanges,
-        functionRoot
+        functionUncoveredRanges,
+        rootRange
     };
 
 };
 
+const getFakeAstInfo = (coverageList) => {
+    const functions = [];
+    const branches = [];
+    const statements = [];
+    coverageList.forEach((block) => {
+        const {
+            isBlockCoverage, functionName, ranges, root
+        } = block;
+
+        ranges.forEach((range, i) => {
+
+            const {
+                startOffset, endOffset, count
+            } = range;
+
+            if (i === 0 && root) {
+                return;
+            }
+
+            statements.push({
+                start: startOffset,
+                end: endOffset,
+                count
+            });
+
+            if (isBlockCoverage) {
+                // branches
+                branches.push({
+                    type: 'branch',
+                    start: startOffset,
+                    end: endOffset,
+                    locations: [{
+                        start: startOffset,
+                        end: endOffset,
+                        count
+                    }]
+                });
+            }
+
+            if (i === 0) {
+                // function range
+                functions.push({
+                    start: startOffset,
+                    end: endOffset,
+                    bodyStart: startOffset,
+                    bodyEnd: endOffset,
+                    count,
+                    functionName
+                });
+
+            }
+        });
+
+    });
+
+    // console.log('fake functions', functions.map((it) => it));
+
+    return {
+        functions,
+        branches,
+        statements
+    };
+};
+
 const getJsAstInfo = (item, coverageList) => {
 
-    const { source } = item;
+    const { source, fake } = item;
+
+    if (fake) {
+        return getFakeAstInfo(coverageList);
+    }
 
     const options = {
         ecmaVersion: 'latest',
@@ -198,10 +176,10 @@ const getJsAstInfo = (item, coverageList) => {
         ast = acornLoose.parse(source, options);
     }
 
-    const state = generateCountState(coverageList);
-    // state.item = item;
+    const coverageInfo = getCoverageInfo(coverageList);
+    coverageInfo.item = item;
 
-    return collectAstInfo(ast, state);
+    return collectAstInfo(ast, coverageInfo);
 };
 
 // =========================================================================================================
@@ -214,7 +192,7 @@ const addRule = (item, coverageList, coveredRanges, count = 0) => {
     const endOffset = end.offset;
 
     if (!count) {
-        const coveredRange = findInRanges(startOffset, endOffset, coveredRanges);
+        const coveredRange = Util.findInRanges(startOffset, endOffset, coveredRanges, 'startOffset', 'endOffset');
         if (coveredRange) {
             count = 1;
         }
@@ -344,7 +322,8 @@ const getCssAstInfo = (item, coverageList) => {
 
     return {
         functions: [],
-        branches: []
+        branches: [],
+        statements: []
     };
 };
 

package/lib/converter/collect-source-maps.js

@@ -126,7 +126,7 @@ const collectSourceMaps = async (v8list, options) => {
         };
 
         // remove comments if not debug
-        if (Util.loggingType !== 'debug') {
+        if (!Util.isDebug()) {
             sourceData.source = convertSourceMap.removeComments(source);
         }