monocart-coverage-reports 2.9.3 → 2.10.1

package/lib/platform/share.js

@@ -26,6 +26,22 @@ const Util = {
         return s.padStart(l, '0');
     },
 
+    isNum: function(num) {
+        if (typeof num !== 'number' || isNaN(num)) {
+            return false;
+        }
+        const isInvalid = function(n) {
+            if (n === Number.MAX_VALUE || n === Number.MIN_VALUE || n === Number.NEGATIVE_INFINITY || n === Number.POSITIVE_INFINITY) {
+                return true;
+            }
+            return false;
+        };
+        if (isInvalid(num)) {
+            return false;
+        }
+        return true;
+    },
+
     toNum: function(num, toInt) {
         if (typeof (num) !== 'number') {
             num = parseFloat(num);
@@ -322,6 +338,12 @@ const Util = {
         return lines;
     },
 
+    initLineCoverage: (lineItem) => {
+        lineItem.coveredCount = 1;
+        lineItem.uncoveredEntire = null;
+        lineItem.uncoveredPieces = [];
+    },
+
     updateLinesCoverage: (lines, count, lineMap) => {
         lines.forEach((it) => {
             const lineItem = lineMap.get(it.line);

package/lib/reports/codacy.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const codacyReport = 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);
+};
+
+
+module.exports = {
+    codacyReport
+};

package/lib/reports/codecov.js

@@ -0,0 +1,28 @@
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const codecovReport = async (reportData, reportOptions, options) => {
+    const codecovOptions = {
+        outputFile: 'codecov.json',
+        ... reportOptions
+    };
+
+    const jsonPath = path.resolve(options.outputDir, codecovOptions.outputFile);
+
+    // https://docs.codecov.com/docs/codecov-custom-coverage-format
+    const coverage = {};
+    reportData.files.forEach((item) => {
+        const { sourcePath, data } = item;
+        coverage[sourcePath] = data.lines;
+    });
+    const codecovData = {
+        coverage
+    };
+
+    await Util.writeFile(jsonPath, JSON.stringify(codecovData));
+    return Util.relativePath(jsonPath);
+};
+
+module.exports = {
+    codecovReport
+};

package/lib/reports/console-details.js

@@ -0,0 +1,174 @@
+const CG = require('console-grid');
+const EC = require('eight-colors');
+const { minimatch } = require('../packages/monocart-coverage-vendor.js');
+const { getGroupedRows } = require('../utils/snapshot.js');
+const Util = require('../utils/util.js');
+
+const getRowData = (rowName, summary, metrics, color) => {
+    const summaryRow = {};
+    let lowest = {
+        pct: 100,
+        status: 'high'
+    };
+    metrics.map((k) => {
+        const s = summary[k];
+        if (!s) {
+            return;
+        }
+        const percent = s.pct;
+        if (typeof percent !== 'number') {
+            return;
+        }
+        summaryRow[k] = Util.getColorStrByStatus(Util.PSF(percent, 100, 2), s.status, color);
+        if (percent < lowest.pct) {
+            lowest = s;
+        }
+    });
+    summaryRow.nameStatus = lowest.status;
+    summaryRow.name = rowName;
+    return summaryRow;
+};
+
+const getDetailsRows = (files, metrics, cdOptions, color) => {
+
+    const skipPercent = cdOptions.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 flatRows = [];
+    files.forEach((file) => {
+
+        // do NOT add debug file
+        if (file.debug) {
+            return;
+        }
+
+        const { sourcePath, summary } = file;
+        const fileRow = getRowData(sourcePath, summary, metrics, color);
+        fileRow.uncoveredLines = Util.getUncoveredLines(file.data.lines, color);
+        flatRows.push(fileRow);
+    });
+
+    return getGroupedRows(flatRows);
+};
+
+const getFileFilter = (input) => {
+    // for function handler
+    if (typeof input === 'function') {
+        return input;
+    }
+
+    // for single minimatch pattern
+    if (input && typeof input === 'string') {
+        // string to multiple patterns "{...}"
+        // mcr npx mocha --entryFilter {'**/node_modules/**':false,'**/src/*.js':true}
+        // mcr npx mocha --entryFilter "{'**/node_modules/**': false, '**/src/*.js': true}"
+        const obj = Util.strToObj(input);
+        if (obj) {
+            input = obj;
+        } else {
+            return (file) => {
+                return minimatch(file.sourcePath, input);
+            };
+        }
+    }
+
+    // for patterns
+    if (input && typeof input === 'object') {
+        const patterns = Object.keys(input);
+        return (file) => {
+            const sourcePath = file.sourcePath;
+            for (const pattern of patterns) {
+                if (minimatch(sourcePath, pattern)) {
+                    return input[pattern];
+                }
+            }
+            // false if not matched
+        };
+    }
+
+};
+
+const getFilteredFiles = (filter, files) => {
+    const fileFilter = getFileFilter(filter);
+    if (fileFilter) {
+        return files.filter(fileFilter);
+    }
+    return files;
+};
+
+const consoleDetailsReport = (reportData, reportOptions, options) => {
+    const cdOptions = {
+        maxCols: 50,
+        skipPercent: 0,
+        metrics: [],
+        filter: null,
+        ... reportOptions
+    };
+
+    const {
+        type, name, summary
+    } = reportData;
+
+    if (name) {
+        Util.logInfo(EC.cyan(name));
+    }
+
+    const color = 'ansicode';
+    let files = reportData.files;
+    files = getFilteredFiles(cdOptions.filter, files);
+
+    const metrics = Util.getMetrics(cdOptions.metrics, type);
+    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, color);
+    }
+    // no rows if skipped all by skipPercent
+    if (rows.length) {
+        rows.push({
+            innerBorder: true
+        });
+    }
+    rows.push(summaryRow);
+
+    const columns = [{
+        id: 'name',
+        name: 'Name'
+    }, ... metrics.map((m) => {
+        return {
+            id: m,
+            name: Util.capitalizeFirstLetter(m),
+            align: 'right'
+        };
+    }), {
+        id: 'uncoveredLines',
+        name: 'Uncovered Lines'
+    }];
+
+    return CG({
+        options: {
+            silent: cdOptions.silent,
+            nullPlaceholder: '',
+            defaultMaxWidth: cdOptions.maxCols
+        },
+        columns,
+        rows
+    });
+};
+
+module.exports = {
+    getRowData,
+    getFilteredFiles,
+    consoleDetailsReport
+};

package/lib/reports/console-summary.js

@@ -0,0 +1,83 @@
+const CG = require('console-grid');
+const EC = require('eight-colors');
+const Util = require('../utils/util.js');
+
+const nFormatter = (v) => {
+    if (typeof v === 'number') {
+        return Util.NF(v);
+    }
+    return v;
+};
+
+
+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 consoleSummaryReport = (reportData, reportOptions, options) => {
+
+    const csOptions = {
+        metrics: [],
+        ... reportOptions
+    };
+
+    const {
+        summary, name, type
+    } = reportData;
+
+    if (name) {
+        Util.logInfo(EC.cyan(name));
+    }
+
+    const metrics = Util.getMetrics(csOptions.metrics, type);
+
+    const rows = metrics.map((k) => {
+        return {
+            ... summary[k],
+            name: Util.capitalizeFirstLetter(k)
+        };
+    });
+
+    const columns = getSummaryColumns('ansicode');
+
+    CG({
+        columns,
+        rows
+    });
+};
+
+module.exports = {
+    getSummaryColumns,
+    consoleSummaryReport
+};

package/lib/reports/custom.js

@@ -0,0 +1,34 @@
+const { pathToFileURL } = require('url');
+const Util = require('../utils/util.js');
+
+const customReport = async (reportName, reportData, reportOptions, globalOptions) => {
+    let CustomReporter;
+    let err;
+    try {
+        CustomReporter = await import(reportName);
+    } catch (e) {
+        err = e;
+        try {
+            CustomReporter = await import(pathToFileURL(reportName));
+        } catch (ee) {
+            err = ee;
+        }
+    }
+
+    if (!CustomReporter) {
+        Util.logError(err.message);
+        return;
+    }
+
+    CustomReporter = CustomReporter.default || CustomReporter;
+
+    const reporter = new CustomReporter(reportOptions, globalOptions);
+
+    const results = await reporter.generate(reportData);
+
+    return results;
+};
+
+module.exports = {
+    customReport
+};

package/lib/reports/markdown-details.js

@@ -0,0 +1,120 @@
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const { getRowData, getFilteredFiles } = require('./console-details.js');
+
+const cutWithMaxCols = (str, maxCols, before) => {
+    if (str && maxCols && str.length > maxCols) {
+        if (before) {
+            return `... ${str.slice(str.length - (maxCols - 4))}`;
+        }
+        return `${str.slice(0, maxCols - 4)} ...`;
+    }
+
+    return str;
+};
+
+const markdownDetailsReport = async (reportData, reportOptions, options) => {
+    const mdOptions = {
+        baseUrl: '',
+        // unicode, html, or empty for no color
+        color: 'unicode',
+        maxCols: 50,
+        skipPercent: 0,
+        metrics: [],
+        filter: null,
+        outputFile: 'coverage-details.md',
+        ... reportOptions
+    };
+
+    const baseUrl = mdOptions.baseUrl;
+    const color = Util.normalizeColorType(mdOptions.color);
+    const maxCols = Util.normalizeMaxCols(mdOptions.maxCols, 15);
+
+    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;
+        });
+    }
+
+    files = getFilteredFiles(mdOptions.filter, files);
+
+    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);
+
+        let rowName = cutWithMaxCols(fileRow.name, maxCols, true);
+
+        if (fileRow.nameStatus) {
+            const nameColor = baseUrl && color === 'tex' ? '' : color;
+            rowName = Util.getColorStrByStatus(rowName, fileRow.nameStatus, nameColor);
+        }
+        if (baseUrl) {
+            rowName = `[${rowName}](${baseUrl + sourcePath})`;
+        }
+
+        fileRow.name = rowName;
+
+        const uncoveredLines = Util.getUncoveredLines(file.data.lines, color);
+        fileRow.uncoveredLines = cutWithMaxCols(uncoveredLines, maxCols);
+
+        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'
+    }, ... metrics.map((m) => {
+        return {
+            id: m,
+            name: Util.capitalizeFirstLetter(m),
+            align: 'right'
+        };
+    }), {
+        id: 'uncoveredLines',
+        name: 'Uncovered Lines'
+    }];
+
+    const markdownGrid = Util.markdownGrid({
+        options: {
+            name: reportData.name
+        },
+        columns,
+        rows
+    });
+
+    await Util.writeFile(mdPath, markdownGrid);
+    return Util.relativePath(mdPath);
+};
+
+
+module.exports = {
+    markdownDetailsReport
+};

package/lib/reports/markdown-summary.js

@@ -0,0 +1,44 @@
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const { getSummaryColumns } = require('./console-summary.js');
+
+const markdownSummaryReport = 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 = Util.markdownGrid({
+        options: {
+            name: reportData.name
+        },
+        columns,
+        rows
+    });
+
+    await Util.writeFile(mdPath, markdownGrid);
+    return Util.relativePath(mdPath);
+};
+
+module.exports = {
+    markdownSummaryReport
+};

package/lib/reports/raw.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const rawReport = (reportData, reportOptions, options) => {
+    const rawOptions = {
+        outputDir: 'raw',
+        ... reportOptions
+    };
+
+    const cacheDir = options.cacheDir;
+    const rawDir = path.resolve(options.outputDir, rawOptions.outputDir);
+    // console.log(rawDir, cacheDir);
+    if (fs.existsSync(rawDir)) {
+        Util.logError(`Failed to save raw report because the dir already exists: ${Util.relativePath(rawDir)}`);
+        return;
+    }
+
+    const rawParent = path.dirname(rawDir);
+    if (!fs.existsSync(rawParent)) {
+        fs.mkdirSync(rawParent, {
+            recursive: true
+        });
+    }
+
+    // just rename the cache folder name
+    fs.renameSync(cacheDir, rawDir);
+
+};
+
+module.exports = {
+    rawReport
+};

package/lib/reports/v8-json.js

@@ -0,0 +1,22 @@
+const path = require('path');
+const Util = require('../utils/util.js');
+
+const v8JsonReport = async (reportData, reportOptions, options) => {
+    const v8JsonOptions = {
+        outputFile: 'coverage-report.json',
+        ... reportOptions
+    };
+
+    // console.log(mergedOptions);
+    const jsonPath = path.resolve(options.outputDir, v8JsonOptions.outputFile);
+    const reportPath = Util.relativePath(jsonPath);
+
+    reportData.reportPath = reportPath;
+
+    await Util.writeFile(jsonPath, JSON.stringify(reportData));
+    return reportPath;
+};
+
+module.exports = {
+    v8JsonReport
+};

package/lib/reports/v8.js

@@ -0,0 +1,51 @@
+const path = require('path');
+const Assets = require('../assets.js');
+
+const v8Report = async (reportData, reportOptions, options) => {
+
+    // V8 only options, merged with root options
+    const v8HtmlOptions = {
+        outputFile: options.outputFile,
+        inline: options.inline,
+        assetsPath: options.assetsPath,
+        metrics: options.metrics,
+        ... reportOptions
+    };
+
+    // add metrics to data for UI
+    reportData.metrics = v8HtmlOptions.metrics;
+
+    const {
+        outputFile, inline, assetsPath
+    } = v8HtmlOptions;
+
+    // resolve full report path
+    const reportPath = path.resolve(options.outputDir, outputFile);
+    const outputDir = path.dirname(reportPath);
+    const htmlFile = path.basename(reportPath);
+
+    const jsFiles = ['monocart-coverage-app'];
+    // console.log(jsFiles);
+
+    const htmlOptions = {
+        reportData,
+        jsFiles,
+        inline,
+        assetsPath,
+        outputDir,
+        htmlFile,
+
+        saveReportPath: 'reportPath',
+
+        reportDataFile: 'coverage-data.js'
+    };
+
+    // compress json data for html
+    const htmlPath = await Assets.saveHtmlReport(htmlOptions);
+
+    return htmlPath;
+};
+
+module.exports = {
+    v8Report
+};