monocart-coverage-reports 2.0.1 → 2.0.3

package/lib/converter/ast.js

@@ -154,14 +154,6 @@ const generateCountState = (coverageList) => {
 
 const getJsAstInfo = (item, coverageList) => {
 
-    // not for css
-    if (!item.js) {
-        return {
-            functions: [],
-            branches: []
-        };
-    }
-
     const { source } = item;
 
     const options = {
@@ -193,76 +185,118 @@ const getJsAstInfo = (item, coverageList) => {
 
 // =========================================================================================================
 
-const addCssRules = (rules, coverageList, coveredRanges, locator) => {
-    let hasCovered = false;
-    // line and line is 1-base
-    rules.forEach((rule) => {
+const addRule = (item, coverageList, coveredRanges, count = 0) => {
 
-        const { type, position } = rule;
+    const { source } = item;
+    const { start, end } = source;
+    const startOffset = start.offset;
+    const endOffset = end.offset;
 
-        if (type === 'comment') {
-            return;
+    if (!count) {
+        const coveredRange = findInRanges(startOffset, endOffset, coveredRanges);
+        if (coveredRange) {
+            count = 1;
         }
+    }
 
-        const { start, end } = position;
-
-        // both 1-base
-        // console.log(start, end);
-        const startOffset = locator.locationToOffset({
-            line: start.line,
-            column: start.column - 1
-        });
-
-        const endOffset = locator.locationToOffset({
-            line: end.line,
-            column: end.column - 1
-        });
-
-        // start should offset @media
-        if (type === 'media') {
-            // rules in media
-            // console.log('media', rule.media, startOffset, endOffset);
-            const childCoverageList = [];
-            const hasChildCovered = addCssRules(rule.rules, childCoverageList, coveredRanges, locator);
-            if (hasChildCovered) {
-                childCoverageList.forEach((it) => {
-                    coverageList.push(it);
-                });
-                return;
-            }
+    coverageList.push({
+        start: startOffset,
+        end: endOffset,
+        count
+    });
+
+    return count;
+
+};
+
+const addAtRule = (item, coverageList, coveredRanges) => {
+    const { name, nodes } = item;
+
+    if (['charset', 'import', 'namespace'].includes(name)) {
+        addRule(item, coverageList, coveredRanges, 1);
+        return;
+    }
+
+    if (['media', 'supports', 'container', 'layer'].includes(name)) {
+
+        const childCoverageList = [];
+        const count = addCssRules(nodes, childCoverageList, coveredRanges);
+        if (count) {
 
-            // add whole media as uncovered
             coverageList.push({
-                start: startOffset,
-                end: endOffset,
-                count: 0
+                start: item.source.start.offset,
+                end: childCoverageList[0].start,
+                count: 1
+            });
+
+            let end;
+            childCoverageList.forEach((it) => {
+                coverageList.push(it);
+                end = it.end;
             });
+
+            coverageList.push({
+                start: end,
+                end: item.source.end.offset,
+                count: 1
+            });
+
             return;
         }
 
-        let count = 0;
-        if (type === 'charset') {
-            count = 1;
-        } else {
-            const coveredRange = findInRanges(startOffset, endOffset, coveredRanges);
-            if (coveredRange) {
-                count = 1;
-                hasCovered = true;
-            }
+    }
+
+    addRule(item, coverageList, coveredRanges);
+
+};
+
+const addCssRules = (list, coverageList, coveredRanges) => {
+
+    let count = 0;
+
+    // line and line is 1-base
+    list.forEach((item) => {
+
+        const { type } = item;
+
+        if (type === 'comment') {
+            return;
+        }
+
+        if (type === 'rule') {
+            count += addRule(item, coverageList, coveredRanges);
+            return;
         }
 
-        coverageList.push({
-            start: startOffset,
-            end: endOffset,
-            count
-        });
+        // console.log('=============================================================================');
+        // Object.keys(item).forEach((k) => {
+        //     if (k === 'parent') {
+        //         return;
+        //     }
+        //     if (k === 'raws') {
+        //         return;
+        //     }
+        //     if (k === 'nodes') {
+        //         console.log(k, item[k].length);
+        //         return;
+        //     }
+        //     if (k === 'source') {
+        //         console.log(k, item[k].start, item[k].end);
+        //         return;
+        //     }
+        //     console.log(k, item[k]);
+        // });
+
+        if (type === 'atrule') {
+            addAtRule(item, coverageList, coveredRanges);
+        }
 
     });
 
-    return hasCovered;
+    return count;
 };
 
-const getCssAstInfo = (item, locator) => {
+const getCssAstInfo = (item, coverageList) => {
 
     const {
         source, sourcePath, ranges
@@ -270,6 +304,7 @@ const getCssAstInfo = (item, locator) => {
 
     // sort covered ranges
     ranges.sort((a, b) => a.start - b.start);
+
     // to offset covered ranges
     const coveredRanges = ranges.map((it) => {
         return {
@@ -282,11 +317,13 @@ const getCssAstInfo = (item, locator) => {
     const ast = parseCss(source);
     Util.logTime(`parse css: ${sourcePath}`, time_start_parse);
 
-    const coverageList = [];
-    addCssRules(ast.rules, coverageList, coveredRanges, locator);
+    // if (sourcePath.endsWith('style.css')) {
+    addCssRules(ast.nodes, coverageList, coveredRanges);
+    // }
 
     return {
-        coverageList
+        functions: [],
+        branches: []
     };
 };
 

package/lib/converter/branches.js

@@ -108,33 +108,58 @@ const addBranch = (group, node, locationMap, functionInfo) => {
     return branchInfo;
 };
 
+const addNoneBranch = (group) => {
+    group.locations.push({
+        none: true,
+        count: 0
+    });
+};
+
 // =======================================================================================
 
+const hasFunctionBlock = (functionInfo) => {
+    const { range } = functionInfo;
+    if (range) {
+        const { blockMap } = range;
+        if (blockMap) {
+            return true;
+        }
+    }
+    return false;
+};
+
 const addNodeCount = (node, parents, functionInfo) => {
 
     const { start, end } = node;
-    const { count, range } = functionInfo;
 
-    if (range) {
+    if (hasFunctionBlock(functionInfo)) {
+        const { range } = functionInfo;
         const { blockMap, blockRanges } = range;
-        if (blockMap) {
-            const block = blockMap.get(start);
-            if (block) {
-                node._state = {
-                    count: block.count
-                };
-                return;
-            }
-
-            const blockItem = findInRanges(start, end, blockRanges);
-            if (blockItem) {
-                node._state = {
-                    count: blockItem.count
-                };
-                return;
-            }
+        const block = blockMap.get(start);
+        if (block) {
+            node._state = {
+                count: block.count
+            };
+            return;
+        }
 
+        const blockItem = findInRanges(start, end, blockRanges);
+        if (blockItem) {
+            node._state = {
+                count: blockItem.count
+            };
+            return;
         }
+
+        // continue find in reverseParents
+
+    } else {
+
+        // default to 1 if no function block
+        node._state = {
+            count: 1
+        };
+        return;
     }
 
     const reverseParents = [].concat(parents).reverse();
@@ -149,7 +174,7 @@ const addNodeCount = (node, parents, functionInfo) => {
 
     // function count
     node._state = {
-        count: count
+        count: functionInfo.count
     };
 
 };
@@ -198,10 +223,7 @@ const createBranches = (ast, functionInfo, branchMap) => {
                 addBranch(group, alternate, locationMap, functionInfo);
             } else {
                 // add none branch
-                group.locations.push({
-                    none: true,
-                    count: 0
-                });
+                addNoneBranch(group);
                 // no need update group end, there is no end
             }
         },
@@ -306,7 +328,7 @@ const LogicalExpression = (group, parentCount, noBlockList, blockCount) => {
 
     // const start = group.loc.start;
     // if (start > 7874 && start < 7922) {
-    //     console.log(group.type, parentCount, 'locations', group.locations, group.functionInfo.range);
+    //     console.log(group.type, parentCount, 'locations', group.locations);
     // }
 
 };
@@ -351,6 +373,14 @@ const updateBranchCount = (group) => {
     const parentCount = getBranchParentCount(reverseParents, functionCount);
     // console.log(functionInfo.start, 'function count', functionCount, 'parent count', parentCount);
 
+    if (!hasFunctionBlock(functionInfo)) {
+        // default to parent if no function range
+        locations.forEach((item) => {
+            item.count = parentCount;
+        });
+        return;
+    }
+
     // calculate branches count
     // > 1
 
@@ -360,9 +390,9 @@ const updateBranchCount = (group) => {
         if (item.block) {
             item.count = item.block.count;
             blockCount += item.count;
-        } else {
-            noBlockList.push(item);
+            return;
         }
+        noBlockList.push(item);
     });
 
     const handlers = {

package/lib/converter/converter.js

@@ -978,7 +978,7 @@ const convertV8List = async (v8list, options) => {
 
         // ============================
         // move functions and ranges to coverageList
-        let coverageList;
+        let coverageList = [];
         let astInfo;
         if (js) {
             coverageList = item.functions;
@@ -988,11 +988,8 @@ const convertV8List = async (v8list, options) => {
             }
             astInfo = getJsAstInfo(item, coverageList);
         } else {
-            astInfo = getCssAstInfo(item, locator);
             // convent css covered ranges to rules ranges and include uncovered ranges
-            coverageList = astInfo.coverageList;
-            // console.log(coverageList);
-
+            astInfo = getCssAstInfo(item, coverageList);
             // remove original ranges
             if (Util.loggingType !== 'debug') {
                 delete item.ranges;