monocart-coverage-reports 2.10.6 → 2.10.8-beta.0

package/lib/converter/converter.js

@@ -21,7 +21,6 @@ const {
 const { getSourceType, initSourceMapSourcesPath } = require('../utils/source-path.js');
 
 const { decode } = require('@jridgewell/sourcemap-codec');
-const { minimatch } = require('../packages/monocart-coverage-vendor.js');
 
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
@@ -956,50 +955,10 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 
 // ========================================================================================================
 
-const getSourceFilter = (options) => {
-    let input = options.sourceFilter || options.filter;
-
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        // mcr npx mocha --sourceFilter {'**/node_modules/**':false,'**/src/*.js':true}
-        // mcr npx mocha --sourceFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (sourcePath) => {
-                return minimatch(sourcePath, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (sourcePath) => {
-            for (const pattern of patterns) {
-                if (minimatch(sourcePath, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
-    // default
-    return () => true;
-};
-
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
-    const sourceFilter = getSourceFilter(options);
+    const sourceFilter = Util.getSourceFilter(options);
 
     // create original content mappings
     const originalStateMap = new Map();

package/lib/converter/untested.js

@@ -4,8 +4,10 @@ const Util = require('../utils/util.js');
 
 const { pathToFileURL, fileURLToPath } = require('url');
 
+const { normalizeSourcePath, getSourcePathReplacer } = require('../utils/source-path.js');
+
 // const EC = require('eight-colors');
-const { minimatch } = require('../packages/monocart-coverage-vendor.js');
+const { minimatch, convertSourceMap } = require('../packages/monocart-coverage-vendor.js');
 
 // ========================================================================================================
 
@@ -109,16 +111,64 @@ const resolveFileType = (fileType, filePath) => {
     return 'js';
 };
 
-const getUntestedCoverageData = (emptyList, options, coverageType) => {
+const saveUntestedFileSource = async (entryFile, options) => {
+    const {
+        id,
+        url,
+        source,
+        sourceMap
+    } = entryFile;
+    // console.log('-', entry.sourcePath);
+
+    const { cachePath } = Util.getCacheFileInfo('source', id, options.cacheDir);
+    if (fs.existsSync(cachePath)) {
+        return;
+    }
+
+    // save source and sourceMap to separated json file
+    const sourceData = {
+        id,
+        url,
+        source,
+        sourceMap
+    };
+
+    // remove comments if not debug
+    if (!Util.isDebug()) {
+        sourceData.source = convertSourceMap.removeComments(source);
+    }
+
+    // console.log('save untested file', id, url);
+
+    await Util.saveSourceCacheFile(sourceData, options);
+
+};
+
+const getUntestedCoverageData = async (entryList, options, coverageType) => {
+
+    // save all empty coverage
+    const dataId = Util.uid();
+    const results = {
+        id: dataId
+    };
 
-    // NOTE: do not save untested file to raw report
+    if (coverageType === 'istanbul') {
+        results.type = 'istanbul';
+        results.data = {};
+    } else {
+        results.type = 'v8';
+        results.data = [];
+    }
 
     const emptyCoverageList = [];
 
     // save all empty source and sourcemap
-    for (const entryFile of emptyList) {
+    for (const entry of entryList) {
 
-        const { type, url } = entryFile;
+        // for raw report: source file
+        await saveUntestedFileSource(entry, options);
+
+        const { type, url } = entry;
 
         if (coverageType === 'istanbul') {
 
@@ -133,6 +183,7 @@ const getUntestedCoverageData = (emptyList, options, coverageType) => {
                 b: {}
             };
             // object
+            results.data[item.path] = item;
             emptyCoverageList.push(item);
 
         } else {
@@ -140,59 +191,99 @@ const getUntestedCoverageData = (emptyList, options, coverageType) => {
             // ===============================================
             if (type === 'js') {
                 // empty js
-                entryFile.functions = entryFile.functions || [{
+                entry.functions = entry.functions || [{
                     functionName: '',
                     ranges: [{
                         startOffset: 0,
-                        endOffset: entryFile.source.length,
+                        endOffset: entry.source.length,
                         count: 0
                     }]
                 }];
             } else {
                 // empty css
-                entryFile.ranges = entryFile.ranges || [];
+                entry.ranges = entry.ranges || [];
             }
 
+            const item = {
+                ... entry
+            };
+            delete item.source;
+            delete item.sourceMap;
+
+            // array
+            results.data.push(item);
             // will be parsed to AST and converted to V8 coverage
-            emptyCoverageList.push(entryFile);
+            emptyCoverageList.push(entry);
 
         }
 
     }
 
+    // for raw report: coverage file
+    const { cachePath } = Util.getCacheFileInfo('coverage', dataId, options.cacheDir);
+    await Util.writeFile(cachePath, JSON.stringify(results));
+
     return emptyCoverageList;
 };
 
-const getEmptyCoverages = async (fileList, options, coverageType, fileTransformer) => {
+const getEmptyCoverages = async (testedMap, options, coverageType, fileList, fileTransformer) => {
+    const sourceFilter = Util.getSourceFilter(options);
+    const sourcePathReplacer = getSourcePathReplacer(options);
+    const baseDir = options.baseDir;
 
-    const emptyList = [];
+    // console.log(fileList);
 
+    const entryList = [];
     for (const item of fileList) {
-        const {
-            filePath, fileType, sourcePath
-        } = item;
+
+        const { fileType, filePath } = item;
         const type = resolveFileType(fileType, filePath);
         const url = pathToFileURL(filePath).toString();
         const source = Util.readFileSync(filePath);
-        const entryFile = {
+        const entry = {
             empty: true,
             type,
             url,
-            sourcePath,
-            // for empty, css supports both source and text
             source
         };
 
-        await fileTransformer(entryFile, coverageType);
+        // normalize sourcePath here
+        let sourcePath = normalizeSourcePath(url, baseDir);
+        if (sourcePathReplacer) {
+            const newSourcePath = sourcePathReplacer(sourcePath, entry);
+            if (typeof newSourcePath === 'string' && newSourcePath) {
+                sourcePath = newSourcePath;
+            }
+        }
+
+        // console.log(sourcePath);
+
+        if (testedMap.has(sourcePath)) {
+            continue;
+        }
 
+        if (!sourceFilter(sourcePath)) {
+            continue;
+        }
+
+        entry.sourcePath = sourcePath;
+
+        await fileTransformer(entry, coverageType);
         // after transformer
-        entryFile.id = Util.calculateSha1(entryFile.sourcePath + entryFile.source);
+        entry.id = Util.calculateSha1(entry.sourcePath + entry.source);
 
-        emptyList.push(entryFile);
+        entryList.push(entry);
     }
 
+
+    // console.log('fileList', fileList);
+    if (!entryList.length) {
+        return;
+    }
+
+
     // save empty coverage for merging raw reports
-    return getUntestedCoverageData(emptyList, options, coverageType);
+    return getUntestedCoverageData(entryList, options, coverageType);
 };
 
 const getUntestedList = (testedMap, options, coverageType = 'v8') => {
@@ -201,9 +292,11 @@ const getUntestedList = (testedMap, options, coverageType = 'v8') => {
     if (!allOptions) {
         return;
     }
+
     const {
         dirList, fileFilter, fileTransformer
     } = allOptions;
+
     const fileList = [];
     dirList.forEach((dir) => {
         Util.forEachFile(dir, [], (fileName, fileDir) => {
@@ -211,23 +304,22 @@ const getUntestedList = (testedMap, options, coverageType = 'v8') => {
             // 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
-                    });
-                }
+                fileList.push({
+                    filePath,
+                    fileType,
+                    fileDir,
+                    fileName
+                });
             }
+
         });
     });
-    // console.log('fileList', fileList);
+
     if (!fileList.length) {
         return;
     }
 
-    return getEmptyCoverages(fileList, options, coverageType, fileTransformer);
+    return getEmptyCoverages(testedMap, options, coverageType, fileList, fileTransformer);
 
 };
 

package/lib/index.d.ts

@@ -361,8 +361,8 @@ declare namespace MCR {
             dir: string | string[];
 
             /** 
-             * the file filter, return the file type, if true, defaults to css if ".css" otherwise is js 
-             * 
+             * the file filter is triggered before `sourceFilter`, no need to use it in normal case
+             * the filter could return the file type, if true, defaults to css if ".css" otherwise is js 
              * {string} `minimatch` pattern for file path; {object} multiple patterns; {function} A filter function for file path;
             */
             filter?: string | {

package/lib/index.js

@@ -6,7 +6,7 @@ const EC = require('eight-colors');
 const defaultOptions = require('./default/options.js');
 const Util = require('./utils/util.js');
 
-const { initV8ListAndSourcemap, getEntryFilter } = require('./v8/v8.js');
+const { initV8ListAndSourcemap } = require('./v8/v8.js');
 const {
     getInputData, readFromDir, generateCoverageReports
 } = require('./generate.js');
@@ -225,7 +225,7 @@ class CoverageReport {
 
     // get entry filter handler
     getEntryFilter() {
-        return getEntryFilter(this.options);
+        return Util.getEntryFilter(this.options);
     }
 
     // load config file

package/lib/utils/util.js

@@ -12,7 +12,9 @@ const request = require('./request.js');
 const version = require('../../package.json').version;
 const markdownGrid = require('./markdown.js');
 
-const { findUpSync, supportsColor } = require('../packages/monocart-coverage-vendor.js');
+const {
+    findUpSync, supportsColor, minimatch
+} = require('../packages/monocart-coverage-vendor.js');
 
 // https://github.com/chalk/supports-color
 // disabled color if Terminal stdout does not support color
@@ -161,6 +163,115 @@ const Util = {
         };
     },
 
+    // eslint-disable-next-line complexity
+    getEntryFilter: (options) => {
+        // for entry.url
+
+        if (options.entryFilterHandler) {
+            return options.entryFilterHandler;
+        }
+
+        let input = options.entryFilter || options.filter;
+
+        // for function handler
+        if (typeof input === 'function') {
+            options.entryFilterHandler = input;
+            return input;
+        }
+
+        // for single minimatch pattern
+        if (input && typeof input === 'string') {
+            // string to multiple patterns "{...}"
+            // mcr npx mocha --entryFilter {'**/node_modules/**':false,'**/src/*.js':true}
+            // mcr npx mocha --entryFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
+            const obj = Util.strToObj(input);
+            if (obj) {
+                input = obj;
+            } else {
+                const handler = (entry) => {
+                    return minimatch(entry.url, input);
+                };
+                options.entryFilterHandler = handler;
+                return handler;
+            }
+        }
+
+        // for patterns
+        if (input && typeof input === 'object') {
+            const patterns = Object.keys(input);
+            const handler = (entry) => {
+                const url = entry.url;
+                for (const pattern of patterns) {
+                    if (minimatch(url, pattern)) {
+                        return input[pattern];
+                    }
+                }
+                // false if not matched
+            };
+            options.entryFilterHandler = handler;
+            return handler;
+        }
+
+        // default
+        const handler = () => true;
+        options.entryFilterHandler = handler;
+        return handler;
+    },
+
+    // eslint-disable-next-line complexity
+    getSourceFilter: (options) => {
+        // for sourcePath
+
+        if (options.sourceFilterHandler) {
+            return options.sourceFilterHandler;
+        }
+
+        let input = options.sourceFilter || options.filter;
+
+        // for function handler
+        if (typeof input === 'function') {
+            options.sourceFilterHandler = input;
+            return input;
+        }
+
+        // for single minimatch pattern
+        if (input && typeof input === 'string') {
+        // string to multiple patterns "{...}"
+        // mcr npx mocha --sourceFilter {'**/node_modules/**':false,'**/src/*.js':true}
+        // mcr npx mocha --sourceFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
+            const obj = Util.strToObj(input);
+            if (obj) {
+                input = obj;
+            } else {
+                const handler = (sourcePath) => {
+                    return minimatch(sourcePath, input);
+                };
+                options.sourceFilterHandler = handler;
+                return handler;
+            }
+        }
+
+        // for patterns
+        if (input && typeof input === 'object') {
+            const patterns = Object.keys(input);
+            const handler = (sourcePath) => {
+                for (const pattern of patterns) {
+                    if (minimatch(sourcePath, pattern)) {
+                        return input[pattern];
+                    }
+                }
+            // false if not matched
+            };
+            options.sourceFilterHandler = handler;
+            return handler;
+        }
+
+        // default
+        const handler = () => true;
+        options.sourceFilterHandler = handler;
+        return handler;
+    },
+
     saveSourceCacheFile: async (sourceData, options, fileCache) => {
         const { cacheName, cachePath } = Util.getCacheFileInfo('source', sourceData.id, options.cacheDir);
 

package/lib/v8/v8.js

@@ -7,7 +7,6 @@ const {
     resolveAnonymousUrl, normalizeSourcePath, getSourcePathReplacer
 } = require('../utils/source-path.js');
 const { collectSourceMaps } = require('../converter/collect-source-maps.js');
-const { minimatch } = require('../packages/monocart-coverage-vendor.js');
 
 const { v8Report } = require('../reports/v8.js');
 const { v8JsonReport } = require('../reports/v8-json.js');
@@ -27,53 +26,12 @@ const getWrapperSource = (offset, source) => {
     return startStr + source;
 };
 
-const getEntryFilter = (options) => {
-    let input = options.entryFilter || options.filter;
-
-    // for function handler
-    if (typeof input === 'function') {
-        return input;
-    }
-
-    // for single minimatch pattern
-    if (input && typeof input === 'string') {
-        // string to multiple patterns "{...}"
-        // mcr npx mocha --entryFilter {'**/node_modules/**':false,'**/src/*.js':true}
-        // mcr npx mocha --entryFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
-        const obj = Util.strToObj(input);
-        if (obj) {
-            input = obj;
-        } else {
-            return (entry) => {
-                return minimatch(entry.url, input);
-            };
-        }
-    }
-
-    // for patterns
-    if (input && typeof input === 'object') {
-        const patterns = Object.keys(input);
-        return (entry) => {
-            const url = entry.url;
-            for (const pattern of patterns) {
-                if (minimatch(url, pattern)) {
-                    return input[pattern];
-                }
-            }
-            // false if not matched
-        };
-    }
-
-    // default
-    return () => true;
-};
-
 const initV8ListAndSourcemap = async (mcr, v8list) => {
 
     const { options, fileCache } = mcr;
 
     // entry filter
-    const entryFilter = getEntryFilter(options);
+    const entryFilter = Util.getEntryFilter(options);
 
     const lengthBefore = v8list.length;
     v8list = v8list.filter(entryFilter);
@@ -367,6 +325,5 @@ const saveV8Report = async (v8list, options, istanbulReportPath) => {
 module.exports = {
     initV8ListAndSourcemap,
     mergeV8Coverage,
-    saveV8Report,
-    getEntryFilter
+    saveV8Report
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.10.6",
+    "version": "2.10.8-beta.0",
     "description": "A code coverage tool to generate native V8 reports or Istanbul reports.",
     "main": "./lib/index.js",
     "bin": {
@@ -111,4 +111,4 @@
         "vine-ui": "^3.1.16",
         "ws": "^8.18.0"
     }
-}
+}