monocart-coverage-reports 2.10.4 → 2.10.6

package/README.md

@@ -967,6 +967,8 @@ process.env.MCR_LOG_TIME = true
 - Coverage for Next.js, both server side and client side:
     - [nextjs-with-playwright](https://github.com/cenfun/nextjs-with-playwright)
     - [nextjs-with-playwright-istanbul](https://github.com/cenfun/nextjs-with-playwright-istanbul)
+- Coverage for Remix:
+    - [remix-with-playwright](https://github.com/cenfun/remix-with-playwright)
 - see [Collecting V8 Coverage Data with Playwright](#collecting-v8-coverage-data-with-playwright)
 
 ### [c8](https://github.com/bcoe/c8)

package/README.zh-Hans.md

@@ -971,6 +971,8 @@ process.env.MCR_LOG_TIME = true
 - Coverage for Next.js, both server side and client side:
     - [nextjs-with-playwright](https://github.com/cenfun/nextjs-with-playwright)
     - [nextjs-with-playwright-istanbul](https://github.com/cenfun/nextjs-with-playwright-istanbul)
+- Coverage for Remix:
+    - [remix-with-playwright](https://github.com/cenfun/remix-with-playwright)
 - see [Collecting V8 Coverage Data with Playwright](#collecting-v8-coverage-data-with-playwright)
 
 ### [c8](https://github.com/bcoe/c8)

package/lib/converter/converter.js

@@ -13,6 +13,8 @@ const findOriginalRange = require('./find-original-range.js');
 const { getJsAstInfo, getCssAstInfo } = require('./ast.js');
 const { getIgnoredRanges } = require('./ignore.js');
 
+const { getUntestedList } = require('./untested.js');
+
 const {
     sortRanges, dedupeCountRanges, mergeRangesWith
 } = require('../utils/dedupe.js');
@@ -1333,66 +1335,215 @@ const initJsCoverageList = (item) => {
     return coverageList;
 };
 
-// ========================================================================================================
-
-const isCoveredInRanges = (range, uncoveredBytes) => {
-    if (!uncoveredBytes.length) {
-        return true;
+const logConvertTime = (msg, time_start, untested) => {
+    if (untested) {
+        return;
     }
-    for (const item of uncoveredBytes) {
-        if (range.start >= item.start && range.end <= item.end) {
-            return false;
+    Util.logTime(msg, time_start);
+};
+
+const convertCoverages = (list, options, untested) => {
+    const stateList = [];
+
+    for (const item of list) {
+        // console.log([item.id]);
+
+        const time_start_ast = Date.now();
+
+        const {
+            type, source, fake, sourcePath
+        } = item;
+
+        // for source file, type could be ts or vue as extname, but js = true
+        const js = type === 'js';
+        item.js = js;
+
+        // source mapping
+        const locator = new Locator(source);
+        const maxContentLength = source.length;
+
+        // ============================
+        // move sourceMap
+        const sourceMap = item.sourceMap;
+        if (sourceMap) {
+            delete item.sourceMap;
+        }
+
+        // ============================
+        // move functions and ranges to coverageList
+        let coverageList = [];
+        let astInfo;
+        if (js) {
+            coverageList = initJsCoverageList(item);
+            // remove original functions
+            if (!Util.isDebug()) {
+                delete item.functions;
+            }
+            astInfo = getJsAstInfo(item, coverageList);
+        } else {
+            // convent css covered ranges to rules ranges and include uncovered ranges
+            astInfo = getCssAstInfo(item, coverageList);
+            // remove original ranges
+            if (!Util.isDebug()) {
+                delete item.ranges;
+            }
         }
+
+        logConvertTime(`  ┌ [convert] parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast, untested);
+
+        // console.log(sourcePath, astInfo.statements.length);
+        // ============================
+
+        const time_start_unpack = Date.now();
+
+        // current file and it's sources from sourceMap
+        // see const originalState
+        const state = {
+            js,
+            type,
+            source,
+            fake,
+            sourcePath,
+            sourceMap,
+            locator,
+            maxContentLength,
+            decodedMappings: [],
+            rangeCache: new Map(),
+            diffCache: new Map(),
+
+            // alignTextList: [],
+
+            // coverage info
+            bytes: [],
+            functions: [],
+            branches: [],
+            statements: [],
+            astInfo,
+            // for sub source files
+            coverageList,
+            originalList: [],
+            // coverage data
+            v8Data: item
+        };
+
+        unpackDistFile(item, state, options);
+        const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
+
+        stateList.push(state);
+
+        logConvertTime(`  ┌ [convert] unpacked sourcemap: ${sourcePath} (${unpackedFiles})`, time_start_unpack, untested);
+
     }
-    return true;
+
+    return stateList;
+};
+
+// ========================================================================================================
+
+const isUncoveredRange = (range, key, uncoveredGroups) => {
+
+    let uncovered = true;
+    uncoveredGroups.forEach((group) => {
+        const { groupMap, state } = group;
+
+        // ========================================================
+        // self key
+        if (groupMap.has(key)) {
+            return;
+        }
+
+        // ========================================================
+        // in all group
+        for (const item of groupMap.values()) {
+            if (range.start >= item.start && range.end <= item.end) {
+                return;
+            }
+        }
+
+        // ========================================================
+        // no sourcemap mappings in range
+        // check original range in decodedMappings
+        const { decodedMappings } = state;
+        const item = decodedMappings.find((it) => it.originalOffset >= range.start && it.originalOffset <= range.end);
+        if (!item) {
+            return;
+        }
+
+        // ========================================================
+        uncovered = false;
+
+    });
+
+    return uncovered;
+
 };
 
 const mergeV8Data = (state, stateList) => {
     // console.log(stateList);
 
-    // const sourcePath = state.sourcePath;
-    // console.log(sourcePath);
-    // if (sourcePath.endsWith('scroll_zoom.ts')) {
-    // console.log('merge v8 data ===================================', sourcePath);
-    // console.log(stateList.map((it) => it.bytes));
-    // console.log(stateList.map((it) => it.functions));
-    // console.log(stateList.map((it) => it.branches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))])));
+    // let debug = false;
+    // if (state.sourcePath.endsWith('counter.tsx')) {
+    //     debug = true;
+    //     console.log('merge v8 data ===================================', state.sourcePath);
+    //     console.log('bytes before ============', stateList.map((it) => it.bytes));
+    //     // console.log('statements ==============', stateList.map((it) => it.statements));
+    //     // console.log('functions ==============', stateList.map((it) => it.functions));
+    //     // console.log('branches ======================', stateList.map((it) => it.branches.map((b) => [`${b.start}-${b.end}`, JSON.stringify(b.locations.map((l) => l.count))])));
     // }
 
     // ===========================================================
     // bytes
     const mergedBytes = [];
-    const uncoveredList = [];
+
+    const coveredMap = new Map();
+    const uncoveredMap = new Map();
+    const uncoveredGroups = [];
     stateList.forEach((st) => {
+        const groupMap = new Map();
         const bytes = dedupeCountRanges(st.bytes);
-        const uncoveredBytes = [];
         bytes.forEach((range) => {
+            const key = `${range.start}_${range.end}`;
             if (range.count) {
                 mergedBytes.push(range);
+                coveredMap.set(key, true);
             } else {
-                uncoveredBytes.push(range);
+                uncoveredMap.set(key, range);
+                groupMap.set(key, range);
             }
         });
-        uncoveredList.push(uncoveredBytes);
+
+        uncoveredGroups.push({
+            groupMap,
+            state: st
+        });
     });
-    // just remove uncovered range
-    uncoveredList.forEach((currentBytes) => {
-        currentBytes.forEach((range) => {
-            for (const targetBytes of uncoveredList) {
-                if (targetBytes === currentBytes) {
-                    continue;
-                }
-                if (isCoveredInRanges(range, targetBytes)) {
-                    return;
-                }
-            }
+
+    // if (debug) {
+    //     console.log('coveredMap ============', coveredMap);
+    //     console.log('uncoveredMap ============', uncoveredMap);
+    //     console.log('uncoveredGroups ============', uncoveredGroups);
+    // }
+
+    uncoveredMap.forEach((range, key) => {
+
+        // in covered range
+        if (coveredMap.has(key)) {
+            return;
+        }
+
+        if (isUncoveredRange(range, key, uncoveredGroups)) {
             mergedBytes.push(range);
-        });
+        }
+
     });
 
     // will be dedupeCountRanges in collectFileCoverage
     state.bytes = mergedBytes;
 
+    // if (debug) {
+    //     console.log('bytes after ============', mergedBytes);
+    // }
+
     // ===========================================================
     // functions
     const allFunctions = stateList.map((it) => it.functions).flat();
@@ -1432,6 +1583,20 @@ const mergeV8Data = (state, stateList) => {
     const mergedFunctions = mergeRangesWith(allFunctions, functionComparer, functionHandler);
     state.functions = mergedFunctions;
 
+    // ===========================================================
+    // statements
+    const allStatements = stateList.map((it) => it.statements).flat();
+    const statementComparer = (lastRange, range) => {
+        // exact matched because the statement range is generated from ast
+        return lastRange.start === range.start && lastRange.end === range.end;
+    };
+    const statementHandler = (lastRange, range) => {
+        // merge statements count
+        lastRange.count += range.count;
+    };
+    const mergedStatements = mergeRangesWith(allStatements, statementComparer, statementHandler);
+    state.statements = mergedStatements;
+
     // ===========================================================
     // branches
     const allBranches = stateList.map((it) => it.branches).flat();
@@ -1458,6 +1623,43 @@ const mergeV8Data = (state, stateList) => {
     // }
 
 
+};
+
+const addUntestedFiles = async (stateList, options) => {
+
+    const time_start_untested = Date.now();
+
+    const testedMap = new Map();
+    stateList.forEach((state) => {
+        const { v8Data, originalList } = state;
+        // dedupe dist file if not debug
+        if (!v8Data.dedupe) {
+            testedMap.set(state.sourcePath, true);
+        }
+        originalList.forEach((originalState) => {
+            testedMap.set(originalState.sourcePath, true);
+        });
+    });
+
+    // console.log('testedMap', testedMap);
+
+    const untestedList = await getUntestedList(testedMap, options, 'v8');
+    if (!untestedList) {
+        return;
+    }
+
+    const untestedStateList = convertCoverages(untestedList, options, true);
+
+    // console.log(untestedStateList);
+    untestedStateList.forEach((state) => {
+        stateList.push(state);
+    });
+
+    // console.log('untestedList', untestedList);
+
+    Util.logTime(`  ┌ [convert] added untested files: ${EC.yellow(untestedList.length)}`, time_start_untested);
+
+
 };
 
 const generateV8DataList = (stateList, options) => {
@@ -1536,109 +1738,17 @@ const generateV8DataList = (stateList, options) => {
     };
 };
 
-const convertV8List = (v8list, options) => {
-
-    const stateList = [];
-
-    for (const item of v8list) {
-        // console.log([item.id]);
-
-        const time_start_ast = Date.now();
-
-        const {
-            type, source, fake, sourcePath
-        } = item;
-
-        // for source file, type could be ts or vue as extname, but js = true
-        const js = type === 'js';
-        item.js = js;
+const convertV8List = async (v8list, options) => {
 
-        // source mapping
-        const locator = new Locator(source);
-        const maxContentLength = source.length;
+    // for tested files
+    const stateList = convertCoverages(v8list, options);
 
-        // ============================
-        // move sourceMap
-        const sourceMap = item.sourceMap;
-        if (sourceMap) {
-            delete item.sourceMap;
-        }
-
-        // ============================
-        // move functions and ranges to coverageList
-        let coverageList = [];
-        let astInfo;
-        if (js) {
-            coverageList = initJsCoverageList(item);
-            // remove original functions
-            if (!Util.isDebug()) {
-                delete item.functions;
-            }
-            astInfo = getJsAstInfo(item, coverageList);
-        } else {
-            // convent css covered ranges to rules ranges and include uncovered ranges
-            astInfo = getCssAstInfo(item, coverageList);
-            // remove original ranges
-            if (!Util.isDebug()) {
-                delete item.ranges;
-            }
-        }
-
-        Util.logTime(`  ┌ [convert] parsed ast: ${sourcePath} (${EC.cyan(Util.BSF(maxContentLength))})`, time_start_ast);
-
-        // console.log(sourcePath, astInfo.statements.length);
-        // ============================
-
-        const time_start_unpack = Date.now();
-
-        // current file and it's sources from sourceMap
-        // see const originalState
-        const state = {
-            js,
-            type,
-            source,
-            fake,
-            sourcePath,
-            sourceMap,
-            locator,
-            maxContentLength,
-            decodedMappings: [],
-            rangeCache: new Map(),
-            diffCache: new Map(),
-
-            // alignTextList: [],
-
-            // coverage info
-            bytes: [],
-            functions: [],
-            branches: [],
-            statements: [],
-            astInfo,
-            // for sub source files
-            coverageList,
-            originalList: [],
-            // coverage data
-            v8Data: item
-        };
-
-        unpackDistFile(item, state, options);
-        const unpackedFiles = EC.cyan(`${state.originalList.length} files`);
-
-        stateList.push(state);
-
-        Util.logTime(`  ┌ [convert] unpacked sourcemap: ${sourcePath} (${unpackedFiles})`, time_start_unpack);
-
-    }
+    // empty coverage handler
+    await addUntestedFiles(stateList, options);
 
     const time_start_convert = Date.now();
-
     const dataList = generateV8DataList(stateList, options);
     const dataFiles = EC.cyan(`${dataList.v8DataList.length} files`);
-
-    // stateList.forEach((st, i) => {
-    // Util.writeFileSync(`align-text-${i}.js`, `window.gridData = ${JSON.stringify(st.alignTextList, null, 4)}`);
-    // });
-
     Util.logTime(`  ┌ [convert] converted data list (${dataFiles})`, time_start_convert);
 
     return dataList;

package/lib/converter/untested.js

@@ -0,0 +1,237 @@
+const fs = require('fs');
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const { pathToFileURL, fileURLToPath } = require('url');
+
+// const EC = require('eight-colors');
+const { minimatch } = require('../packages/monocart-coverage-vendor.js');
+
+// ========================================================================================================
+
+const resolveAllDirList = (input) => {
+    const dirs = Util.toList(input, ',');
+    if (!dirs.length) {
+        return;
+    }
+    const dirList = dirs.filter((it) => fs.existsSync(it));
+    if (!dirList.length) {
+        return;
+    }
+    return dirList;
+};
+
+const resolveAllFilter = (input) => {
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
+    }
+
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
+        // string to multiple patterns "{...}"
+        const obj = Util.strToObj(input);
+        if (obj) {
+            input = obj;
+        } else {
+            return (filePath) => {
+                return minimatch(filePath, input);
+            };
+        }
+    }
+
+    // for patterns
+    if (input && typeof input === 'object') {
+        const patterns = Object.keys(input);
+        return (filePath) => {
+            for (const pattern of patterns) {
+                if (minimatch(filePath, pattern)) {
+                    return input[pattern];
+                }
+            }
+            // false if not matched
+        };
+    }
+
+    // default
+    return () => true;
+};
+
+const resolveAllOptions = (input) => {
+    if (!input) {
+        return;
+    }
+
+    let dir;
+    let filter;
+    let transformer;
+
+    if (typeof input === 'string') {
+        const obj = Util.strToObj(input);
+        if (obj) {
+            dir = obj.dir;
+            filter = obj.filter;
+            transformer = obj.transformer;
+        } else {
+            dir = input;
+        }
+    } else if (Array.isArray(input)) {
+        dir = input;
+    } else {
+        dir = input.dir;
+        filter = input.filter;
+        transformer = input.transformer;
+    }
+
+    const dirList = resolveAllDirList(dir);
+    if (!dirList) {
+        return;
+    }
+
+    const fileFilter = resolveAllFilter(filter);
+    const fileTransformer = typeof transformer === 'function' ? transformer : () => {};
+
+    return {
+        dirList,
+        fileFilter,
+        fileTransformer
+    };
+};
+
+const resolveFileType = (fileType, filePath) => {
+    if (fileType === 'js' || fileType === 'css') {
+        return fileType;
+    }
+    const extname = path.extname(filePath);
+    if (['.css', '.scss', '.sass', '.less'].includes(extname)) {
+        return 'css';
+    }
+    return 'js';
+};
+
+const getUntestedCoverageData = (emptyList, options, coverageType) => {
+
+    // NOTE: do not save untested file to raw report
+
+    const emptyCoverageList = [];
+
+    // save all empty source and sourcemap
+    for (const entryFile of emptyList) {
+
+        const { type, url } = entryFile;
+
+        if (coverageType === 'istanbul') {
+
+            // ===============================================
+            const item = {
+                path: fileURLToPath(url),
+                statementMap: {},
+                fnMap: {},
+                branchMap: {},
+                s: {},
+                f: {},
+                b: {}
+            };
+            // object
+            emptyCoverageList.push(item);
+
+        } else {
+
+            // ===============================================
+            if (type === 'js') {
+                // empty js
+                entryFile.functions = entryFile.functions || [{
+                    functionName: '',
+                    ranges: [{
+                        startOffset: 0,
+                        endOffset: entryFile.source.length,
+                        count: 0
+                    }]
+                }];
+            } else {
+                // empty css
+                entryFile.ranges = entryFile.ranges || [];
+            }
+
+            // will be parsed to AST and converted to V8 coverage
+            emptyCoverageList.push(entryFile);
+
+        }
+
+    }
+
+    return emptyCoverageList;
+};
+
+const getEmptyCoverages = async (fileList, options, coverageType, fileTransformer) => {
+
+    const emptyList = [];
+
+    for (const item of fileList) {
+        const {
+            filePath, fileType, sourcePath
+        } = item;
+        const type = resolveFileType(fileType, filePath);
+        const url = pathToFileURL(filePath).toString();
+        const source = Util.readFileSync(filePath);
+        const entryFile = {
+            empty: true,
+            type,
+            url,
+            sourcePath,
+            // for empty, css supports both source and text
+            source
+        };
+
+        await fileTransformer(entryFile, coverageType);
+
+        // after transformer
+        entryFile.id = Util.calculateSha1(entryFile.sourcePath + entryFile.source);
+
+        emptyList.push(entryFile);
+    }
+
+    // save empty coverage for merging raw reports
+    return getUntestedCoverageData(emptyList, options, coverageType);
+};
+
+const getUntestedList = (testedMap, options, coverageType = 'v8') => {
+    const allOptions = resolveAllOptions(options.all);
+    // console.log('allOptions', all, allOptions);
+    if (!allOptions) {
+        return;
+    }
+    const {
+        dirList, fileFilter, fileTransformer
+    } = allOptions;
+    const fileList = [];
+    dirList.forEach((dir) => {
+        Util.forEachFile(dir, [], (fileName, fileDir) => {
+            const filePath = path.resolve(fileDir, fileName);
+            // return file extname for file type
+            const fileType = fileFilter(filePath);
+            if (fileType) {
+                const sourcePath = Util.relativePath(filePath);
+                if (!testedMap.has(sourcePath)) {
+                    fileList.push({
+                        filePath,
+                        fileType,
+                        sourcePath
+                    });
+                }
+            }
+        });
+    });
+    // console.log('fileList', fileList);
+    if (!fileList.length) {
+        return;
+    }
+
+    return getEmptyCoverages(fileList, options, coverageType, fileTransformer);
+
+};
+
+
+module.exports = {
+    getUntestedList
+};

package/lib/default/options.js

@@ -67,7 +67,8 @@ module.exports = {
     // options for adding empty coverage for all files
     // all: {
     //     dir: ['src'],
-    //     filter: (sourcePath) => true
+    //     filter: (sourcePath) => true,
+    //     transformer: (entry) => {}
     // },
     all: null,