monocart-coverage-reports 2.0.0 → 2.0.2

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

@@ -26,6 +26,9 @@ const quickFindRange = (position, ranges) => {
 
 
 const findInRanges = (start, end, ranges) => {
+    if (!Util.isList(ranges)) {
+        return;
+    }
     const range = quickFindRange(start, ranges);
     if (start >= range.startOffset && end <= range.endOffset) {
         return range;

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;