monocart-coverage-reports 2.8.6 → 2.9.0

package/lib/generate.js

@@ -16,6 +16,7 @@ const { resolveSourceMap } = require('./converter/collect-source-maps.js');
 
 const { minimatch } = require('./packages/monocart-coverage-vendor.js');
 const { getGroupedRows } = require('./utils/snapshot.js');
+const generateMarkdownGrid = require('./utils/markdown.js');
 
 // ========================================================================================================
 
@@ -90,8 +91,11 @@ const getReportGroup = (reports, lcov, dataType) => {
 
         // both
         'codecov': 'both',
+        'codacy': 'both',
         'console-details': 'both',
         'console-summary': 'both',
+        'markdown-details': 'both',
+        'markdown-summary': 'both',
         'raw': 'both'
     };
 
@@ -128,13 +132,6 @@ const getReportGroup = (reports, lcov, dataType) => {
 
 // ========================================================================================================
 
-const pFormatter = (v, row, column) => {
-    if (typeof v === 'number') {
-        return Util.getColorStrByStatus(Util.PSF(v, 100, 2), row.status);
-    }
-    return v;
-};
-
 const nFormatter = (v) => {
     if (typeof v === 'number') {
         return Util.NF(v);
@@ -142,7 +139,7 @@ const nFormatter = (v) => {
     return v;
 };
 
-const getRowData = (rowName, summary, metrics) => {
+const getRowData = (rowName, summary, metrics, color) => {
     const summaryRow = {};
     let lowest = {
         pct: 100,
@@ -157,7 +154,7 @@ const getRowData = (rowName, summary, metrics) => {
         if (typeof percent !== 'number') {
             return;
         }
-        summaryRow[k] = Util.getColorStrByStatus(Util.PSF(percent, 100, 2), s.status);
+        summaryRow[k] = Util.getColorStrByStatus(Util.PSF(percent, 100, 2), s.status, color);
         if (percent < lowest.pct) {
             lowest = s;
         }
@@ -167,65 +164,7 @@ const getRowData = (rowName, summary, metrics) => {
     return summaryRow;
 };
 
-const getUncoveredLines = (file) => {
-    const lines = [];
-
-    const dataLines = file.data.lines;
-
-    let startLine;
-    let endLine;
-
-    const addLines = () => {
-        if (!startLine) {
-            return;
-        }
-        if (endLine) {
-            // range
-            const link = startLine.color === 'yellow' && endLine.color === 'yellow' ? EC.yellow('-') : EC.red('-');
-            lines.push(EC[startLine.color](startLine.line) + link + EC[endLine.color](endLine.line));
-            startLine = null;
-            endLine = null;
-        } else {
-            // only start
-            lines.push(EC[startLine.color](startLine.line));
-            startLine = null;
-        }
-    };
-
-    const setLines = (line, color) => {
-        if (startLine) {
-            endLine = {
-                line,
-                color
-            };
-            return;
-        }
-        startLine = {
-            line,
-            color
-        };
-    };
-
-    Object.keys(dataLines).forEach((line) => {
-        const count = dataLines[line];
-        if (count === 0) {
-            setLines(line, 'red');
-            return;
-        }
-        // 0 < count < 1
-        if (typeof count === 'string') {
-            setLines(line, 'yellow');
-            return;
-        }
-        // count >= 1
-        addLines();
-    });
-    addLines();
-
-    return lines.join(',');
-};
-
-const getDetailsRows = (files, metrics, cdOptions) => {
+const getDetailsRows = (files, metrics, cdOptions, color) => {
 
     const skipPercent = cdOptions.skipPercent;
     if (typeof skipPercent === 'number' && skipPercent > 0) {
@@ -250,8 +189,8 @@ const getDetailsRows = (files, metrics, cdOptions) => {
         }
 
         const { sourcePath, summary } = file;
-        const fileRow = getRowData(sourcePath, summary, metrics);
-        fileRow.uncoveredLines = getUncoveredLines(file);
+        const fileRow = getRowData(sourcePath, summary, metrics, color);
+        fileRow.uncoveredLines = Util.getUncoveredLines(file.data.lines, color);
         flatRows.push(fileRow);
     });
 
@@ -280,6 +219,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,
@@ -296,11 +271,13 @@ const handleConsoleDetailsReport = (reportData, reportOptions, options) => {
         Util.logInfo(EC.cyan(name));
     }
 
+    const color = 'ansicode';
+
     const metrics = Util.getMetrics(cdOptions.metrics, type);
-    const rows = getDetailsRows(files, metrics, cdOptions);
-    const summaryRow = getRowData('Summary', summary, metrics);
+    const rows = getDetailsRows(files, metrics, cdOptions, color);
+    const summaryRow = getRowData('Summary', summary, metrics, color);
     if (summaryRow.nameStatus) {
-        summaryRow.name = Util.getColorStrByStatus(summaryRow.name, summaryRow.nameStatus);
+        summaryRow.name = Util.getColorStrByStatus(summaryRow.name, summaryRow.nameStatus, color);
     }
     // no rows if skipped all by skipPercent
     if (rows.length) {
@@ -335,6 +312,41 @@ const handleConsoleDetailsReport = (reportData, reportOptions, options) => {
     });
 };
 
+const getSummaryColumns = (color) => {
+
+    const columns = [{
+        id: 'name',
+        name: 'Name'
+    }, {
+        id: 'pct',
+        name: 'Coverage %',
+        align: 'right',
+        formatter: (v, row, column) => {
+            if (typeof v === 'number') {
+                return Util.getColorStrByStatus(Util.PSF(v, 100, 2), row.status, color);
+            }
+            return v;
+        }
+    }, {
+        id: 'covered',
+        name: 'Covered',
+        align: 'right',
+        formatter: nFormatter
+    }, {
+        id: 'uncovered',
+        name: 'Uncovered',
+        align: 'right',
+        formatter: nFormatter
+    }, {
+        id: 'total',
+        name: 'Total',
+        align: 'right',
+        formatter: nFormatter
+    }];
+
+    return columns;
+};
+
 const handleConsoleSummaryReport = (reportData, reportOptions, options) => {
 
     const csOptions = {
@@ -359,35 +371,136 @@ const handleConsoleSummaryReport = (reportData, reportOptions, options) => {
         };
     });
 
+    const columns = getSummaryColumns('ansicode');
+
+    CG({
+        columns,
+        rows
+    });
+};
+
+const handleMarkdownDetailsReport = async (reportData, reportOptions, options) => {
+    const mdOptions = {
+        baseUrl: '',
+        // unicode, html, or empty for no color
+        color: 'unicode',
+        skipPercent: 0,
+        metrics: [],
+        outputFile: 'coverage-details.md',
+        ... reportOptions
+    };
+
+    const color = Util.normalizeColorType(mdOptions.color);
+    const baseUrl = mdOptions.baseUrl;
+
+    const mdPath = path.resolve(options.outputDir, mdOptions.outputFile);
+
+    const metrics = Util.getMetrics(mdOptions.metrics, reportData.type);
+
+    let files = reportData.files;
+    const skipPercent = mdOptions.skipPercent;
+    if (typeof skipPercent === 'number' && skipPercent > 0) {
+        files = files.filter((file) => {
+            const { summary } = file;
+            for (const k of metrics) {
+                const percent = summary[k].pct;
+                if (typeof percent === 'number' && percent < skipPercent) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+
+    const rows = [];
+    files.forEach((file) => {
+
+        // do NOT add debug file
+        if (file.debug) {
+            return;
+        }
+
+        const { sourcePath, summary } = file;
+
+        const fileRow = getRowData(sourcePath, summary, metrics, color);
+        if (fileRow.nameStatus) {
+            const nameColor = baseUrl && color === 'tex' ? '' : color;
+            fileRow.name = Util.getColorStrByStatus(fileRow.name, fileRow.nameStatus, nameColor);
+        }
+        if (baseUrl) {
+            fileRow.name = `[${fileRow.name}](${baseUrl + sourcePath})`;
+        }
+
+        fileRow.uncoveredLines = Util.getUncoveredLines(file.data.lines, color);
+        rows.push(fileRow);
+    });
+
+    const summaryRow = getRowData('Summary', reportData.summary, metrics, color);
+    if (summaryRow.nameStatus) {
+        summaryRow.name = Util.getColorStrByStatus(summaryRow.name, summaryRow.nameStatus, color);
+    }
+    rows.push(summaryRow);
+
     const columns = [{
         id: 'name',
         name: 'Name'
-    }, {
-        id: 'pct',
-        name: 'Coverage %',
-        align: 'right',
-        formatter: pFormatter
-    }, {
-        id: 'covered',
-        name: 'Covered',
-        align: 'right',
-        formatter: nFormatter
-    }, {
-        id: 'uncovered',
-        name: 'Uncovered',
-        align: 'right',
-        formatter: nFormatter
-    }, {
-        id: 'total',
-        name: 'Total',
-        align: 'right',
-        formatter: nFormatter
+    }, ... metrics.map((m) => {
+        return {
+            id: m,
+            name: Util.capitalizeFirstLetter(m),
+            align: 'right'
+        };
+    }), {
+        id: 'uncoveredLines',
+        name: 'Uncovered Lines'
     }];
 
-    CG({
+    const markdownGrid = generateMarkdownGrid({
+        options: {
+            name: reportData.name
+        },
         columns,
         rows
     });
+
+    await Util.writeFile(mdPath, markdownGrid);
+    return Util.relativePath(mdPath);
+};
+
+const handleMarkdownSummaryReport = async (reportData, reportOptions, options) => {
+    const msOptions = {
+        // unicode, html, or empty for no color
+        color: 'unicode',
+        metrics: [],
+        outputFile: 'coverage-summary.md',
+        ... reportOptions
+    };
+
+    const color = Util.normalizeColorType(msOptions.color);
+
+    const mdPath = path.resolve(options.outputDir, msOptions.outputFile);
+
+    const metrics = Util.getMetrics(msOptions.metrics, reportData.type);
+
+    const rows = metrics.map((k) => {
+        return {
+            ... reportData.summary[k],
+            name: Util.capitalizeFirstLetter(k)
+        };
+    });
+
+    const columns = getSummaryColumns(color);
+
+    const markdownGrid = generateMarkdownGrid({
+        options: {
+            name: reportData.name
+        },
+        columns,
+        rows
+    });
+
+    await Util.writeFile(mdPath, markdownGrid);
+    return Util.relativePath(mdPath);
 };
 
 const handleRawReport = (reportData, reportOptions, options) => {
@@ -464,8 +577,11 @@ const generateCoverageReports = async (dataList, sourceCache, options) => {
 
     const buildInBothReports = {
         'codecov': handleCodecovReport,
+        'codacy': handleCodacyReport,
         'console-details': handleConsoleDetailsReport,
         'console-summary': handleConsoleSummaryReport,
+        'markdown-details': handleMarkdownDetailsReport,
+        'markdown-summary': handleMarkdownSummaryReport,
         'raw': handleRawReport
     };
 
@@ -854,9 +970,16 @@ const resolveEntrySourceMap = (entry, sourceMapCache) => {
     }
 };
 
-const readCoverageData = (item, entryFilter, sourceCache) => {
+const readCoverageData = async (dir, filename, entryFilter, sourceCache) => {
 
-    const json = item.json;
+    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;
@@ -886,6 +1009,26 @@ const readCoverageData = (item, entryFilter, sourceCache) => {
     return coverageData;
 };
 
+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)) {
@@ -894,56 +1037,34 @@ const readFromDir = async (mcr, dir) => {
     }
 
     const files = fs.readdirSync(dir);
-    const list = [];
+
+    const coverageList = [];
+    const sourceList = [];
+
     files.forEach((filename) => {
-        if (filename.startsWith('coverage-')) {
-            list.push({
-                type: 'coverage',
-                filename
-            });
-            return;
-        }
-        if (filename.startsWith('source-')) {
-            list.push({
-                type: 'source',
-                filename
-            });
+        // 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);
+            }
         }
     });
 
-    if (!list.length) {
+    if (!coverageList.length) {
         Util.logInfo(`No coverage files in the dir: ${dir}`);
         return;
     }
 
-    const contentList = await Promise.all(list.map((it) => Util.readFile(path.resolve(dir, it.filename))));
-    const sourceCache = {};
-    const coverageFiles = [];
-
-    contentList.forEach((content, i) => {
-        if (!content) {
-            return;
-        }
-        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);
-        }
-    });
+    const sourceCache = await readSourceList(dir, sourceList);
 
     const entryFilter = mcr.getEntryFilter();
 
     const results = [];
-    for (const item of coverageFiles) {
-        const coverageData = readCoverageData(item, entryFilter, sourceCache);
+    for (const filename of coverageList) {
+        const coverageData = await readCoverageData(dir, filename, entryFilter, sourceCache);
         if (coverageData) {
             const res = await mcr.add(coverageData);
             results.push(res);

package/lib/index.d.ts

@@ -44,12 +44,18 @@ declare namespace MCR {
 
     export type ReportDescription =
         ['v8'] | ["v8", {
+            /**
+             * defaults to `index.html`
+             */
             outputFile?: string;
             inline?: boolean;
             assetsPath?: string;
             metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
         }] |
         ['v8-json'] | ["v8-json", {
+            /**
+             * defaults to `coverage-report.json`
+             */
             outputFile?: string;
         }] |
         ['clover'] | ['clover', {
@@ -105,6 +111,15 @@ declare namespace MCR {
             file?: string;
         }] |
         ['codecov'] | ["codecov", {
+            /**
+             * defaults to `codecov.json`
+             */
+            outputFile?: string;
+        }] |
+        ['codacy'] | ["codacy", {
+            /**
+             * defaults to `codacy.json`
+             */
             outputFile?: string;
         }] |
         ['console-summary'] | ['console-summary', {
@@ -115,6 +130,24 @@ declare namespace MCR {
             skipPercent?: number;
             metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
         }] |
+        ['markdown-summary'] | ['markdown-summary', {
+            color: 'unicode' | 'html' | 'tex' | string;
+            metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
+            /**
+             * defaults to `coverage-summary.md`
+             */
+            outputFile?: string;
+        }] |
+        ['markdown-details'] | ['markdown-details', {
+            baseUrl?: string;
+            color: 'unicode' | 'html' | 'tex' | string;
+            skipPercent?: number;
+            metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
+            /**
+             * defaults to `coverage-details.md`
+             */
+            outputFile?: string;
+        }] |
         ['raw'] | ['raw', {
             outputDir?: string;
         }] |
@@ -190,10 +223,23 @@ declare namespace MCR {
             branches?: CoverageRange[];
             functions?: CoverageRange[];
             ignores?: IgnoredRange[];
-            /** codecov json format */
-            lines: {
+            lines?: {
+                /** 
+                 * key: line number;
+                 * number: hits (0 means uncovered);
+                 * string: partial covered 
+                 */
                 [key: string]: number | string;
             };
+            extras?: {
+                /** 
+                 * key: line number;
+                 * b: blank;
+                 * c: comment;
+                 * i: ignored;
+                 */
+                [key: string]: "b" | "c" | "i";
+            }
         }
     }
 
@@ -234,6 +280,9 @@ declare namespace MCR {
         /** {string} base dir for normalizing the relative source path, defaults to cwd */
         baseDir?: string;
 
+        /** {string} coverage data dir, alternative to method `addFromDir()`, defaults to null */
+        dataDir?: string;
+
         /** (V8 only) 
          * 
          * {string} `minimatch` pattern for entry url; 
@@ -413,6 +462,7 @@ declare namespace MCR {
                 functions: string;
                 lines: string;
                 uncoveredLines: string;
+                extras: string;
             }
         }
     }

package/lib/index.js

@@ -136,11 +136,19 @@ class CoverageReport {
 
         this.initOptions();
 
+        const dataDir = this.options.dataDir;
+        if (dataDir) {
+            await this.addFromDir(dataDir);
+        }
+
         const inputData = await getInputData(this);
         if (!inputData) {
             return;
         }
 
+        // GC, no OOM
+        this.fileCache.clear();
+
         const { dataList, sourceCache } = inputData;
 
         // empty output dir except cache dir before generate reports
@@ -161,16 +169,21 @@ class CoverageReport {
 
         const coverageResults = await generateCoverageReports(dataList, sourceCache, this.options);
 
-        if (this.logging !== 'debug') {
-            Util.rmSync(this.options.cacheDir);
-        }
-
         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);
+        // 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-summary.js

@@ -32,12 +32,15 @@ class IstanbulSummary extends ReportBase {
 
         const fileCoverage = node.getFileCoverage();
         const lines = fileCoverage.getLineCoverage();
+        // no extras for istanbul
+        const extras = {};
 
         this.files.push({
             sourcePath,
             summary: fileSummary,
             data: {
-                lines
+                lines,
+                extras
             }
         });
     }