monocart-coverage-reports 2.9.3 → 2.10.0

package/lib/converter/ignore.js

@@ -69,16 +69,77 @@ const addNextIgnore = (list, content, item, locator) => {
 };
 
 // both v8 or c8
-const hasIgnoreKey = (content) => {
-    const v8Key = 'v8 ignore';
-    if (content.startsWith(v8Key)) {
-        return v8Key.length;
+const getStartEndNextInfo = (content) => {
+    content = content.trim();
+
+    const start = 'start';
+    const stop = 'stop';
+    const next = 'next';
+    if (content.startsWith(start)) {
+        return {
+            type: 'range',
+            value: stop
+        };
     }
-    const c8Key = 'c8 ignore';
-    if (content.startsWith(c8Key)) {
-        return c8Key.length;
+    if (content.startsWith(stop)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(next)) {
+        return {
+            type: 'next',
+            value: content.slice(next.length)
+        };
+    }
+};
+
+const getDisableEnableNextInfo = (content) => {
+    content = content.trim();
+
+    const start = 'disable';
+    const stop = 'enable';
+    const next = 'ignore next';
+    if (content.startsWith(start)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(stop)) {
+        return {
+            type: 'range',
+            value: stop
+        };
+    }
+    if (content.startsWith(next)) {
+        return {
+            type: 'next',
+            value: content.slice(next.length)
+        };
     }
-    // istanbul ignore has different rules, can not support it
+};
+
+
+const getIgnoreInfo = (content) => {
+    content = content.trim();
+
+    const v8_ignore = 'v8 ignore';
+    if (content.startsWith(v8_ignore)) {
+        return getStartEndNextInfo(content.slice(v8_ignore.length));
+    }
+
+    const c8_ignore = 'c8 ignore';
+    if (content.startsWith(c8_ignore)) {
+        return getStartEndNextInfo(content.slice(c8_ignore.length));
+    }
+
+    const node_coverage = 'node:coverage';
+    if (content.startsWith(node_coverage)) {
+        return getDisableEnableNextInfo(content.slice(node_coverage.length));
+    }
+
 };
 
 const getIgnoredRanges = (locator, options) => {
@@ -101,42 +162,43 @@ const getIgnoredRanges = (locator, options) => {
         const {
             block, start, end, text
         } = item;
-        let content = block ? text.slice(2, -2) : text.slice(2);
-        content = content.trim();
 
-        const ignoreKey = hasIgnoreKey(content);
-        if (!ignoreKey) {
+        const content = block ? text.slice(2, -2) : text.slice(2);
+        const ignoreInfo = getIgnoreInfo(content);
+        if (!ignoreInfo) {
             return;
         }
 
-        content = content.slice(ignoreKey).trim();
+        const { type, value } = ignoreInfo;
 
         if (ignoreStart) {
             // v-8 ignore stop
-            if (content === 'stop') {
-                ignoreStart.end = extendEnd(end, source, maxLength);
+            if (type === 'range' && value === ignoreStart.value) {
+                ignoreStart.ignoreData.end = extendEnd(end, source, maxLength);
                 ignoreStart = null;
             }
             return;
         }
 
         // v-8 ignore start
-        if (content === 'start') {
+        if (type === 'range') {
             // add first for sort by start
-            ignoreStart = {
-                type: 'start-stop',
+            const ignoreData = {
+                type,
                 start: extendStart(start, source),
                 end: start
             };
-            list.push(ignoreStart);
+            list.push(ignoreData);
+            ignoreStart = {
+                ignoreData,
+                value
+            };
             return;
         }
 
-        // v-8 ignore next N
-        const nextKey = 'next';
-        if (content.startsWith(nextKey)) {
-            content = content.slice(nextKey.length).trim();
-            addNextIgnore(list, content, item, locator);
+        // next N
+        if (type === 'next') {
+            addNextIgnore(list, value.trim(), item, locator);
         }
 
     });

package/lib/converter/info-function.js

@@ -16,8 +16,13 @@ module.exports = class InfoFunction {
         this.original = original;
     }
 
-    getRange() {
+    getName(index) {
+        return this.functionName || `(anonymous_${index})`;
+    }
+
+    getRange(index) {
         const range = {
+            name: this.getName(index),
             start: this.start,
             end: this.end,
             count: this.count
@@ -51,10 +56,8 @@ module.exports = class InfoFunction {
 
         const line = loc.start.line;
 
-        const functionName = this.functionName || `(anonymous_${index})`;
-
         return {
-            name: functionName,
+            name: this.getName(index),
             decl: decl,
             loc: loc,
             line: line