monocart-coverage-reports 2.8.4 → 2.8.6

package/lib/generate.js

@@ -21,7 +21,6 @@ const { getGroupedRows } = require('./utils/snapshot.js');
 
 // maybe v8 or to istanbul reports
 const generateV8ListReports = async (v8list, coverageData, fileSources, options) => {
-    const time_start = Date.now();
     let istanbulReportPath;
     // v8 to istanbul reports
     if (options.reportGroup.istanbul) {
@@ -32,7 +31,6 @@ const generateV8ListReports = async (v8list, coverageData, fileSources, options)
     // v8 reports and v8 coverage results
     // could be no v8 or v8-json, but requires v8 coverage results
     const v8CoverageResults = await saveV8Report(v8list, options, istanbulReportPath);
-    Util.logTime('- saved coverage reports', time_start);
     return v8CoverageResults;
 };
 
@@ -434,9 +432,15 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
     // v8list
     if (dataType === 'v8') {
         // merge v8list first
+        const t1 = Date.now();
         const v8list = await mergeV8Coverage(dataList, sourceCache, options);
+        Util.logTime('┌ [generate] merged v8 coverage data', t1);
         // console.log('after merge', v8list.map((it) => it.url));
+
+        const t2 = Date.now();
         const results = convertV8List(v8list, options);
+        Util.logTime('┌ [generate] converted coverage data', t2);
+
         const {
             v8DataList, coverageData, fileSources
         } = results;
@@ -444,9 +448,12 @@ const getCoverageResults = async (dataList, sourceCache, options) => {
     }
 
     // istanbul data
+    const t3 = Date.now();
     const istanbulData = mergeIstanbulCoverage(dataList);
     const { coverageData, fileSources } = initIstanbulData(istanbulData, options);
-    return saveIstanbulReports(coverageData, fileSources, options);
+    Util.logTime('┌ [generate] prepared istanbul coverage data', t3);
+    const results = await saveIstanbulReports(coverageData, fileSources, options);
+    return results;
 };
 
 const generateCoverageReports = async (dataList, sourceCache, options) => {
@@ -468,11 +475,13 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
         for (const reportName of bothReports) {
             const reportOptions = bothGroup[reportName];
             const buildInHandler = buildInBothReports[reportName];
+            const t1 = Date.now();
             if (buildInHandler) {
                 await buildInHandler(coverageResults, reportOptions, options);
             } else {
                 await Util.runCustomReporter(reportName, coverageResults, reportOptions, options);
             }
+            Util.logTime(`┌ [generate] saved report: ${reportName}`, t1);
         }
     }
 
@@ -663,28 +672,111 @@ const getEmptyData = (all, dataList) => {
 
 // ========================================================================================================
 
+const getInputList = (mcr) => {
+    // get input dirs
+    const { inputDir, cacheDir } = mcr.options;
 
-const getInputData = async (inputList, all, cacheDir, addHandler) => {
-    const dataList = [];
-    const sourceCache = new Map();
+    const inputDirs = Util.toList(inputDir, ',');
+
+    const inputList = inputDirs.filter((dir) => {
+        const hasDir = fs.existsSync(dir);
+        if (!hasDir) {
+            // could be empty
+            Util.logInfo(`Not found coverage data dir: ${Util.relativePath(dir)}`);
+        }
+        return hasDir;
+    });
 
-    const addJsonData = async (dir, filename) => {
-        const isCoverage = filename.startsWith('coverage-');
-        const isSource = filename.startsWith('source-');
-        if (isCoverage || isSource) {
+    if (mcr.hasCache()) {
+        inputList.push(cacheDir);
+    }
+
+    return inputList;
+};
+
+const addJsonData = async (mcr, dataList, sourceCache, dir, filename) => {
+    const isCoverage = filename.startsWith('coverage-');
+    const isSource = filename.startsWith('source-');
+    if (isCoverage || isSource) {
+        let json;
+        if (mcr.fileCache.has(filename)) {
+            json = mcr.fileCache.get(filename);
+        } else {
             const content = await Util.readFile(path.resolve(dir, filename));
             if (content) {
-                const json = JSON.parse(content);
-                if (isCoverage) {
-                    dataList.push(json);
-                } else {
+                json = JSON.parse(content);
+            }
+        }
+        if (json) {
+            if (isCoverage) {
+                dataList.push(json);
+            } else {
+                sourceCache.set(json.id, json);
+            }
+        }
+    }
+};
+
+const addEmptyData = async (mcr, dataList, sourceCache) => {
+
+    const { all, cacheDir } = mcr.options;
+    // 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) {
+        return;
+    }
+
+    let files = 0;
+    if (Util.isList(emptyData)) {
+        files = emptyData.length;
+    } else {
+        files = Object.keys(emptyData).length;
+    }
+
+    Util.logDebug(`added all files with empty coverage: ${EC.yellow(files)}`);
+    const coverageResults = await mcr.add(emptyData);
+    // after `add`
+    if (!coverageResults) {
+        return;
+    }
+
+    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 { cacheName, cachePath } = Util.getCacheFileInfo('source', id, cacheDir);
+            if (mcr.fileCache.has(cacheName)) {
+                const json = mcr.fileCache.get(cacheName);
+                sourceCache.set(json.id, json);
+            } else {
+                const content = Util.readFileSync(cachePath);
+                if (content) {
+                    const json = JSON.parse(content);
                     sourceCache.set(json.id, json);
                 }
             }
-        }
-    };
+        });
+    }
+};
+
+const getInputData = async (mcr) => {
+
+    const inputList = getInputList(mcr);
+    // console.log('input list', inputList);
+
+    const dataList = [];
+    const sourceCache = new Map();
 
     for (const dir of inputList) {
+
         const allFiles = fs.readdirSync(dir);
         if (!allFiles.length) {
             continue;
@@ -692,38 +784,17 @@ const getInputData = async (inputList, all, cacheDir, addHandler) => {
         for (const filename of allFiles) {
             // only json file
             if (filename.endsWith('.json')) {
-                await addJsonData(dir, filename);
+                await addJsonData(mcr, dataList, sourceCache, dir, filename);
             }
         }
     }
 
-    // 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) {
-        Util.logDebug(`added empty files for all: ${EC.yellow(emptyData.length)}`);
-        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);
-                    }
-                });
-            }
-        }
+    await addEmptyData(mcr, dataList, sourceCache);
+
+    if (!dataList.length) {
+        const dirs = inputList.map((dir) => Util.relativePath(dir));
+        Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
+        return;
     }
 
     return {
@@ -783,14 +854,11 @@ const resolveEntrySourceMap = (entry, sourceMapCache) => {
     }
 };
 
-const readCoverageData = (filePath, entryFilter, sourceCache) => {
+const readCoverageData = (item, entryFilter, sourceCache) => {
 
-    const content = fs.readFileSync(filePath).toString('utf-8');
-    if (!content) {
-        return;
-    }
+    const json = item.json;
 
-    const json = JSON.parse(content);
+    // raw v8 json
     let coverageData = json.result;
     if (!Util.isList(coverageData)) {
         return;
@@ -818,7 +886,7 @@ const readCoverageData = (filePath, entryFilter, sourceCache) => {
     return coverageData;
 };
 
-const readFromDir = async (dir, entryFilter, addHandler) => {
+const readFromDir = async (mcr, dir) => {
 
     if (!dir || !fs.existsSync(dir)) {
         Util.logInfo(`Not found V8 coverage dir: ${dir}`);
@@ -826,41 +894,63 @@ const readFromDir = async (dir, entryFilter, addHandler) => {
     }
 
     const files = fs.readdirSync(dir);
-    if (!files.length) {
+    const list = [];
+    files.forEach((filename) => {
+        if (filename.startsWith('coverage-')) {
+            list.push({
+                type: 'coverage',
+                filename
+            });
+            return;
+        }
+        if (filename.startsWith('source-')) {
+            list.push({
+                type: 'source',
+                filename
+            });
+        }
+    });
+
+    if (!list.length) {
         Util.logInfo(`No coverage files in the dir: ${dir}`);
         return;
     }
 
-    const coverageFiles = [];
+    const contentList = await Promise.all(list.map((it) => Util.readFile(path.resolve(dir, it.filename))));
     const sourceCache = {};
-    files.forEach((filename) => {
-        const isCoverage = filename.startsWith('coverage-');
-        if (isCoverage) {
-            coverageFiles.push(filename);
+    const coverageFiles = [];
+
+    contentList.forEach((content, i) => {
+        if (!content) {
             return;
         }
-        const isSource = filename.startsWith('source-');
-        if (isSource) {
-            const filePath = path.resolve(dir, filename);
-            const content = fs.readFileSync(filePath).toString('utf-8');
-            if (content) {
-                const json = JSON.parse(content);
-                if (json.url) {
-                    sourceCache[json.url] = json;
-                }
+        const json = JSON.parse(content);
+        if (!json) {
+            return;
+        }
+        const item = list[i];
+        if (item.type === 'source') {
+            if (json.url) {
+                sourceCache[json.url] = json;
             }
+        } else {
+            item.json = json;
+            coverageFiles.push(item);
         }
     });
 
-    // filter before adding
-    for (const filename of coverageFiles) {
-        const filePath = path.resolve(dir, filename);
-        const coverageData = readCoverageData(filePath, entryFilter, sourceCache);
+    const entryFilter = mcr.getEntryFilter();
+
+    const results = [];
+    for (const item of coverageFiles) {
+        const coverageData = readCoverageData(item, entryFilter, sourceCache);
         if (coverageData) {
-            await addHandler(coverageData);
+            const res = await mcr.add(coverageData);
+            results.push(res);
         }
     }
 
+    return results;
 };
 
 module.exports = {

package/lib/index.d.ts

@@ -128,7 +128,7 @@ declare namespace MCR {
         path: string;
         type: "v8" | "istanbul";
         data: any;
-    } | undefined;
+    };
 
 
     export interface MetricsSummary {
@@ -204,7 +204,7 @@ declare namespace MCR {
         watermarks: Watermarks;
         summary: CoverageSummary;
         files: CoverageFile[];
-    } | undefined;
+    };
 
     export type LoggingType = "off" | "error" | "info" | "debug";
     export interface CoverageReportOptions {
@@ -329,7 +329,7 @@ declare namespace MCR {
         onEntry?: (entry: V8CoverageEntry) => Promise<void>;
 
         /** {function} onEnd hook */
-        onEnd?: (coverageResults: CoverageResults) => Promise<void>;
+        onEnd?: (coverageResults: CoverageResults | undefined) => Promise<void>;
 
         [key: string]: any;
     }
@@ -357,7 +357,7 @@ declare namespace MCR {
         /** add coverage data
          * 
          * @param coverageData {array} V8 format, {object} Istanbul format */
-        add: (coverageData: any[] | any) => Promise<AddedResults>;
+        add: (coverageData: any[] | any) => Promise<AddedResults | undefined>;
 
         /**
          * add V8 coverage from a dir
@@ -366,7 +366,7 @@ declare namespace MCR {
         addFromDir: (dir: string) => Promise<void>;
 
         /** generate report */
-        generate: () => Promise<CoverageResults>;
+        generate: () => Promise<CoverageResults | undefined>;
 
         /** check if cache exists */
         hasCache: () => boolean;

package/lib/index.js

@@ -53,6 +53,7 @@ class CoverageReport {
             ... options
         };
         this.initOptions();
+        this.fileCache = new Map();
     }
 
     initOptions(force) {
@@ -97,9 +98,6 @@ class CoverageReport {
         }
 
         const dataId = Util.uid();
-        const dataName = `coverage-${dataId}.json`;
-        const dataPath = path.resolve(this.options.cacheDir, dataName);
-
         const results = {
             id: dataId
         };
@@ -107,15 +105,16 @@ class CoverageReport {
         if (Array.isArray(data)) {
             results.type = 'v8';
             // could be empty list after entryFilter
-            results.data = await initV8ListAndSourcemap(data, this.options);
+            results.data = await initV8ListAndSourcemap(this, data);
         } else {
             results.type = 'istanbul';
             results.data = data;
         }
 
-        // save data to cache dir
-        const dataContent = JSON.stringify(results);
-        await Util.writeFile(dataPath, dataContent);
+        // save data to cache
+        const { cacheName, cachePath } = Util.getCacheFileInfo('coverage', dataId, this.options.cacheDir);
+        this.fileCache.set(cacheName, results);
+        await Util.writeFile(cachePath, JSON.stringify(results));
 
         Util.logTime(`added coverage data: ${results.type}`, time_start);
 
@@ -123,11 +122,11 @@ class CoverageReport {
     }
 
     // add coverage from dir
-    addFromDir(dir) {
-        const entryFilter = this.getEntryFilter();
-        return readFromDir(dir, entryFilter, (coverageData) => {
-            return this.add(coverageData);
-        });
+    async addFromDir(dir) {
+        const time_start = Date.now();
+        const results = await readFromDir(this, dir);
+        Util.logTime(`added from dir: ${dir}`, time_start);
+        return results;
     }
 
     // generate report
@@ -137,34 +136,13 @@ class CoverageReport {
 
         this.initOptions();
 
-        const {
-            all, inputDir, cacheDir
-        } = this.options;
-
-        const inputDirs = Util.toList(inputDir, ',');
-        if (this.hasCache()) {
-            inputDirs.push(cacheDir);
-        }
-
-        const inputList = inputDirs.filter((dir) => {
-            const hasDir = fs.existsSync(dir);
-            if (!hasDir) {
-                // could be empty
-                Util.logInfo(`Not found coverage data dir: ${Util.relativePath(dir)}`);
-            }
-            return hasDir;
-        });
-
-        const { dataList, sourceCache } = await getInputData(inputList, all, cacheDir, (emptyData) => {
-            return this.add(emptyData);
-        });
-
-        if (!dataList.length) {
-            const dirs = inputList.map((dir) => Util.relativePath(dir));
-            Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
+        const inputData = await getInputData(this);
+        if (!inputData) {
             return;
         }
 
+        const { dataList, sourceCache } = inputData;
+
         // empty output dir except cache dir before generate reports
         const outputDir = this.options.outputDir;
 
@@ -179,19 +157,21 @@ class CoverageReport {
             });
         }
 
+        Util.logTime('┌ [generate] prepared coverage data', time_start);
+
         const coverageResults = await generateCoverageReports(dataList, sourceCache, this.options);
 
         if (this.logging !== 'debug') {
-            Util.rmSync(cacheDir);
+            Util.rmSync(this.options.cacheDir);
         }
 
-        Util.logTime(`generated coverage reports: ${EC.cyan(coverageResults.reportPath)}`, time_start);
-
         const onEnd = this.options.onEnd;
         if (typeof onEnd === 'function') {
             await onEnd.call(this, coverageResults);
         }
 
+        Util.logTime(`generated coverage reports: ${EC.cyan(coverageResults.reportPath)}`, time_start);
+
         return coverageResults;
     }
 

package/lib/istanbul/istanbul.js

@@ -89,9 +89,11 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
 
     const istanbulGroup = options.reportGroup.istanbul;
     Object.keys(istanbulGroup).forEach((reportName) => {
+        const t1 = Date.now();
         const reportOptions = istanbulGroup[reportName];
         const report = istanbulReports.create(reportName, reportOptions);
         report.execute(context);
+        Util.logTime(`┌ [generate] saved report: ${reportName}`, t1);
     });
 
     // add watermarks and color