monocart-coverage-reports 2.3.3 → 2.4.0

package/lib/converter/ignore.js

@@ -2,7 +2,7 @@ const Util = require('../utils/util.js');
 
 const getNextN = (content, currentLine, item, locator) => {
 
-    // v8 ignore next N
+    // v-8 ignore next N
     if (content) {
         const n = parseInt(content);
         if (n && n > 0) {
@@ -20,19 +20,32 @@ const getNextN = (content, currentLine, item, locator) => {
         }
     }
 
-    // v8 ignore next
+    // v-8 ignore next
     return 1;
 };
 
+const extendStart = (start, source) => {
+    // extend left, include
+    while (start > 0 && Util.isBlank(source[start - 1])) {
+        start -= 1;
+    }
+    return start;
+};
+
+const extendEnd = (end, source, maxLength) => {
+    // extend right, exclude
+    while (end < maxLength && Util.isBlank(source[end])) {
+        end += 1;
+    }
+    return end;
+};
+
 const addNextIgnore = (list, content, item, locator) => {
 
     const { lineParser, source } = locator;
     const maxLength = source.length;
-    let startOffset = item.start;
-    // extend left
-    while (startOffset > 0 && Util.isBlank(source[startOffset - 1])) {
-        startOffset -= 1;
-    }
+
+    const start = extendStart(item.start, source);
 
     // findLine 0-base
     const currentLine = lineParser.findLine(item.end);
@@ -43,17 +56,13 @@ const addNextIgnore = (list, content, item, locator) => {
     // getLine 1-base
     const line = currentLine.line + 1;
     const endLine = locator.getLine(line + n);
-    let endOffset = endLine ? endLine.end : maxLength;
-    // extend right
-    while (endOffset < maxLength && Util.isBlank(source[endOffset + 1])) {
-        endOffset += 1;
-    }
+    const end = extendEnd(endLine ? endLine.end : maxLength, source, maxLength);
 
     const nextItem = {
         type: 'next',
         n,
-        startOffset,
-        endOffset
+        start,
+        end
     };
 
     list.push(nextItem);
@@ -69,6 +78,7 @@ const hasIgnoreKey = (content) => {
     if (content.startsWith(c8Key)) {
         return c8Key.length;
     }
+    // istanbul ignore has different rules, can not support it
 };
 
 const getIgnoredRanges = (locator, options) => {
@@ -76,7 +86,8 @@ const getIgnoredRanges = (locator, options) => {
         return;
     }
 
-    const { lineParser } = locator;
+    const { lineParser, source } = locator;
+    const maxLength = source.length;
 
     const comments = lineParser.comments;
     if (!Util.isList(comments)) {
@@ -101,27 +112,27 @@ const getIgnoredRanges = (locator, options) => {
         content = content.slice(ignoreKey).trim();
 
         if (ignoreStart) {
-            // v8 ignore stop
+            // v-8 ignore stop
             if (content === 'stop') {
-                ignoreStart.endOffset = end;
+                ignoreStart.end = extendEnd(end, source, maxLength);
                 ignoreStart = null;
             }
             return;
         }
 
-        // v8 ignore start
+        // v-8 ignore start
         if (content === 'start') {
             // add first for sort by start
             ignoreStart = {
                 type: 'start-stop',
-                startOffset: start,
-                endOffset: start
+                start: extendStart(start, source),
+                end: start
             };
             list.push(ignoreStart);
             return;
         }
 
-        // v8 ignore next N
+        // v-8 ignore next N
         const nextKey = 'next';
         if (content.startsWith(nextKey)) {
             content = content.slice(nextKey.length).trim();
@@ -132,7 +143,7 @@ const getIgnoredRanges = (locator, options) => {
 
     // ignore not stop
     if (ignoreStart) {
-        ignoreStart.endOffset = locator.source.length;
+        ignoreStart.end = locator.source.length;
         ignoreStart = null;
     }
 

package/lib/converter/info-branch.js

@@ -1,10 +1,16 @@
 const Util = require('../utils/util.js');
 module.exports = class InfoBranch {
-    constructor(start, end, locations, type) {
+    constructor(data, original) {
+        const {
+            start, end, locations, type
+        } = data;
+
         this.start = start;
         this.end = end;
         this.locations = locations;
-        this.type = type || 'branch';
+        this.type = type;
+        this.data = data;
+        this.original = original;
     }
 
     getRanges() {
@@ -20,6 +26,11 @@ module.exports = class InfoBranch {
             if (item.ignored) {
                 range.ignored = true;
             }
+            // for debug
+            if (Util.isDebug() && this.original) {
+                range.generatedStart = item.generatedStart;
+                range.generatedEnd = item.generatedEnd;
+            }
             return range;
         });
     }

package/lib/converter/info-function.js

@@ -1,10 +1,19 @@
 const Util = require('../utils/util.js');
 module.exports = class InfoFunction {
-    constructor(start, end, count, name) {
+    constructor(data, original) {
+
+        const {
+            start, end, bodyStart, bodyEnd, functionName, count
+        } = data;
+
         this.start = start;
         this.end = end;
+        this.bodyStart = bodyStart;
+        this.bodyEnd = bodyEnd;
         this.count = count;
-        this.name = name || '(anonymous)';
+        this.functionName = functionName;
+        this.data = data;
+        this.original = original;
     }
 
     getRange() {
@@ -16,13 +25,25 @@ module.exports = class InfoFunction {
         if (this.ignored) {
             range.ignored = true;
         }
+        // for debug
+        if (Util.isDebug() && this.original) {
+            range.generatedStart = this.data.generatedStart;
+            range.generatedEnd = this.data.generatedEnd;
+        }
         return range;
     }
 
-    generate(locator) {
+    generate(locator, index) {
 
-        const loc = {
+        const decl = {
             start: this.start,
+            end: this.bodyStart
+        };
+
+        Util.updateOffsetToLocation(locator, decl);
+
+        const loc = {
+            start: this.bodyStart,
             end: this.end
         };
 
@@ -30,9 +51,11 @@ module.exports = class InfoFunction {
 
         const line = loc.start.line;
 
+        const functionName = this.functionName || `(anonymous_${index})`;
+
         return {
-            name: this.name,
-            decl: loc,
+            name: functionName,
+            decl: decl,
             loc: loc,
             line: line
         };

package/lib/converter/info-statement.js

@@ -0,0 +1,43 @@
+const Util = require('../utils/util.js');
+module.exports = class InfoStatement {
+    constructor(data, original) {
+        const {
+            start, end, count
+        } = data;
+
+        this.start = start;
+        this.end = end;
+        this.count = count;
+        this.data = data;
+        this.original = original;
+    }
+
+    getRange() {
+        const range = {
+            start: this.start,
+            end: this.end,
+            count: this.count
+        };
+        if (this.ignored) {
+            range.ignored = true;
+        }
+        // for debug
+        if (Util.isDebug() && this.original) {
+            range.generatedStart = this.data.generatedStart;
+            range.generatedEnd = this.data.generatedEnd;
+        }
+        return range;
+    }
+
+    generate(locator) {
+
+        const loc = {
+            start: this.start,
+            end: this.end
+        };
+
+        Util.updateOffsetToLocation(locator, loc);
+
+        return loc;
+    }
+};

package/lib/default/options.js

@@ -62,7 +62,7 @@ module.exports = {
     reportPath: null,
 
     // {array} watermarks for low/medium/high. Defaults to [50, 80]
-    // {object} Istanbul: { statements:[50,80], functions:[50,80], branches:[50,80], lines:[50,80] }, V8: { bytes:[50,80] }.
+    // {object} { bytes:[50,80], statements:[50,80], branches:[50,80], functions:[50,80], lines:[50,80] }
     watermarks: [50, 80],
 
     // {function} onEnd hook

package/lib/generate.js

@@ -166,8 +166,8 @@ const showConsoleSummary = (reportData, reportOptions, options) => {
     }
 
     const allMetrics = {
-        v8: ['bytes', 'functions', 'branches', 'lines'],
-        istanbul: ['statements', 'functions', 'branches', 'lines']
+        v8: ['bytes', 'statements', 'branches', 'functions', 'lines'],
+        istanbul: ['statements', 'branches', 'functions', 'lines']
     };
 
     let list = allMetrics[type];

package/lib/index.d.ts

@@ -15,13 +15,12 @@ declare namespace MCR {
     }
 
     export type Watermarks = [number, number] | {
-        functions?: [number, number];
-        branches?: [number, number];
-        lines?: [number, number];
         /** V8 only */
         bytes?: [number, number];
-        /** Istanbul only */
         statements?: [number, number];
+        branches?: [number, number];
+        functions?: [number, number];
+        lines?: [number, number];
     }
 
     export type ReportDescription =
@@ -29,7 +28,7 @@ declare namespace MCR {
             outputFile?: string;
             inline?: boolean;
             assetsPath?: string;
-            metrics?: Array<"bytes" | "functions" | "branches" | "lines">;
+            metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
         }] |
         ['v8-json'] | ["v8-json", {
             outputFile?: string;
@@ -56,7 +55,7 @@ declare namespace MCR {
             verbose?: boolean;
             linkMapper?: any;
             skipEmpty?: boolean;
-            metricsToShow?: Array<"lines" | "branches" | "functions" | "statements">;
+            metricsToShow?: Array<"statements" | "branches" | "functions" | "lines">;
         }] |
         ['json'] | ['json', {
             file?: string;
@@ -90,7 +89,7 @@ declare namespace MCR {
             file?: string;
         }] |
         ['console-summary'] | ['console-summary', {
-            metrics?: Array<"bytes" | "functions" | "branches" | "lines" | "statements">;
+            metrics?: Array<"bytes" | "statements" | "branches" | "functions" | "lines">;
         }] |
         ['raw'] | ['raw', {
             outputDir?: string;
@@ -121,13 +120,12 @@ declare namespace MCR {
     }
 
     export interface CoverageSummary {
-        functions: MetricsSummary;
-        branches: MetricsSummary;
-        lines: MetricsSummary;
         /** V8 only */
         bytes?: MetricsSummary;
-        /** Istanbul only */
         statements?: MetricsSummary;
+        branches: MetricsSummary;
+        functions: MetricsSummary;
+        lines: MetricsSummary;
     }
 
     /** V8 only */
@@ -139,6 +137,13 @@ declare namespace MCR {
         none?: boolean;
     }
 
+    export interface IgnoredRange {
+        start: number;
+        end: number;
+        type: string;
+        n?: number;
+    }
+
     export interface CoverageFile {
         sourcePath: string;
         summary: CoverageSummary;
@@ -157,8 +162,14 @@ declare namespace MCR {
         /** V8 only */
         data?: {
             bytes: CoverageRange[];
-            functions: CoverageRange[];
+            statements: CoverageRange[];
             branches: CoverageRange[];
+            functions: CoverageRange[];
+            ignores?: IgnoredRange[];
+            /** codecov json format */
+            lines: {
+                [key: string]: number | string
+            };
         }
     }
 
@@ -218,7 +229,7 @@ declare namespace MCR {
         reportPath?: string | (() => string);
 
         /** {array} watermarks for low/medium/high. Defaults to [50, 80]
-        * {object} { statements:[50,80], functions:[50,80], branches:[50,80], lines:[50,80] }, V8: { bytes:[50,80] } */
+        * {object} { bytes:[50,80], statements:[50,80], branches:[50,80], functions:[50,80], lines:[50,80] } */
         watermarks?: Watermarks;
 
         /** {function} onEnd hook */

package/lib/istanbul/istanbul.js

@@ -39,8 +39,8 @@ const saveIstanbulReports = (coverageData, fileSources, options) => {
 
     const defaultWatermarks = {
         statements: [50, 80],
-        functions: [50, 80],
         branches: [50, 80],
+        functions: [50, 80],
         lines: [50, 80]
     };
     const watermarks = Util.resolveWatermarks(defaultWatermarks, options.watermarks);