monocart-coverage-reports 2.5.5 → 2.5.6

package/README.md

@@ -125,7 +125,7 @@ console.log(coverageResults.summary);
     }
     ```
     - istanbul custom reporter
-    > example: [./test/custom-istanbul-reporter.js](./test/custom-istanbul-reporter.js), see [istanbul built-in reporters' implementation](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-reports/lib) for reference, 
+    > example: [./test/custom-istanbul-reporter.js](./test/custom-istanbul-reporter.js), see [istanbul built-in reporters' implementation](https://github.com/istanbuljs/istanbuljs/tree/master/packages/istanbul-reports/lib) for reference.
     - v8 custom reporter
     > example: [./test/custom-v8-reporter.js](./test/custom-v8-reporter.js)
 
@@ -183,13 +183,20 @@ We can use `sourceFilter` to filter the source files. For example, we should rem
 > src/index.js
 > src/components/app.js
 ```
-Example:
+For example:
 ```js
 const coverageOptions = {
     entryFilter: (entry) => entry.url.indexOf("main.js") !== -1,
     sourceFilter: (sourcePath) => sourcePath.search(/src\//) !== -1
 };
 ```
+Or `minimatch` pattern:
+```js
+const coverageOptions = {
+    entryFilter: "**/main.js",
+    sourceFilter: "**/src/**"
+};
+```
 
 ## onEnd Hook
 For example, checking thresholds:
@@ -245,19 +252,29 @@ Arguments:
 
 Options:
   -V, --version                output the version number
-  -c, --config <path>          config path for options
+  -c, --config <path>          custom config path
   -o, --outputDir <dir>        output dir for reports
   -r, --reports <name[,name]>  coverage reports to use
   -n, --name <name>            report name for title
+  -i, --inputDir <dir>         input dir for merging raw files
+  --entryFilter <pattern>      entry url filter
+  --sourceFilter <pattern>     source path filter
   --outputFile <path>          output file for v8 report
   --inline                     inline html for v8 report
   --assetsPath <path>          assets path if not inline
   --lcov                       generate lcov.info file
+  --logging <logging>          off, error, info, debug
   -h, --help                   display help for command
 ```
-- Using configuration file for more [options](#default-options)
+- Supports loading default configuration file
+    - `.mcrrc`
+    - `mcr.config.json`
+    - `mcr.config.mjs`
+    - `mcr.config.cjs`
+    - `mcr.config.js`
+- Specify custom configuration file
 ```sh
-mcr "node ./test/test-node-env.js" -c test/cli-options.js
+mcr "node ./test.js" -c path-to/my-custom-config.js
 ```
 
 ## Compare Reports

package/lib/cli.js

@@ -3,8 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const EC = require('eight-colors');
-const { fileURLToPath } = require('url');
-
+const { fileURLToPath, pathToFileURL } = require('url');
 const {
     foregroundChild,
     program
@@ -13,21 +12,76 @@ const {
 const MCR = require('./index.js');
 const Util = require('./utils/util.js');
 const defaultOptions = require('./default/options.js');
+const { resolveSourceMap } = require('./converter/collect-source-maps.js');
+
 const version = require('../package.json').version;
 
 const cleanDir = (dir) => {
     Util.rmSync(dir);
 };
 
-const initOptions = (cliOptions) => {
-    // merge all cli options
-    const configPath = cliOptions.config;
+const resolveConfigPath = (customConfigPath) => {
+
+    const configList = [
+        '.mcrrc',
+        'mcr.config.json',
+        'mcr.config.mjs',
+        'mcr.config.cjs',
+        'mcr.config.js'
+    ];
+
+    if (customConfigPath) {
+        configList.push(customConfigPath);
+    }
+
+    const existsList = configList.filter((p) => fs.existsSync(p));
+    if (!existsList.length) {
+        return;
+    }
+
+    // last one
+    const configPath = existsList.pop();
+    Util.logInfo(`Config: ${EC.cyan(configPath)}`);
+
+    return configPath;
+};
+
+const resolveConfigOptions = async (configPath) => {
+
+    // json format
+    const ext = path.extname(configPath);
+    if (ext === '.json' || configPath.slice(-2) === 'rc') {
+        return JSON.parse(Util.readFileSync(configPath));
+    }
+
+    let configOptions;
+    let err;
+    try {
+        configOptions = await import(pathToFileURL(configPath));
+    } catch (ee) {
+        err = ee;
+    }
+
+    if (!configOptions) {
+        Util.logError(err.message);
+        return;
+    }
+
+    configOptions = configOptions.default || configOptions;
+
+    return configOptions;
+};
+
+const initOptions = async (cliOptions) => {
+
+    const configPath = resolveConfigPath(cliOptions.config);
     if (configPath) {
-        if (fs.existsSync(configPath)) {
-            const config = require(path.resolve(configPath));
-            Object.assign(cliOptions, config);
-        } else {
-            EC.logRed(`Not found config: ${configPath}`);
+        const configOptions = await resolveConfigOptions(configPath);
+        if (configOptions) {
+            cliOptions = {
+                ... configOptions,
+                ... cliOptions
+            };
         }
     }
 
@@ -46,9 +100,9 @@ const initOptions = (cliOptions) => {
 
 const executeCommand = async (command, cliOptions) => {
 
-    const options = initOptions(cliOptions);
+    const options = await initOptions(cliOptions);
 
-    console.log('Execute:', EC.cyan(command));
+    Util.logInfo(`Execute: ${EC.cyan(command)}`);
     // console.log(options);
 
     const nodeV8CoverageDir = path.resolve(options.outputDir, '.v8-coverage');
@@ -82,6 +136,9 @@ const executeCommand = async (command, cliOptions) => {
             const json = JSON.parse(content);
             let coverageList = json.result;
 
+            // for node sourcemap
+            const sourceMapCache = json['source-map-cache'] || {};
+
             // filter node internal files
             coverageList = coverageList.filter((entry) => entry.url && entry.url.startsWith('file:'));
 
@@ -90,11 +147,28 @@ const executeCommand = async (command, cliOptions) => {
             }
             // attached source content
             coverageList.forEach((entry) => {
+                // source content
                 const filePath = fileURLToPath(entry.url);
                 if (fs.existsSync(filePath)) {
                     entry.source = fs.readFileSync(filePath).toString('utf8');
-                } else {
-                    EC.logRed('not found file', Util.relativePath(filePath));
+                }
+
+                // sourcemap data
+                const sourcemapData = sourceMapCache[entry.url];
+                if (sourcemapData) {
+                    if (sourcemapData.data) {
+                        entry.sourceMap = resolveSourceMap(sourcemapData.data, entry.url);
+                    }
+                    // sourcemapData.lineLengths just for fake source file (can not parse to AST)
+                    if (!entry.source && sourcemapData.lineLengths) {
+                        // get runtime code with ts-node
+                        let source = '';
+                        sourcemapData.lineLengths.forEach((length) => {
+                            source += `${''.padEnd(length, '*')}\n`;
+                        });
+                        entry.fake = true;
+                        entry.source = source;
+                    }
                 }
             });
 
@@ -118,18 +192,23 @@ program
     .description('CLI to generate coverage reports')
     .version(version)
     .argument('<command>', 'command to execute')
-    .option('-c, --config <path>', 'config path for options')
+    .option('-c, --config <path>', 'custom config path')
     .option('-o, --outputDir <dir>', 'output dir for reports')
     .option('-r, --reports <name[,name]>', 'coverage reports to use')
     .option('-n, --name <name>', 'report name for title')
     .option('-i, --inputDir <dir>', 'input dir for merging raw files')
 
+    .option('--entryFilter <pattern>', 'entry url filter')
+    .option('--sourceFilter <pattern>', 'source path filter')
+
     .option('--outputFile <path>', 'output file for v8 report')
     .option('--inline', 'inline html for v8 report')
     .option('--assetsPath <path>', 'assets path if not inline')
 
     .option('--lcov', 'generate lcov.info file')
 
+    .option('--logging <logging>', 'off, error, info, debug')
+
     .action((command, cliOptions) => {
         executeCommand(command, cliOptions);
     });

package/lib/converter/collect-source-maps.js

@@ -67,14 +67,14 @@ const getSourceMapUrl = (content, url) => {
     }
 };
 
-const resolveSourcesContent = async (sources, url) => {
+const resolveSourcesContent = (sources, url) => {
     const list = [];
     for (const file of sources) {
         const sourceUrl = Util.resolveUrl(file, url);
         if (sourceUrl) {
             const sourcePath = sourceUrl.toString();
             if (sourcePath.startsWith('file:')) {
-                const content = await Util.readFile(path.resolve(fileURLToPath(sourcePath)));
+                const content = Util.readFileSync(path.resolve(fileURLToPath(sourcePath)));
                 list.push(content);
                 continue;
             }
@@ -86,7 +86,7 @@ const resolveSourcesContent = async (sources, url) => {
     }
 };
 
-const resolveSourceMap = async (data, url) => {
+const resolveSourceMap = (data, url) => {
     if (!data) {
         return;
     }
@@ -104,7 +104,7 @@ const resolveSourceMap = async (data, url) => {
     }
 
     // load sources content by sources
-    const contents = await resolveSourcesContent(sources, url);
+    const contents = resolveSourcesContent(sources, url);
     if (contents) {
         data.sourcesContent = contents;
         return data;
@@ -164,7 +164,7 @@ const collectSourceMaps = async (v8list, options) => {
             // from inline sync
             const smc = convertSourceMap.fromSource(source);
             if (smc) {
-                sourceData.sourceMap = await resolveSourceMap(smc.sourcemap, url);
+                sourceData.sourceMap = resolveSourceMap(smc.sourcemap, url);
                 smList.push({
                     url,
                     inline: true
@@ -195,7 +195,7 @@ const collectSourceMaps = async (v8list, options) => {
         const { url } = sourceData;
         const data = await loadSourceMap(sourceMapUrl);
         if (data) {
-            sourceData.sourceMap = await resolveSourceMap(data, url);
+            sourceData.sourceMap = resolveSourceMap(data, url);
             smList.push({
                 url,
                 sourceMapUrl
@@ -208,4 +208,7 @@ const collectSourceMaps = async (v8list, options) => {
 
 };
 
-module.exports = collectSourceMaps;
+module.exports = {
+    collectSourceMaps,
+    resolveSourceMap
+};

package/lib/converter/converter.js

@@ -15,7 +15,7 @@ const {
     sortRanges, dedupeCountRanges, mergeRangesWith
 } = require('../utils/dedupe.js');
 const { getSourceType, initSourceMapSourcePath } = require('../utils/source-path.js');
-const { decode } = require('../packages/monocart-coverage-vendor.js');
+const { decode, minimatch } = require('../packages/monocart-coverage-vendor.js');
 
 const InfoBranch = require('./info-branch.js');
 const InfoFunction = require('./info-function.js');
@@ -838,13 +838,25 @@ const getOriginalDecodedMappings = (originalDecodedMap, sourceIndex, locator) =>
 
 // ========================================================================================================
 
+const getSourceFilter = (options) => {
+    const sourceFilter = options.sourceFilter;
+    if (typeof sourceFilter === 'function') {
+        return sourceFilter;
+    }
+
+    if (sourceFilter && typeof sourceFilter === 'string') {
+        return (sourcePath) => {
+            return minimatch(sourcePath, sourceFilter);
+        };
+    }
+
+    return () => true;
+};
+
 const initOriginalList = (state, originalDecodedMap, options) => {
 
     // source filter
-    let sourceFilter = options.sourceFilter;
-    if (typeof sourceFilter !== 'function') {
-        sourceFilter = () => true;
-    }
+    const sourceFilter = getSourceFilter(options);
 
     // create original content mappings
     const originalStateMap = new Map();
@@ -855,8 +867,10 @@ const initOriginalList = (state, originalDecodedMap, options) => {
 
         // filter
         if (!sourceFilter(sourcePath)) {
+            // console.log('-', sourcePath);
             return;
         }
+        // console.log(sourcePath);
 
         // console.log(`add source: ${k}`);
         const sourceContent = sourcesContent[sourceIndex];

package/lib/index.d.ts

@@ -198,9 +198,14 @@ declare namespace MCR {
         /** {string|string[]} input raw dir(s) */
         inputDir?: string | string[];
 
-        /** {string} v8 or html for istanbul by default
-        * {array} multiple reports with options
-        * v8 report or istanbul supported reports */
+        /** 
+         * 
+         * {string} 'v8', 'v8,console-details'
+         * 
+         * {array} ['v8'], ['v8', ['console-details', { skipPercent: 80 }]]
+         * 
+         * By default, `v8` for V8 data, `html` for Istanbul data
+        */
         reports?: string | ReportDescription[];
 
         /** {string} Report name. Defaults to "Coverage Report". */
@@ -213,11 +218,21 @@ declare namespace MCR {
         /** (V8 only) {string} Assets path if not inline. Defaults to "./assets" */
         assetsPath?: string;
 
-        /** (V8 only) {function} A filter function to execute for each element in the V8 list. */
-        entryFilter?: (entry: V8CoverageEntry) => boolean;
-
-        /** (V8 only) {function} A filter function to execute for each element in the sources which unpacked from the source map. */
-        sourceFilter?: (sourcePath: string) => boolean;
+        /** (V8 only) 
+         * 
+         * {string} `minimatch` pattern for entry url; multiple patterns: "{pattern1,pattern2}";
+         * 
+         * {function} A filter function for each entry file in the V8 list.
+         * */
+        entryFilter?: string | ((entry: V8CoverageEntry) => boolean);
+
+        /** (V8 only) 
+         * 
+         * {string} `minimatch` pattern for source path; multiple patterns: "{pattern1,pattern2}";
+         * 
+         * {function} A filter function for each source path when the source is unpacked from the source map. 
+         * */
+        sourceFilter?: string | ((sourcePath: string) => boolean);
 
         /** (V8 only) {boolean} Enable/Disable ignoring uncovered codes with the special comments: v8 ignore next/next N/start/stop */
         v8Ignore?: boolean;