monocart-coverage-reports 2.7.3 → 2.7.4

package/README.md

@@ -42,6 +42,7 @@
     - [CodeceptJS](#codeceptjs)
     - [WebdriverIO](#webdriverio)
     - [Storybook Test Runner](#storybook-test-runner)
+    - [TestCafe](#testcafe)
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
@@ -829,6 +830,9 @@ const coverageOptions = {
 ### [Storybook Test Runner](https://github.com/storybookjs/test-runner)
 - [storybook-monocart-coverage](https://github.com/cenfun/storybook-monocart-coverage) - Storybook V8 Coverage Example
 
+### [TestCafe](https://github.com/DevExpress/testcafe)
+- [testcafe-reporter-coverage](https://github.com/cenfun/testcafe-reporter-coverage) - A TestCafe custom reporter for coverage reports
+
 ### [Codecov](https://codecov.com/)
 [![codecov](https://codecov.io/gh/cenfun/monocart-coverage-reports/graph/badge.svg?token=H0LW7UKYU3)](https://codecov.io/gh/cenfun/monocart-coverage-reports)
 - Supports native `codecov` built-in report ([specification](https://docs.codecov.com/docs/codecov-custom-coverage-format))

package/lib/converter/converter.js

@@ -1405,7 +1405,7 @@ const convertV8List = (v8list, options) => {
         // console.log([item.id]);
 
         const {
-            type, source, sourcePath
+            type, source, fake, sourcePath
         } = item;
 
         // for source file, type could be ts or vue as extname, but js = true
@@ -1454,6 +1454,7 @@ const convertV8List = (v8list, options) => {
             js,
             type,
             source,
+            fake,
             sourcePath,
             sourceMap,
             locator,

package/lib/converter/find-original-range.js

@@ -1,3 +1,4 @@
+const { diff } = require('../packages/monocart-coverage-vendor');
 const Util = require('../utils/util.js');
 const EC = Util.EC;
 
@@ -38,6 +39,133 @@ const findMapping = (list, offset) => {
 
 // ========================================================================================================
 
+const alignText = (gt, ot) => {
+
+    const toList = (s) => {
+        return s.split('').map((v, i) => {
+            return {
+                index: i,
+                value: v
+            };
+        });
+    };
+
+    const mergeList = (gList, oList) => {
+        const oLen = oList.length;
+        if (!oLen) {
+            return;
+        }
+        const gLen = gList.length;
+        if (gLen === oLen) {
+            gList.forEach((item, i) => {
+                item.original = oList[i];
+            });
+        }
+    };
+
+    const gl = toList(gt);
+    const ol = toList(ot);
+
+    // console.log(gl);
+    // console.log(ol);
+
+    const commonItems = [];
+    diff(gl.length, ol.length, (gi, oi) => {
+        return gl[gi].value === ol[oi].value;
+    }, (len, gi, oi) => {
+        commonItems.push([gi, oi, len]);
+    });
+
+    // console.log(commonItems);
+    // console.log('================================================================');
+    // merge list
+    // previous index
+    let gpi = 0;
+    let opi = 0;
+    commonItems.forEach(([gi, oi, len]) => {
+
+        if (gpi !== gi) {
+            const gList = gl.slice(gpi, gi);
+            const oList = ol.slice(opi, oi);
+            mergeList(gList, oList);
+        }
+
+        for (let i = 0; i < len; i++) {
+
+            const gii = gi + i;
+            const oii = oi + i;
+            const gItem = gl[gii];
+            gItem.original = ol[oii];
+
+            // matching a word end
+            if (i === len - 1 && len > 1) {
+                gItem.wordEnd = true;
+            }
+
+        }
+        gpi = gi + len;
+        opi = oi + len;
+    });
+
+    // console.log(JSON.stringify(data.gt));
+    // console.log(JSON.stringify(data.ot));
+    if (gpi < gl.length && opi < ol.length) {
+        const gList = gl.slice(gpi);
+        const oList = ol.slice(opi);
+        mergeList(gList, oList);
+    }
+
+    // console.log(gl);
+    return gl;
+};
+
+const getAlignPosition = (gt, gp, ot, direction) => {
+
+    // generatedText: '"false";\n',
+    // originalText: "'false';\r\n    ",
+    // generatedPos: 7
+
+    // left matched
+
+    // originalText: '1;',
+    // generatedText: '1;else',
+    // generatedLeft: '1;'
+
+    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
+    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
+
+    // right matched
+    // only for original first line text
+
+    // exclusive
+    const list = alignText(gt, ot);
+    const item = list[gp];
+    if (item && item.original) {
+        return {
+            pos: item.original.index
+        };
+    }
+
+    // inclusive, for end only
+    if (gp && direction === 'end') {
+        const prev = list[gp - 1];
+        if (prev && prev.original && prev.wordEnd) {
+            // console.log(direction, '=====================================================================');
+            const op = prev.original.index + 1;
+            // console.log(gp, JSON.stringify(gt));
+            // console.log(op, JSON.stringify(ot));
+
+            return {
+                pos: op
+            };
+
+        }
+    }
+
+};
+
+// ========================================================================================================
+
 const getBlockStartPosition = (originalLineText) => {
     // originalText: 'argument) {',
     // generatedLeft: 'o',
@@ -117,32 +245,42 @@ const getBlockEndPosition = (originalLineText) => {
 
 };
 
+// ========================================================================================================
+
 const getComparedPosition = (info, direction) => {
 
-    let gt = info.generatedText;
+    const gt = info.generatedText;
     const gp = info.generatedPos;
-    let ot = info.originalText;
+    const ot = info.originalText;
 
-    // before trim
-    const oLen = ot.length;
+    // whole generated text
+    if (gp >= gt.length) {
+        // console.log(JSON.stringify(gt), gt.length, gp);
+        // console.log(JSON.stringify(ot));
+        return {
+            pos: info.originalLineText.length
+        };
+    }
 
-    gt = gt.trimEnd();
-    ot = ot.trimEnd();
+    // =============================
+    // trim right
+    const gtt = gt.trimEnd();
+    const ott = ot.trimEnd();
 
     // no original content after trim
-    if (!ot) {
+    if (!ott) {
         return {
-            pos: direction === 'start' ? oLen : 0
+            pos: direction === 'start' ? ot.length : 0
         };
     }
 
     // no generated content after trim
-    if (!gt) {
+    if (!gtt) {
         return;
     }
 
     // same content
-    if (gt === ot) {
+    if (gtt === ott) {
         return {
             pos: gp
         };
@@ -150,54 +288,13 @@ const getComparedPosition = (info, direction) => {
 
     // =============================
 
-    // generatedText: '"false";\n',
-    // originalText: "'false';\r\n    ",
-    // generatedPos: 7
-
-    // length not change, replace " to '
-    gt = gt.replace(/"/g, "'");
-    ot = ot.replace(/"/g, "'");
-
-
-    // same content too
-    if (gt === ot) {
-        return {
-            pos: gp
-        };
-    }
-
-    // ============================
-    // left matched
-
-    // originalText: '1;',
-    // generatedText: '1;else',
-    // generatedLeft: '1;'
-
-    // generatedText: '    var id = options.base ? item[0] + options.base : item[0];\r\n',
-    // originalText: '    var id = options.base ? item[0] + options.base : item[0];\n',
-
-    const left = gt.slice(0, gp);
-    if (ot.startsWith(left)) {
-        return {
-            pos: gp
-        };
-    }
+    return getAlignPosition(gt, gp, ot, direction);
 
-    // ============================
-    // right matched
-    // only for original first line text
+};
 
-    const olt = info.originalLineText;
-    const right = gt.slice(gp);
-    if (olt.endsWith(right)) {
-        return {
-            pos: olt.length - right.length
-        };
-    }
 
-};
+const getSimilarPosition = (info, direction) => {
 
-const initOriginalLineText = (info) => {
     const originalText = info.originalText;
     // never cross line, using first line of original text
     // trim end remove \r\n and \n
@@ -205,44 +302,27 @@ const initOriginalLineText = (info) => {
     if (originalLines.length === 1) {
         // already single line
         info.originalLineText = originalText.trimEnd();
-        info.originalSingle = true;
-        return;
+    } else {
+        // multiple liens
+        info.originalLineText = originalLines[0].trimEnd();
     }
-    // multiple liens
-    info.originalLineText = originalLines[0].trimEnd();
-};
 
-const getSimilarPosition = (info, direction) => {
-
-    initOriginalLineText(info);
+    // no need comparison for fake source
+    if (info.fake) {
+        return;
+    }
 
     const textPos = getComparedPosition(info, direction);
     if (textPos) {
         return textPos;
     }
 
-    if (info.originalSingle) {
-        return;
-    }
-
-    // multiple lines
-    const { generatedPos, originalLineText } = info;
-    // generatedPos not in first line
-    if (generatedPos > originalLineText.length) {
-        return;
-    }
-
-    const linePos = getComparedPosition(info, direction);
-    if (linePos) {
-        return linePos;
-    }
-
     // console.log('====================================================================');
-    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`);
+    // console.log(`${EC.magenta(direction)} similar position can NOT be fixed`, info.originalState.sourcePath);
     // console.log({
-    //     sourcePath: info.originalState.sourcePath,
-    //     generatedText,
-    //     generatedPos,
+    //     direction,
+    //     generatedText: info.generatedText,
+    //     generatedPos: info.generatedPos,
     //     originalText
     // });
 
@@ -402,11 +482,13 @@ const getFixedOriginalStart = (start, mappings, state, cache) => {
         };
     }
 
-    const direction = 'start';
+
     const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, start);
+    const direction = 'start';
 
     const info = {
+        fake: state.fake,
         generatedText,
         generatedPos,
         originalText,
@@ -453,11 +535,13 @@ const getFixedOriginalEnd = (end, mappings, state, cache) => {
         };
     }
 
-    const direction = 'end';
+
     const { originalText, originalOffset } = getOriginalText(m1, m2, cache);
     const { generatedText, generatedPos } = getGeneratedText(m1, m2, state, end);
+    const direction = 'end';
 
     const info = {
+        fake: state.fake,
         offset: end,
         generatedText,
         generatedPos,