monocart-coverage-reports 2.8.5 → 2.8.7

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;
 };
 
@@ -92,6 +90,7 @@ const getReportGroup = (reports, lcov, dataType) => {
 
         // both
         'codecov': 'both',
+        'codacy': 'both',
         'console-details': 'both',
         'console-summary': 'both',
         'raw': 'both'
@@ -282,6 +281,42 @@ const handleCodecovReport = async (reportData, reportOptions, options) => {
     return Util.relativePath(jsonPath);
 };
 
+const handleCodacyReport = async (reportData, reportOptions, options) => {
+    const codacyOptions = {
+        outputFile: 'codacy.json',
+        ... reportOptions
+    };
+
+    const jsonPath = path.resolve(options.outputDir, codacyOptions.outputFile);
+
+    // https://api.codacy.com/swagger#tocscoveragereport
+    const fileReports = [];
+    reportData.files.forEach((item) => {
+        const { sourcePath, data } = item;
+
+        const coverage = {};
+        for (const [key, value] of Object.entries(data.lines)) {
+            if (typeof value === 'number') {
+                coverage[key] = value;
+            } else {
+                // partial coverage not supported?
+                coverage[key] = 0;
+            }
+        }
+
+        fileReports.push({
+            filename: sourcePath,
+            coverage
+        });
+    });
+    const codacyData = {
+        fileReports
+    };
+
+    await Util.writeFile(jsonPath, JSON.stringify(codacyData));
+    return Util.relativePath(jsonPath);
+};
+
 const handleConsoleDetailsReport = (reportData, reportOptions, options) => {
     const cdOptions = {
         maxCols: 50,
@@ -434,9 +469,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 +485,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) => {
@@ -457,6 +501,7 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
 
     const buildInBothReports = {
         'codecov': handleCodecovReport,
+        'codacy': handleCodacyReport,
         'console-details': handleConsoleDetailsReport,
         'console-summary': handleConsoleSummaryReport,
         'raw': handleRawReport
@@ -468,11 +513,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 +710,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;
+    });
+
+    if (mcr.hasCache()) {
+        inputList.push(cacheDir);
+    }
+
+    return inputList;
+};
 
-    const addJsonData = async (dir, filename) => {
-        const isCoverage = filename.startsWith('coverage-');
-        const isSource = filename.startsWith('source-');
-        if (isCoverage || isSource) {
+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 +822,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 +892,18 @@ const resolveEntrySourceMap = (entry, sourceMapCache) => {
     }
 };
 
-const readCoverageData = (filePath, entryFilter, sourceCache) => {
+const readCoverageData = async (dir, filename, entryFilter, sourceCache) => {
 
-    const content = fs.readFileSync(filePath).toString('utf-8');
+    const content = await Util.readFile(path.resolve(dir, filename));
     if (!content) {
         return;
     }
-
     const json = JSON.parse(content);
+    if (!json) {
+        return;
+    }
+
+    // raw v8 json
     let coverageData = json.result;
     if (!Util.isList(coverageData)) {
         return;
@@ -818,7 +931,27 @@ const readCoverageData = (filePath, entryFilter, sourceCache) => {
     return coverageData;
 };
 
-const readFromDir = async (dir, entryFilter, addHandler) => {
+const readSourceList = async (dir, sourceList) => {
+    const sourceCache = {};
+
+    for (const filename of sourceList) {
+        const content = await Util.readFile(path.resolve(dir, filename));
+        if (!content) {
+            continue;
+        }
+        const json = JSON.parse(content);
+        if (!json) {
+            continue;
+        }
+        if (json.url) {
+            sourceCache[json.url] = json;
+        }
+    }
+
+    return sourceCache;
+};
+
+const readFromDir = async (mcr, dir) => {
 
     if (!dir || !fs.existsSync(dir)) {
         Util.logInfo(`Not found V8 coverage dir: ${dir}`);
@@ -826,41 +959,41 @@ const readFromDir = async (dir, entryFilter, addHandler) => {
     }
 
     const files = fs.readdirSync(dir);
-    if (!files.length) {
-        Util.logInfo(`No coverage files in the dir: ${dir}`);
-        return;
-    }
 
-    const coverageFiles = [];
-    const sourceCache = {};
+    const coverageList = [];
+    const sourceList = [];
+
     files.forEach((filename) => {
-        const isCoverage = filename.startsWith('coverage-');
-        if (isCoverage) {
-            coverageFiles.push(filename);
-            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;
-                }
+        // read all json files
+        if (filename.endsWith('.json')) {
+            // could be source files generated by register hooks
+            if (filename.startsWith('source-')) {
+                sourceList.push(filename);
+            } else {
+                coverageList.push(filename);
             }
         }
     });
 
-    // filter before adding
-    for (const filename of coverageFiles) {
-        const filePath = path.resolve(dir, filename);
-        const coverageData = readCoverageData(filePath, entryFilter, sourceCache);
+    if (!coverageList.length) {
+        Util.logInfo(`No coverage files in the dir: ${dir}`);
+        return;
+    }
+
+    const sourceCache = await readSourceList(dir, sourceList);
+
+    const entryFilter = mcr.getEntryFilter();
+
+    const results = [];
+    for (const filename of coverageList) {
+        const coverageData = await readCoverageData(dir, filename, 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

@@ -107,6 +107,9 @@ declare namespace MCR {
         ['codecov'] | ["codecov", {
             outputFile?: string;
         }] |
+        ['codacy'] | ["codacy", {
+            outputFile?: string;
+        }] |
         ['console-summary'] | ['console-summary', {
             metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
         }] |
@@ -190,7 +193,7 @@ declare namespace MCR {
             branches?: CoverageRange[];
             functions?: CoverageRange[];
             ignores?: IgnoredRange[];
-            /** codecov json format */
+            /** common json format */
             lines: {
                 [key: string]: number | string;
             };

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,33 +136,15 @@ class CoverageReport {
 
         this.initOptions();
 
-        const {
-            all, inputDir, cacheDir
-        } = this.options;
-
-        const inputDirs = Util.toList(inputDir, ',');
-        if (this.hasCache()) {
-            inputDirs.push(cacheDir);
+        const inputData = await getInputData(this);
+        if (!inputData) {
+            return;
         }
 
-        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);
-        });
+        // GC, no OOM
+        this.fileCache.clear();
 
-        if (!dataList.length) {
-            const dirs = inputList.map((dir) => Util.relativePath(dir));
-            Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
-            return;
-        }
+        const { dataList, sourceCache } = inputData;
 
         // empty output dir except cache dir before generate reports
         const outputDir = this.options.outputDir;
@@ -179,19 +160,26 @@ class CoverageReport {
             });
         }
 
-        const coverageResults = await generateCoverageReports(dataList, sourceCache, this.options);
-
-        if (this.logging !== 'debug') {
-            Util.rmSync(cacheDir);
-        }
+        Util.logTime('┌ [generate] prepared coverage data', time_start);
 
-        Util.logTime(`generated coverage reports: ${EC.cyan(coverageResults.reportPath)}`, time_start);
+        const coverageResults = await generateCoverageReports(dataList, sourceCache, this.options);
 
         const onEnd = this.options.onEnd;
         if (typeof onEnd === 'function') {
             await onEnd.call(this, coverageResults);
         }
 
+        // remove cache dir after finished
+        if (!Util.isDebug()) {
+            Util.rmSync(this.options.cacheDir);
+        }
+
+        let reportPath = '';
+        if (coverageResults.reportPath) {
+            reportPath = EC.cyan(coverageResults.reportPath);
+        }
+        Util.logTime(`generated coverage reports: ${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