monocart-coverage-reports 2.2.1 → 2.3.0

package/lib/converter/info-branch.js

@@ -33,17 +33,25 @@ module.exports = class InfoBranch {
         const line = groupLoc.start.line;
 
         // remove ignored
-        const locations = this.locations.filter((it) => !it.ignored);
+        // do NOT change previous number type to object, need used for sourcemap
+        const newLocations = this.locations.filter((it) => !it.ignored).map((it) => {
+            const item = {
+                start: it.start,
+                end: it.end,
+                none: it.none,
+                count: it.count
+            };
 
-        // [ { start:{line,column}, end:{line,column}, count }, ...]
-        locations.forEach((item) => {
+            // [ { start:{line,column}, end:{line,column}, count }, ...]
             Util.updateOffsetToLocation(locator, item);
+
+            return item;
         });
 
         const map = {
             loc: groupLoc,
             type: this.type,
-            locations: locations.map((item) => {
+            locations: newLocations.map((item) => {
                 const {
                     start, end, none
                 } = item;
@@ -63,7 +71,7 @@ module.exports = class InfoBranch {
             line: line
         };
 
-        const counts = locations.map((item) => item.count);
+        const counts = newLocations.map((item) => item.count);
 
         return {
             map,

package/lib/default/options.js

@@ -6,6 +6,9 @@ module.exports = {
     // {string} output dir
     outputDir: './coverage-reports',
 
+    // {string|string[]} input raw dir(s)
+    inputDir: null,
+
     // {string} v8 or html for istanbul by default
     // {array} multiple reports with options
     // v8 report or istanbul supported reports

package/lib/generate.js

@@ -44,84 +44,83 @@ const getReportGroup = (reports, lcov, dataType) => {
         reportMap.lcovonly = {};
     }
 
-    const defaultReport = dataType === 'v8' ? 'v8' : 'html';
-
-    if (Util.isList(reports)) {
-        reports.forEach((it) => {
-            if (Util.isList(it)) {
-                // ["v8"]
-                reportMap[it[0]] = {
+    const reportList = Util.toList(reports, ',');
+    reportList.forEach((it) => {
+        if (Util.isList(it)) {
+            // ["v8"], ["v8", {}]
+            const id = it[0];
+            if (typeof id === 'string' && id) {
+                reportMap[id] = {
                     ... it[1]
                 };
-                return;
-            }
-            if (typeof it === 'string') {
-                reportMap[it] = {};
-                return;
             }
-            reportMap[defaultReport] = {};
-        });
-    } else if (typeof reports === 'string' && reports) {
-        reportMap[reports] = {};
-    } else {
+            return;
+        }
+        if (typeof it === 'string' && it) {
+            reportMap[it] = {};
+        }
+    });
+
+    // using default report if no reports
+    if (!Object.keys(reportMap).length) {
+        const defaultReport = dataType === 'v8' ? 'v8' : 'html';
         reportMap[defaultReport] = {};
     }
 
-    const allSupportedReports = [
-
+    const allBuildInReports = {
         // v8
-        'v8',
-        'v8-json',
-
-        // both
-        'console-summary',
+        'v8': 'v8',
+        'v8-json': 'v8',
+        'codecov': 'v8',
 
         // istanbul
-        'clover',
-        'cobertura',
-        'html',
-        'html-spa',
-        'json',
-        'json-summary',
-        'lcov',
-        'lcovonly',
-        'none',
-        'teamcity',
-        'text',
-        'text-lcov',
-        'text-summary'
-    ];
+        'clover': 'istanbul',
+        'cobertura': 'istanbul',
+        'html': 'istanbul',
+        'html-spa': 'istanbul',
+        'json': 'istanbul',
+        'json-summary': 'istanbul',
+        'lcov': 'istanbul',
+        'lcovonly': 'istanbul',
+        'none': 'istanbul',
+        'teamcity': 'istanbul',
+        'text': 'istanbul',
+        'text-lcov': 'istanbul',
+        'text-summary': 'istanbul',
+
+        // both
+        'console-summary': 'both',
+        'raw': 'both'
+    };
 
     // group v8 and istanbul
     const reportGroup = {};
     Object.keys(reportMap).forEach((k) => {
-        if (!allSupportedReports.includes(k)) {
-            return;
-        }
+        const options = reportMap[k];
 
-        // v8
-        if (k.startsWith('v8')) {
-            // v8
-            if (!reportGroup.v8) {
-                reportGroup.v8 = {};
-            }
-            reportGroup.v8[k] = reportMap[k];
-            return;
+        let type = allBuildInReports[k];
+        if (!type) {
+            // for custom reporter
+            type = options.type || 'v8';
         }
 
-        // both
-        if (k === 'console-summary') {
-            reportGroup[k] = reportMap[k];
-            return;
+        let group = reportGroup[type];
+        if (!group) {
+            group = {};
+            reportGroup[type] = group;
         }
 
-        // istanbul
-        if (!reportGroup.istanbul) {
-            reportGroup.istanbul = {};
-        }
-        reportGroup.istanbul[k] = reportMap[k];
+        group[k] = options;
+
     });
 
+    // requires a default istanbul report if data is istanbul
+    if (dataType === 'istanbul' && !reportGroup.istanbul) {
+        reportGroup.istanbul = {
+            html: {}
+        };
+    }
+
     return reportGroup;
 };
 
@@ -154,19 +153,14 @@ const nFormatter = (v) => {
     return v;
 };
 
-const showConsoleSummary = (coverageResults, options) => {
+const showConsoleSummary = (reportData, reportOptions, options) => {
 
-    const reportGroup = options.reportGroup;
-    const consoleOptions = reportGroup['console-summary'];
-    if (!consoleOptions) {
-        return;
-    }
-
-    const { metrics } = consoleOptions;
+    const { metrics } = reportOptions;
 
     const {
         summary, name, type
-    } = coverageResults;
+    } = reportData;
+
     if (name) {
         EC.logCyan(name);
     }
@@ -222,10 +216,36 @@ const showConsoleSummary = (coverageResults, options) => {
     });
 };
 
+const saveRawReport = (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);
+
+};
+
 
 // ========================================================================================================
 
-const getCoverageResults = async (dataList, options) => {
+const getCoverageResults = async (dataList, sourceCache, options) => {
     // get first and check v8list or istanbul data
     const firstData = dataList[0];
     const dataType = firstData.type;
@@ -238,27 +258,50 @@ const getCoverageResults = async (dataList, options) => {
     // v8list
     if (dataType === 'v8') {
         // merge v8list first
-        const v8list = await mergeV8Coverage(dataList, options);
+        const v8list = await mergeV8Coverage(dataList, sourceCache, options);
         // console.log('after merge', v8list.map((it) => it.url));
 
-        const { coverageData, fileSources } = await convertV8List(v8list, options);
-        return generateV8ListReports(v8list, coverageData, fileSources, options);
+        // only debug level
+        const time_start = Date.now();
+        const results = convertV8List(v8list, options);
+        const {
+            v8DataList, coverageData, fileSources
+        } = results;
+        Util.logTime(`converted v8 data: ${v8DataList.length}`, time_start);
 
+        return generateV8ListReports(v8DataList, coverageData, fileSources, options);
     }
 
     // istanbul data
-    const istanbulData = mergeIstanbulCoverage(dataList, options);
+    const istanbulData = mergeIstanbulCoverage(dataList);
     const { coverageData, fileSources } = initIstanbulData(istanbulData, options);
     return saveIstanbulReports(coverageData, fileSources, options);
 };
 
-const generateCoverageReports = async (dataList, options) => {
-    const coverageResults = await getCoverageResults(dataList, options);
+const generateCoverageReports = async (dataList, sourceCache, options) => {
+    const coverageResults = await getCoverageResults(dataList, sourceCache, options);
 
     // [ 'type', 'reportPath', 'name', 'watermarks', 'summary', 'files' ]
     // console.log(Object.keys(coverageResults));
 
-    showConsoleSummary(coverageResults, options);
+    const buildInBothReports = {
+        'console-summary': showConsoleSummary,
+        'raw': saveRawReport
+    };
+
+    const bothGroup = options.reportGroup.both;
+    if (bothGroup) {
+        const bothReports = Object.keys(bothGroup);
+        for (const reportName of bothReports) {
+            const reportOptions = bothGroup[reportName];
+            const buildInHandler = buildInBothReports[reportName];
+            if (buildInHandler) {
+                await buildInHandler(coverageResults, reportOptions, options);
+            } else {
+                await Util.runCustomReporter(reportName, coverageResults, reportOptions, options);
+            }
+        }
+    }
 
     return coverageResults;
 };
@@ -266,26 +309,45 @@ const generateCoverageReports = async (dataList, options) => {
 // ========================================================================================================
 
 
-const getCoverageDataList = async (cacheDir) => {
-    const files = fs.readdirSync(cacheDir).filter((f) => f.startsWith('coverage-'));
-    if (!files.length) {
-        return;
-    }
-
+const getInputData = async (inputList) => {
     const dataList = [];
-    for (const item of files) {
-        const content = await Util.readFile(path.resolve(cacheDir, item));
-        if (content) {
-            dataList.push(JSON.parse(content));
+    const sourceCache = new Map();
+
+    const addJsonData = async (dir, filename) => {
+        const isCoverage = filename.startsWith('coverage-');
+        const isSource = filename.startsWith('source-');
+        if (isCoverage || isSource) {
+            const content = await Util.readFile(path.resolve(dir, filename));
+            if (content) {
+                const json = JSON.parse(content);
+                if (isCoverage) {
+                    dataList.push(json);
+                } else {
+                    sourceCache.set(json.id, json);
+                }
+            }
         }
-    }
+    };
 
-    if (dataList.length) {
-        return dataList;
+    for (const dir of inputList) {
+        const allFiles = fs.readdirSync(dir);
+        if (!allFiles.length) {
+            continue;
+        }
+        for (const filename of allFiles) {
+            // only json file
+            if (filename.endsWith('.json')) {
+                await addJsonData(dir, filename);
+            }
+        }
     }
+    return {
+        dataList,
+        sourceCache
+    };
 };
 
 module.exports = {
-    getCoverageDataList,
+    getInputData,
     generateCoverageReports
 };

package/lib/index.d.ts

@@ -34,8 +34,8 @@ declare namespace MCR {
         ['v8-json'] | ["v8-json", {
             outputFile?: string;
         }] |
-        ['console-summary'] | ['console-summary', {
-            metrics?: Array<"bytes" | "functions" | "branches" | "lines" | "statements">;
+        ['codecov'] | ["codecov", {
+            outputFile?: string;
         }] |
         ['clover'] | ['clover', {
             file?: string;
@@ -88,6 +88,16 @@ declare namespace MCR {
         }] |
         ['text-summary'] | ['text-summary', {
             file?: string;
+        }] |
+        ['console-summary'] | ['console-summary', {
+            metrics?: Array<"bytes" | "functions" | "branches" | "lines" | "statements">;
+        }] |
+        ['raw'] | ['raw', {
+            outputDir?: string;
+        }] |
+        [string] | [string, {
+            type?: "v8" | "istanbul" | "both";
+            [key: string]: any;
         }];
 
     export type AddedResults = {
@@ -169,6 +179,9 @@ declare namespace MCR {
         /** {string} output dir */
         outputDir?: string;
 
+        /** {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 */

package/lib/index.js

@@ -4,7 +4,7 @@ const defaultOptions = require('./default/options.js');
 const Util = require('./utils/util.js');
 
 const { initV8ListAndSourcemap } = require('./v8/v8.js');
-const { getCoverageDataList, generateCoverageReports } = require('./generate.js');
+const { getInputData, generateCoverageReports } = require('./generate.js');
 
 class CoverageReport {
 
@@ -41,10 +41,12 @@ class CoverageReport {
     // add coverage data: {array} V8 format, {object} Istanbul format
     async add(data) {
 
+        const time_start = Date.now();
+
         this.initOptions();
 
         if (!Util.checkCoverageData(data)) {
-            Util.logError(`The coverage data must be Array(V8) or Object(Istanbul): ${this.options.name}`);
+            Util.logError(`${this.options.name}: The added coverage data must be Array(V8) or Object(Istanbul)`);
             return;
         }
 
@@ -69,40 +71,68 @@ class CoverageReport {
         const dataContent = JSON.stringify(results);
         await Util.writeFile(dataPath, dataContent);
 
+        Util.logTime(`added coverage data: ${results.type}`, time_start);
+
         return results;
     }
 
     // generate report
     async generate() {
 
-        if (!this.hasCache()) {
-            Util.logError(`Not found coverage cache: ${this.options.cacheDir}`);
+        const time_start = Date.now();
+
+        this.initOptions();
+
+        const { 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) {
+                Util.logError(`Not found coverage data dir: ${Util.relativePath(dir)}`);
+            }
+            return hasDir;
+        });
+
+        if (!inputList.length) {
             return;
         }
 
-        const cacheDir = this.options.cacheDir;
-        const dataList = await getCoverageDataList(cacheDir);
-        if (!dataList) {
-            Util.logError(`Not found coverage data in cache dir: ${cacheDir}`);
+        const { dataList, sourceCache } = await getInputData(inputList);
+        if (!dataList.length) {
+            const dirs = inputList.map((dir) => Util.relativePath(dir));
+            Util.logError(`Not found coverage data in dir(s): ${dirs.join(', ')}`);
             return;
         }
 
         // empty output dir except cache dir before generate reports
         const outputDir = this.options.outputDir;
+
+        if (fs.existsSync(outputDir)) {
         // if assets dir is out of output dir will be ignore
-        fs.readdirSync(outputDir).forEach((itemName) => {
-            if (itemName === this.cacheDirName) {
-                return;
-            }
-            Util.rmSync(path.resolve(outputDir, itemName));
-        });
+            fs.readdirSync(outputDir).forEach((itemName) => {
+                if (itemName === this.cacheDirName) {
+                    return;
+                }
+                Util.rmSync(path.resolve(outputDir, itemName));
+            });
+        } else {
+            fs.mkdirSync(outputDir, {
+                recursive: true
+            });
+        }
 
-        const coverageResults = await generateCoverageReports(dataList, this.options);
+        const coverageResults = await generateCoverageReports(dataList, sourceCache, this.options);
 
         if (this.logging !== 'debug') {
             Util.rmSync(cacheDir);
         }
 
+        Util.logTime(`generated coverage reports: ${coverageResults.reportPath}`, time_start);
+
         const onEnd = this.options.onEnd;
         if (typeof onEnd === 'function') {
             await onEnd(coverageResults);

package/lib/istanbul/istanbul.js

@@ -52,7 +52,7 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
         coverageMap,
         // The summarizer to default to (may be overridden by some reports)
         // values can be nested/flat/pkg. Defaults to 'pkg'
-        defaultSummarizer: options.defaultSummarizer || 'nested',
+        defaultSummarizer: options.defaultSummarizer || 'pkg',
 
         dir: options.outputDir,
         watermarks,
@@ -87,9 +87,10 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
     // create a context for report generation
     const context = istanbulLibReport.createContext(contextOptions);
 
-    const istanbulMap = options.reportGroup.istanbul;
-    Object.keys(istanbulMap).forEach((reportName) => {
-        const report = istanbulReports.create(reportName, istanbulMap[reportName]);
+    const istanbulGroup = options.reportGroup.istanbul;
+    Object.keys(istanbulGroup).forEach((reportName) => {
+        const reportOptions = istanbulGroup[reportName];
+        const report = istanbulReports.create(reportName, reportOptions);
         report.execute(context);
     });
 
@@ -115,14 +116,13 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
     return coverageResults;
 };
 
-const mergeIstanbulCoverage = (dataList, options) => {
+const mergeIstanbulCoverage = (dataList) => {
+    const istanbulCoverageList = dataList.map((it) => it.data);
     const coverageMap = istanbulLibCoverage.createCoverageMap();
-    dataList.forEach((d) => {
-        coverageMap.merge(d.data);
+    istanbulCoverageList.forEach((coverage) => {
+        coverageMap.merge(coverage);
     });
-
     const istanbulData = coverageMap.toJSON();
-
     return istanbulData;
 };