monocart-coverage-reports 2.5.7 → 2.5.8

package/README.md

@@ -37,6 +37,8 @@
     - [Playwright](#playwright)
     - [Jest](#jest)
     - [Vitest](#vitest)
+    - [CodeceptJS](#codeceptjs)
+    - [WebdriverIO](#webdriverio)
     - [Codecov](#codecov)
     - [Coveralls](#coveralls)
     - [Sonar Cloud](#sonar-cloud)
@@ -190,12 +192,22 @@ const coverageOptions = {
     sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
 };
 ```
-Or `minimatch` pattern:
+Or using `minimatch` pattern:
 ```js
 const coverageOptions = {
     entryFilter: "**/main.js",
     sourceFilter: "**/src/**"
 };
+// supports multiple patterns:
+const coverageOptions = {
+    entryFilter: {
+        '**/vendor.js': false,
+        '**/main.js': true
+    },
+    sourceFilter: {
+        '**/src/**': true
+    }
+};
 ```
 
 ## onEnd Hook
@@ -343,21 +355,31 @@ await MCR(coverageOptions).add(jsCoverage);
 ## Collecting Raw V8 Coverage Data with Puppeteer
 > Puppeteer does not provide raw v8 coverage data by default. A simple conversion is required, see example: [./test/test-puppeteer.js](./test/test-puppeteer.js)
 ```js
-await page.coverage.startJSCoverage({
-    // provide raw v8 coverage data
-    includeRawScriptCoverage: true
-});
+await Promise.all([
+    page.coverage.startJSCoverage({
+        resetOnNavigation: false,
+        // provide raw v8 coverage data
+        includeRawScriptCoverage: true
+    }),
+    page.coverage.startCSSCoverage({
+        resetOnNavigation: false
+    })
+]);
 
 await page.goto(url);
 
-const jsCoverage = await page.coverage.stopJSCoverage();
-const rawV8CoverageData = jsCoverage.map((it) => {
-    // Convert to raw v8 coverage format
+const [jsCoverage, cssCoverage] = await Promise.all([
+    page.coverage.stopJSCoverage(),
+    page.coverage.stopCSSCoverage()
+]);
+
+// to raw V8 script coverage
+const coverageData = [... jsCoverage.map((it) => {
     return {
         source: it.text,
         ... it.rawScriptCoverage
     };
-}
+}), ... cssCoverage];
 ```
 
 ## Node.js V8 Coverage Report for Server Side
@@ -503,42 +525,41 @@ const coverageOptions = {
 ```
 
 ## Adding Empty Coverage for Untested Files
-By default the untested files will not be included in the coverage report, we can first add empty coverage data for all files, so the files with coverage data will be merged, and untested files will retain 0% coverage.
+By default the untested files will not be included in the coverage report, we can add empty coverage data for all files with option `all`, the untested files will show 0% coverage.
 ```js
-const fs = require('fs');
-const path = require('path');
-const { pathToFileURL } = require('url');
-const MCR = require('monocart-coverage-reports');
-
-const dir = "./src";
-const coverageData = [];
-const fileList = fs.readdirSync(dir);
-for (const filename of fileList) {
-    const filePath = path.resolve(dir, filename);
-    const source = fs.readFileSync(filePath).toString('utf-8');
-    const sourcePath = path.relative(process.cwd(), filePath);
-    const url = pathToFileURL(sourcePath).toString();
-    const extname = path.extname(filename);
-    if (['.css'].includes(extname)) {
-        coverageData.push({
-            empty: true,
-            type: 'css',
-            url,
-            text: source
-        });
-    } else {
-        coverageData.push({
-            empty: true,
-            type: 'js',
-            url,
-            source
-        });
+const coverageOptions = {
+    all: {
+        dir: ['./src'],
+        filter: (filePath) => {
+            return true;
+        }
     }
-}
-const options = require('path-to/same-options.js');
-await MCR(options).add(coverageData);
+};
+```
+The filter also supports `minimatch` pattern:
+```js
+const coverageOptions = {
+    all: {
+        dir: ['./src'],
+        filter: '**/*.js'
+    }
+};
+// or multiple patterns
+const coverageOptions = {
+    all: {
+        dir: ['./src'],
+        filter: {
+            // exclude files
+            '**/ignored-*.js': false,
+            '**/*.html': false,
+            '**/*.ts': false,
+            // empty css coverage
+            '**/*.scss': "css",
+            '**/*': true
+        }
+    }
+};
 ```
-see example: [./test/cli-options.js](./test/cli-options.js)
 
 ## Ignoring Uncovered Codes
 To ignore codes, use the special comment which starts with `v8 ignore `:
@@ -675,6 +696,12 @@ When `logging` is `debug`, the raw report data will be preserved in `[outputDir]
 ### [Vitest](https://github.com/vitest-dev/vitest)
 - [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage) - A Vitest custom provider module for coverage reports
 
+### [CodeceptJS](https://github.com/codeceptjs/CodeceptJS)
+- [codeceptjs-monocart-coverage](https://github.com/cenfun/codeceptjs-monocart-coverage) - A CodeceptJS plugin for coverage reports
+
+### [WebdriverIO](https://github.com/webdriverio/webdriverio)
+- [wdio-monocart-service](https://github.com/cenfun/wdio-monocart-service) - A WebdriverIO service 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/ast.js

@@ -167,19 +167,34 @@ const getJsAstInfo = (item, coverageList) => {
         allowHashBang: true
     };
 
+    let err;
     let ast;
     try {
         ast = acorn.parse(source, options);
     } catch (e) {
+        err = e;
+    }
+
+    if (err) {
 
-        // empty = untested file, could be .ts, .vue and so on, that can not be parsed normally
-        if (!empty) {
-            Util.logInfo(`failed to parse source file: ${item.sourcePath} ${e.message}`);
+        // empty = untested file
+        // could be .ts, .vue and so on, that can not be parsed normally
+        if (empty) {
+            return {
+                functions: [],
+                branches: [],
+                statements: []
+            };
         }
+
+        // runtime code should be parsed successful
+        Util.logInfo(`failed to parse source file: ${item.sourcePath} ${err.message}`);
+
         // https://github.com/acornjs/acorn/tree/master/acorn-loose
         // It is recommended to always try a parse with the regular acorn parser first,
         // and only fall back to this parser when that one finds syntax errors.
         ast = acornLoose.parse(source, options);
+
     }
 
     const coverageInfo = getCoverageInfo(coverageList);

package/lib/converter/converter.js

@@ -841,17 +841,34 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 // ========================================================================================================
 
 const getSourceFilter = (options) => {
-    const sourceFilter = options.sourceFilter;
-    if (typeof sourceFilter === 'function') {
-        return sourceFilter;
+    const input = options.sourceFilter;
+
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
     }
 
-    if (sourceFilter && typeof sourceFilter === 'string') {
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
         return (sourcePath) => {
-            return minimatch(sourcePath, sourceFilter);
+            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;
 };
 

package/lib/default/options.js

@@ -46,6 +46,13 @@ module.exports = {
     // sourceFilter: (sourcePath) => sourcePath.search(/src\/.+/) !== -1,
     sourceFilter: null,
 
+    // options for adding empty coverage for all files
+    // all: {
+    //     dir: ['src'],
+    //     filter: (sourcePath) => true
+    // },
+    all: null,
+
     // (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop
     v8Ignore: true,
 

package/lib/generate.js

@@ -11,6 +11,9 @@ const { mergeV8Coverage, saveV8Report } = require('./v8/v8.js');
 
 const { convertV8List } = require('./converter/converter.js');
 
+const { minimatch } = require('./packages/monocart-coverage-vendor.js');
+const { pathToFileURL } = require('url');
+
 // ========================================================================================================
 
 // maybe v8 or to istanbul reports
@@ -288,8 +291,175 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
 
 // ========================================================================================================
 
+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') {
+        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 resolveAllDataType = (type, dataList) => {
+    if (!type && dataList.length) {
+        const firstData = dataList[0];
+        type = firstData.type;
+    }
+    const types = {
+        v8: 'v8',
+        istanbul: 'istanbul'
+    };
+    return types[type] || types.v8;
+};
 
-const getInputData = async (inputList) => {
+const resolveAllOptions = (input, dataList) => {
+    if (!input) {
+        return;
+    }
+
+    let type;
+    let dir;
+    let filter;
+    if (typeof input === 'string' || Array.isArray(input)) {
+        dir = input;
+        filter = () => true;
+    } else {
+        type = input.type;
+        dir = input.dir;
+        filter = input.filter;
+    }
+
+    const dirList = resolveAllDirList(dir);
+    if (!dirList) {
+        return;
+    }
+
+    const dataType = resolveAllDataType(type, dataList);
+    const fileFilter = resolveAllFilter(filter);
+
+    return {
+        dirList,
+        dataType,
+        fileFilter
+    };
+};
+
+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 getV8EmptyData = (fileList) => {
+    const v8DataList = [];
+    fileList.forEach((item) => {
+        const { filePath, fileType } = item;
+        const type = resolveFileType(fileType, filePath);
+        const url = pathToFileURL(filePath).toString();
+        const source = Util.readFileSync(filePath);
+        const entryFile = {
+            empty: true,
+            type,
+            url,
+            // for empty, css supports both source and text
+            source
+        };
+        v8DataList.push(entryFile);
+    });
+    return v8DataList;
+};
+
+const getIstanbulEmptyData = (fileList) => {
+    const istanbulData = {};
+    fileList.forEach((item) => {
+        const { filePath } = item;
+        istanbulData[filePath] = {
+            path: filePath,
+            statementMap: {},
+            fnMap: {},
+            branchMap: {},
+            s: {},
+            f: {},
+            b: {}
+        };
+    });
+    return istanbulData;
+};
+
+const getEmptyData = (all, dataList) => {
+    const allOptions = resolveAllOptions(all, dataList);
+    // console.log('allOptions', all, allOptions);
+    if (!allOptions) {
+        return;
+    }
+    const {
+        dirList, dataType, fileFilter
+    } = allOptions;
+    const fileList = [];
+    dirList.forEach((dir) => {
+        Util.forEachFile(dir, [], (fileName, fileDir) => {
+            const filePath = path.resolve(fileDir, fileName);
+            const fileType = fileFilter(filePath);
+            if (fileType) {
+                fileList.push({
+                    filePath,
+                    fileType
+                });
+            }
+        });
+    });
+    // console.log('fileList', fileList);
+    if (!fileList.length) {
+        return;
+    }
+    if (dataType === 'v8') {
+        return getV8EmptyData(fileList);
+    }
+    return getIstanbulEmptyData(fileList);
+};
+
+// ========================================================================================================
+
+
+const getInputData = async (inputList, all, cacheDir, addHandler) => {
     const dataList = [];
     const sourceCache = new Map();
 
@@ -321,6 +491,35 @@ const getInputData = async (inputList) => {
             }
         }
     }
+
+    // add empty coverage for all files
+    // dataList for data type, before `add` we don't which one is tested, because using hash id
+    const emptyData = getEmptyData(all, dataList);
+    if (emptyData) {
+        const coverageResults = await addHandler(emptyData);
+        // after `add`
+        if (coverageResults) {
+            dataList.push(coverageResults);
+            if (coverageResults.type === 'v8') {
+                // sourceCache
+                coverageResults.data.forEach((entry) => {
+                    const { id } = entry;
+                    if (sourceCache.has(id)) {
+                        // console.log('+', entry.sourcePath);
+                        return;
+                    }
+                    // console.log('-', entry.sourcePath);
+                    const sourcePath = Util.resolveCacheSourcePath(cacheDir, id);
+                    const content = Util.readFileSync(sourcePath);
+                    if (content) {
+                        const json = JSON.parse(content);
+                        sourceCache.set(json.id, json);
+                    }
+                });
+            }
+        }
+    }
+
     return {
         dataList,
         sourceCache

package/lib/index.d.ts

@@ -220,19 +220,41 @@ declare namespace MCR {
 
         /** (V8 only) 
          * 
-         * {string} `minimatch` pattern for entry url; multiple patterns: "{pattern1,pattern2}";
+         * {string} `minimatch` pattern for entry url; {object} multiple patterns;
          * 
          * {function} A filter function for each entry file in the V8 list.
          * */
-        entryFilter?: string | ((entry: V8CoverageEntry) => boolean);
+        entryFilter?: string | {
+            [pattern: string]: boolean;
+        } | ((entry: V8CoverageEntry) => boolean);
 
         /** (V8 only) 
          * 
-         * {string} `minimatch` pattern for source path; multiple patterns: "{pattern1,pattern2}";
+         * {string} `minimatch` pattern for source path; {object} multiple patterns;
          * 
          * {function} A filter function for each source path when the source is unpacked from the source map. 
          * */
-        sourceFilter?: string | ((sourcePath: string) => boolean);
+        sourceFilter?: string | {
+            [pattern: string]: boolean;
+        } | ((sourcePath: string) => boolean);
+
+        /**
+         * options for adding empty coverage for all files
+         */
+        all?: string | string[] | {
+            /** the dir(s) of all files */
+            dir: string | string[];
+            /** the coverage data type, v8 or istanbul */
+            type?: "v8" | "istanbul";
+            /** 
+             * the file filter, 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 | {
+                [pattern: string]: "js" | "css" | boolean;
+            } | ((filePath: string) => "js" | "css" | boolean)
+        };
 
         /** (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop */
         v8Ignore?: boolean;

package/lib/index.js

@@ -83,7 +83,10 @@ class CoverageReport {
 
         this.initOptions();
 
-        const { inputDir, cacheDir } = this.options;
+        const {
+            all, inputDir, cacheDir
+        } = this.options;
+
         const inputDirs = Util.toList(inputDir, ',');
         if (this.hasCache()) {
             inputDirs.push(cacheDir);
@@ -92,16 +95,16 @@ class CoverageReport {
         const inputList = inputDirs.filter((dir) => {
             const hasDir = fs.existsSync(dir);
             if (!hasDir) {
-                Util.logError(`Not found coverage data dir: ${Util.relativePath(dir)}`);
+                // could be empty
+                Util.logInfo(`Not found coverage data dir: ${Util.relativePath(dir)}`);
             }
             return hasDir;
         });
 
-        if (!inputList.length) {
-            return;
-        }
+        const { dataList, sourceCache } = await getInputData(inputList, all, cacheDir, (emptyData) => {
+            return this.add(emptyData);
+        });
 
-        const { dataList, sourceCache } = await getInputData(inputList);
         if (!dataList.length) {
             const dirs = inputList.map((dir) => Util.relativePath(dir));
             Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);