monocart-coverage-reports 2.2.1 → 2.2.2

package/README.md

@@ -64,6 +64,8 @@ console.log(coverageResults.summary);
 
 - `v8-json` (V8 data only)
     - [V8 coverage-report.json](https://cenfun.github.io/monocart-coverage-reports/v8-and-istanbul/coverage-report.json)
+- `codecov` (V8 data only)
+    - coverage data for [Codecov](https://docs.codecov.com/docs/codecov-custom-coverage-format), see [example](https://app.codecov.io/github/cenfun/monocart-coverage-reports) 
 - `console-summary` shows coverage summary in console
     
     ![](test/console-summary.png)

package/lib/cli.js

@@ -38,7 +38,7 @@ const initOptions = (cliOptions) => {
 
     // init reports to list with `,`
     const reports = cliOptions.reports;
-    if (reports) {
+    if (reports && typeof reports === 'string') {
         cliOptions.reports = reports.split(',');
     }
 

package/lib/converter/converter.js

@@ -313,9 +313,21 @@ const collectFileCoverage = (item, state, coverageData, options) => {
         b: {}
     };
 
+    // for codecov https://docs.codecov.com/docs/codecov-custom-coverage-format
+    data.lines = {};
+
     lines.filter((it) => !it.ignored).forEach((line, index) => {
         istanbulCoverage.statementMap[`${index}`] = line.generate();
         istanbulCoverage.s[`${index}`] = line.count;
+
+        let count = 0;
+        if (line.covered) {
+            count = line.count;
+        } else if (!line.covered && line.count > 0) {
+            count = '1/2';
+        }
+        // 1-base
+        data.lines[`${line.line}`] = count;
     });
 
     functions.filter((it) => !it.ignored).forEach((fn, index) => {
@@ -987,6 +999,7 @@ const convertV8List = async (v8list, options) => {
     if (sourceList.length) {
         sourceList.forEach((item) => {
 
+            // second time filter for empty source
             // exists same id, mark previous item as dedupe
             const prevItem = v8list.find((it) => it.id === item.id);
             if (prevItem) {

package/lib/generate.js

@@ -67,59 +67,50 @@ const getReportGroup = (reports, lcov, dataType) => {
         reportMap[defaultReport] = {};
     }
 
-    const allSupportedReports = [
+    const allSupportedReports = {
 
         // v8
-        'v8',
-        'v8-json',
+        'v8': 'v8',
+        'v8-json': 'v8',
+        'codecov': 'v8',
 
         // both
-        'console-summary',
+        'console-summary': 'both',
 
         // 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'
+    };
 
     // group v8 and istanbul
     const reportGroup = {};
     Object.keys(reportMap).forEach((k) => {
-        if (!allSupportedReports.includes(k)) {
-            return;
-        }
 
-        // v8
-        if (k.startsWith('v8')) {
-            // v8
-            if (!reportGroup.v8) {
-                reportGroup.v8 = {};
-            }
-            reportGroup.v8[k] = reportMap[k];
+        const groupName = allSupportedReports[k];
+        if (!groupName) {
+            Util.logError(`Unsupported report: ${k}`);
             return;
         }
 
-        // both
-        if (k === 'console-summary') {
-            reportGroup[k] = reportMap[k];
-            return;
+        let group = reportGroup[groupName];
+        if (!group) {
+            group = {};
+            reportGroup[groupName] = group;
         }
 
-        // istanbul
-        if (!reportGroup.istanbul) {
-            reportGroup.istanbul = {};
-        }
-        reportGroup.istanbul[k] = reportMap[k];
+        group[k] = reportMap[k];
+
     });
 
     return reportGroup;
@@ -156,8 +147,12 @@ const nFormatter = (v) => {
 
 const showConsoleSummary = (coverageResults, options) => {
 
-    const reportGroup = options.reportGroup;
-    const consoleOptions = reportGroup['console-summary'];
+    const bothGroup = options.reportGroup.both;
+    if (!bothGroup) {
+        return;
+    }
+
+    const consoleOptions = bothGroup['console-summary'];
     if (!consoleOptions) {
         return;
     }

package/lib/index.d.ts

@@ -34,6 +34,9 @@ declare namespace MCR {
         ['v8-json'] | ["v8-json", {
             outputFile?: string;
         }] |
+        ['codecov'] | ["codecov", {
+            outputFile?: string;
+        }] |
         ['console-summary'] | ['console-summary', {
             metrics?: Array<"bytes" | "functions" | "branches" | "lines" | "statements">;
         }] |

package/lib/istanbul/istanbul.js

@@ -87,9 +87,9 @@ 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 report = istanbulReports.create(reportName, istanbulGroup[reportName]);
         report.execute(context);
     });
 

package/lib/v8/v8.js

@@ -21,9 +21,18 @@ const initV8ListAndSourcemap = async (v8list, options) => {
 
     v8list = v8list.filter((item) => {
         if (typeof item.source === 'string' && item.functions) {
+            item.type = 'js';
             return true;
         }
         if (typeof item.text === 'string' && item.ranges) {
+            item.type = 'css';
+            return true;
+        }
+        // allow empty coverage
+        if (item.empty) {
+            if (!['js', 'css'].includes(item.type)) {
+                item.type = 'js';
+            }
             return true;
         }
         // 404 css, text will be empty
@@ -39,22 +48,30 @@ const initV8ListAndSourcemap = async (v8list, options) => {
     // init id, sourcePath
     v8list = v8list.map((item, i) => {
 
+        const type = item.type;
+
         const data = {
-            url: item.url
+            url: item.url,
+            type
         };
 
-        if (item.functions) {
-            data.type = 'js';
+        if (type === 'js') {
             data.functions = item.functions;
             data.source = item.source;
             // could be existed
             data.sourceMap = item.sourceMap;
-        } else if (item.ranges) {
-            data.type = 'css';
+        } else {
+            // css
             data.ranges = item.ranges;
             data.source = item.text;
         }
 
+
+        // no functions and ranges
+        if (item.empty) {
+            data.empty = true;
+        }
+
         const idList = [];
         // could be existed
         const distFile = item.distFile;
@@ -122,17 +139,17 @@ const mergeJsFunctions = (itemList) => {
 
 const mergeV8Coverage = async (dataList, options) => {
 
-    let list = [];
+    let allList = [];
     dataList.forEach((d) => {
-        list = list.concat(d.data);
+        allList = allList.concat(d.data);
     });
 
-    // console.log('before merge', list.map((it) => it.url));
+    const coverageList = allList.filter((it) => !it.empty);
 
     // connect all functions and ranges
     const itemMap = {};
     const mergeMap = {};
-    list.forEach((item) => {
+    coverageList.forEach((item) => {
         const { id } = item;
         const prev = itemMap[id];
         if (prev) {
@@ -158,11 +175,17 @@ const mergeV8Coverage = async (dataList, options) => {
         }
     }
 
-    list = Object.values(itemMap);
+    // first time filter for empty, (not for sources)
+    const emptyList = allList.filter((it) => it.empty).filter((it) => !itemMap[it.id]);
+
+    // empty list + merged list
+    const mergedList = emptyList.concat(Object.values(itemMap));
 
     // try to load coverage and source by id
-    for (const item of list) {
-        const { id } = item;
+    for (const item of mergedList) {
+        const {
+            id, type, empty
+        } = item;
         const sourcePath = Util.resolveCacheSourcePath(options.cacheDir, id);
         const content = await Util.readFile(sourcePath);
         if (content) {
@@ -173,24 +196,63 @@ const mergeV8Coverage = async (dataList, options) => {
             Util.logError(`failed to read source: ${item.url}`);
             item.source = '';
         }
+
+        // add empty coverage after merged
+        if (empty) {
+            if (type === 'js') {
+                item.functions = [{
+                    functionName: '',
+                    ranges: [{
+                        startOffset: 0,
+                        endOffset: item.source.length,
+                        count: 0
+                    }]
+                }];
+            } else {
+                // empty css
+                item.ranges = [];
+            }
+        }
+
     }
 
-    return list;
+    return mergedList;
 };
 
 // ============================================================
 
+const saveCodecovReport = async (reportData, options, codecovOptions) => {
+    const mergedOptions = {
+        outputFile: 'codecov.json',
+        ... codecovOptions
+    };
+
+    // console.log(mergedOptions);
+    const jsonPath = path.resolve(options.outputDir, mergedOptions.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);
+};
+
 const saveV8JsonReport = async (reportData, options, v8JsonOptions) => {
-    const v8MergedOptions = {
+    const mergedOptions = {
         outputFile: 'coverage-report.json',
         ... v8JsonOptions
     };
 
-    // console.log(v8MergedOptions);
-    const jsonPath = path.resolve(options.outputDir, v8MergedOptions.outputFile);
-    // console.log(reportPath);
+    // console.log(mergedOptions);
+    const jsonPath = path.resolve(options.outputDir, mergedOptions.outputFile);
     await Util.writeFile(jsonPath, JSON.stringify(reportData));
-
     return Util.relativePath(jsonPath);
 };
 
@@ -255,10 +317,10 @@ const saveV8Report = async (v8list, options) => {
     let outputPath;
 
     // v8 reports
-    const v8Map = options.reportGroup.v8;
+    const v8Group = options.reportGroup.v8;
 
     // v8 html
-    const v8Options = v8Map.v8;
+    const v8Options = v8Group.v8;
     if (v8Options) {
 
         // V8 only options, merged with root options
@@ -276,12 +338,25 @@ const saveV8Report = async (v8list, options) => {
         outputPath = await saveV8HtmlReport(reportData, options, v8HtmlOptions);
     }
 
-    // v8 json
-    const v8JsonOptions = v8Map['v8-json'];
+    // v8 json (after html for metrics data)
+    const v8JsonOptions = v8Group['v8-json'];
     if (v8JsonOptions) {
-        outputPath = await saveV8JsonReport(reportData, options, v8JsonOptions);
+        const jsonPath = await saveV8JsonReport(reportData, options, v8JsonOptions);
+        if (!outputPath) {
+            outputPath = jsonPath;
+        }
+    }
+
+    // codecov
+    const codecovOptions = v8Group.codecov;
+    if (codecovOptions) {
+        const jsonPath = await saveCodecovReport(reportData, options, codecovOptions);
+        if (!outputPath) {
+            outputPath = jsonPath;
+        }
     }
 
+    // outputPath last one is html
     const reportPath = Util.resolveReportPath(options, () => {
         return outputPath;
     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "monocart-coverage-reports",
-    "version": "2.2.1",
+    "version": "2.2.2",
     "description": "Monocart coverage reports",
     "main": "./lib/index.js",
     "bin": {
@@ -28,7 +28,7 @@
         "test-node-cdp": "node --inspect=9229 ./test/test-node-cdp.js",
         "test-node-koa": "node ./test/test-node-koa.js",
         "test-browser": "node ./test/test.js",
-        "test-cli": "npx mcr \"node ./test/test-node-env.js\" -o docs/cli -r v8,console-summary --lcov -c test/cli-options.js",
+        "test-cli": "npx mcr \"node ./test/test-node-env.js\" -o docs/cli -c test/cli-options.js",
         "test": "npm run test-browser && npm run test-node && npm run test-cli && npm run build-docs",
         "dev": "sf d v8",
         "open": "node ./scripts/open.js",