monocart-coverage-reports 1.1.0 → 2.0.1

package/lib/converter/find-original-range.js

@@ -24,13 +24,16 @@ const findMapping = (list, offset) => {
 
 };
 
-const findOffsetMapping = (generatedState, offset) => {
+const findOffsetMapping = (state, offset) => {
 
-    const decodedMappings = generatedState.decodedMappings;
+    const decodedMappings = state.decodedMappings;
 
     // possible no length
     if (!decodedMappings.length) {
-        return;
+        return {
+            error: true,
+            errors: [`not found decoded mappings for offset: ${offset}`]
+        };
     }
 
     const mapping = findMapping(decodedMappings, offset);
@@ -39,7 +42,10 @@ const findOffsetMapping = (generatedState, offset) => {
 
     // not found, allow > last, not allow < first
     if (offset < generatedOffset) {
-        return;
+        return {
+            error: true,
+            errors: [`not found generated offset: ${offset}`]
+        };
     }
 
     // exact matched no need fix
@@ -69,8 +75,8 @@ const findNextOriginalDiffMapping = (originalState, mapping) => {
     }
 };
 
-const findNextGeneratedDiffMapping = (generatedState, mapping) => {
-    const decodedMappings = generatedState.decodedMappings;
+const findNextGeneratedDiffMapping = (state, mapping) => {
+    const decodedMappings = state.decodedMappings;
     const i = mapping.generatedIndex + 1;
     const l = decodedMappings.length;
     if (i < l) {
@@ -78,7 +84,7 @@ const findNextGeneratedDiffMapping = (generatedState, mapping) => {
     }
 };
 
-const getGeneratedText = (mapping, generatedState) => {
+const getGeneratedText = (mapping, state) => {
 
     const generatedText = mapping.generatedText;
     if (typeof generatedText === 'string') {
@@ -87,13 +93,13 @@ const getGeneratedText = (mapping, generatedState) => {
 
     let text = '';
 
-    const { positionMapping } = generatedState;
-    const nextMapping = findNextGeneratedDiffMapping(generatedState, mapping);
+    const locator = state.locator;
+    const nextMapping = findNextGeneratedDiffMapping(state, mapping);
     if (nextMapping) {
-        text = positionMapping.getSlice(mapping.generatedOffset, nextMapping.generatedOffset);
+        text = locator.getSlice(mapping.generatedOffset, nextMapping.generatedOffset);
     } else {
         // to the end
-        text = positionMapping.getSlice(mapping.generatedOffset);
+        text = locator.getSlice(mapping.generatedOffset);
     }
 
     // never cross line
@@ -118,13 +124,13 @@ const getOriginalText = (mapping, originalState) => {
 
     let text = '';
 
-    const { positionMapping } = originalState;
+    const { locator } = originalState;
     const nextMapping = findNextOriginalDiffMapping(originalState, mapping);
     if (nextMapping) {
-        text = positionMapping.getSlice(mapping.originalOffset, nextMapping.originalOffset);
+        text = locator.getSlice(mapping.originalOffset, nextMapping.originalOffset);
     } else {
         // to the end
-        text = positionMapping.getSlice(mapping.originalOffset);
+        text = locator.getSlice(mapping.originalOffset);
     }
 
     // the last two items could have same line and column
@@ -326,7 +332,7 @@ const getOriginalEndPosition = (originalText, generatedText, generatedPos) => {
 
 // ========================================================================================================
 
-const fixStartColumn = (startMapping, range, generatedState, originalState) => {
+const fixStartColumn = (startMapping, range, state, originalState) => {
     // exact matched no need fix
     if (startMapping.exact) {
         // originalColumn is the column
@@ -337,14 +343,14 @@ const fixStartColumn = (startMapping, range, generatedState, originalState) => {
     const originalColumn = startMapping.originalColumn;
 
     const originalText = getOriginalText(startMapping, originalState);
-    const generatedText = getGeneratedText(startMapping, generatedState);
+    const generatedText = getGeneratedText(startMapping, state);
 
-    // actual generatedOffset < range startOffset
+    // actual generatedOffset < startOffset
     const generatedPos = range.startOffset - startMapping.generatedOffset;
 
     const originalPos = getOriginalStartPosition(originalText, generatedText, generatedPos);
 
-    // if (originalState.sourcePath.endsWith('src/components/report.vue') && range.count === 0) {
+    // if (originalState.sourcePath.endsWith('src/components/report.vue')) {
     //     console.log('====================================================================');
     //     console.log('fix startMapping', originalState.sourcePath);
     //     console.log(startMapping);
@@ -361,7 +367,7 @@ const fixStartColumn = (startMapping, range, generatedState, originalState) => {
 
 // ========================================================================================================
 
-const fixEndColumn = (endMapping, range, startMapping, generatedState, originalState) => {
+const fixEndColumn = (endMapping, range, startMapping, state, originalState) => {
 
     const originalColumn = endMapping.originalColumn;
 
@@ -373,16 +379,28 @@ const fixEndColumn = (endMapping, range, startMapping, generatedState, originalS
 
     // ================================
     // diff line, to the line end
-    if (endMapping.originalLine !== startMapping.originalLine) {
-        endMapping.column = Infinity;
-        return;
-    }
+    // if (endMapping.originalLine !== startMapping.originalLine) {
+    // endMapping.column = Infinity;
+    // return;
+
+    // console.log(originalState.sourcePath, '-------------------------------diff line---------------------------------------');
+    // console.log(range, startMapping, endMapping);
+
+    // }
 
     // ================================
     // in the same line
 
     const originalText = getOriginalText(endMapping, originalState);
 
+    // if (originalState.sourcePath.indexOf('comments.js') !== -1) {
+    //     if (range.endOffset === 1077) {
+    //         console.log('----------------------------------------------------------------------');
+    //         console.log(originalText);
+    //         console.log(range, startMapping, endMapping);
+    //     }
+    // }
+
     // exclusive, need exclude some end strings
     if (!endMapping.exclusive) {
         endMapping.column = originalColumn + originalText.length;
@@ -390,14 +408,14 @@ const fixEndColumn = (endMapping, range, startMapping, generatedState, originalS
     }
 
 
-    const generatedText = getGeneratedText(endMapping, generatedState);
+    const generatedText = getGeneratedText(endMapping, state);
 
-    // actual generatedOffset < range endOffset
+    // actual generatedOffset < endOffset
     const generatedPos = range.endOffset - endMapping.generatedOffset;
 
     const originalPos = getOriginalEndPosition(originalText, generatedText, generatedPos);
 
-    // if (originalState.sourcePath.endsWith('v8/src/app.vue') && range.count === 0) {
+    // if (originalState.sourcePath.endsWith('v8/src/app.vue')) {
     //     console.log('====================================================================');
     //     console.log('fix endMapping', originalState.sourcePath);
     //     console.log(startMapping, endMapping);
@@ -429,14 +447,17 @@ const isOffsetCrossLine = (startMapping, offset) => {
     return false;
 };
 
-const findStartMapping = (range, generatedState, originalMap) => {
+const findStartMapping = (range, state, originalMap) => {
 
     // startOffset: inclusive
     const startOffset = range.startOffset;
 
-    const startMapping = findOffsetMapping(generatedState, startOffset);
-    if (!startMapping) {
-        return;
+    const startMapping = findOffsetMapping(state, startOffset);
+    if (startMapping.error) {
+        return {
+            error: true,
+            errors: startMapping.errors.concat(`not found start mapping: ${startOffset}`)
+        };
     }
 
     // check end offset for start mapping only
@@ -444,17 +465,23 @@ const findStartMapping = (range, generatedState, originalMap) => {
     // but end mapping is exclusive and offset do -1, possible no mapping found, do not check it
     if (isOffsetCrossLine(startMapping, startOffset)) {
         // try next mapping if its offset in the range
-        const nextMapping = findNextGeneratedDiffMapping(generatedState, startMapping);
+        const nextMapping = findNextGeneratedDiffMapping(state, startMapping);
         if (!nextMapping) {
-            return;
+            return {
+                error: true,
+                errors: [`not found next generated mapping: ${startMapping}`]
+            };
         }
 
         // ignore out of range
         if (nextMapping.generatedOffset >= range.endOffset) {
-            return;
+            return {
+                error: true,
+                errors: [`next generated mapping is out of end offset: ${nextMapping.generatedOffset} >= ${range.endOffset}`]
+            };
         }
 
-        // if (startMapping.sourceIndex === 1 && range.count === 0) {
+        // if (startMapping.sourceIndex === 1) {
         //     console.log('=========================================================');
         //     console.log('find next start');
         //     console.log(startMapping, nextMapping, range);
@@ -474,7 +501,10 @@ const findStartMapping = (range, generatedState, originalMap) => {
 
     const originalState = originalMap.get(sourceIndex);
     if (!originalState) {
-        return;
+        return {
+            error: true,
+            errors: [`not found original state by source index: ${sourceIndex}`]
+        };
     }
 
     return {
@@ -484,24 +514,30 @@ const findStartMapping = (range, generatedState, originalMap) => {
 };
 
 
-const findEndMapping = (range, generatedState, startMapping) => {
+const findEndMapping = (range, state, startMapping) => {
 
     // endOffset: exclusive
     const endOffset = range.endOffset;
 
     // there could be some comments before end mapping even exact matched
-    const endMapping = findOffsetMapping(generatedState, endOffset - 1);
-    if (!endMapping) {
-        return;
+    const endMapping = findOffsetMapping(state, endOffset - 1);
+    if (endMapping.error) {
+        return {
+            error: true,
+            errors: startMapping.errors.concat(`not found end mapping: ${endOffset} - 1 (exclusive)`)
+        };
     }
 
     // cross file ignore
     if (endMapping.sourceIndex !== startMapping.sourceIndex) {
-        return;
+        return {
+            error: true,
+            errors: [`The source index of start and end are not equal: ${startMapping.sourceIndex} != ${endMapping.sourceIndex}`]
+        };
     }
 
     // still exclusive
-    const exclusiveMapping = findOffsetMapping(generatedState, endOffset);
+    const exclusiveMapping = findOffsetMapping(state, endOffset);
     if (exclusiveMapping && exclusiveMapping.originalOffset === endMapping.originalOffset) {
         endMapping.exclusive = true;
     }
@@ -509,14 +545,16 @@ const findEndMapping = (range, generatedState, startMapping) => {
     return endMapping;
 };
 
-const findOriginalRange = (range, generatedState, originalMap) => {
+const findOriginalRange = (range, state, originalMap) => {
 
     // startOffset: inclusive
     // endOffset: exclusive
-
-    const startResult = findStartMapping(range, generatedState, originalMap);
-    if (!startResult) {
-        return;
+    const startResult = findStartMapping(range, state, originalMap);
+    if (startResult.error) {
+        return {
+            error: true,
+            errors: startResult.errors.concat(`not found start mapping: ${range.startOffset}`)
+        };
     }
     const { startMapping, originalState } = startResult;
 
@@ -531,38 +569,44 @@ const findOriginalRange = (range, generatedState, originalMap) => {
     // }
     // ==================================================================================
 
-    const endMapping = findEndMapping(range, generatedState, startMapping);
-    if (!endMapping) {
-        return;
+    const endMapping = findEndMapping(range, state, startMapping);
+    if (endMapping.error) {
+        return {
+            error: true,
+            errors: endMapping.errors.concat(`not found end mapping: ${range.endOffset}`)
+        };
     }
 
     // fix start
-    fixStartColumn(startMapping, range, generatedState, originalState);
+    fixStartColumn(startMapping, range, state, originalState);
 
     // fix end
-    fixEndColumn(endMapping, range, startMapping, generatedState, originalState);
+    fixEndColumn(endMapping, range, startMapping, state, originalState);
 
-    const positionMapping = originalState.positionMapping;
-    const originalStart = positionMapping.locationToOffset({
+    const locator = originalState.locator;
+    const originalStart = locator.locationToOffset({
         line: startMapping.originalLine + 1,
         column: startMapping.column
     });
-    const originalEnd = positionMapping.locationToOffset({
+    const originalEnd = locator.locationToOffset({
         line: endMapping.originalLine + 1,
         column: endMapping.column
     });
 
     // range start greater than end
-    if (originalStart >= originalEnd) {
-        // console.log(`start >= end: ${originalState.sourcePath}`);
+    if (originalStart > originalEnd) {
+        // console.log(`start > end: ${originalState.sourcePath}`);
         // console.log(range, originalRange);
-        return;
+        return {
+            error: true,
+            errors: [`original start is greater than end: ${originalStart} > ${originalEnd}`]
+        };
     }
 
     const originalRange = {
+        ... range,
         startOffset: originalStart,
-        endOffset: originalEnd,
-        count: range.count
+        endOffset: originalEnd
     };
 
     // if (originalState.showLog) {
@@ -573,7 +617,9 @@ const findOriginalRange = (range, generatedState, originalMap) => {
 
     return {
         originalRange,
-        originalState
+        originalState,
+        startMapping,
+        endMapping
     };
 
 };

package/lib/converter/info-branch.js

@@ -1,30 +1,29 @@
 module.exports = class InfoBranch {
-    constructor(sLoc, eLoc, count) {
-        this.startLine = sLoc.line;
-        this.startColumn = sLoc.column;
-        this.endLine = eLoc.line;
-        this.endColumn = eLoc.column;
-        this.count = count;
+    constructor(loc, locations, type) {
+        this.loc = loc;
+        this.line = loc.start.line;
+        // [ { start:{line,column}, end:{line,column}, count }, ...]
+        this.locations = locations;
+        this.type = type || 'branch';
     }
 
     generate() {
-        const location = {
-            start: {
-                line: this.startLine,
-                column: this.startColumn
-            },
-            end: {
-                line: this.endLine,
-                column: this.endColumn
-            }
-        };
         return {
-            type: 'branch',
-            line: this.startLine,
-            loc: location,
-            locations: [{
-                ... location
-            }]
+            loc: this.loc,
+            type: this.type,
+            locations: this.locations.map((item) => {
+                const { start, end } = item;
+                return {
+                    start: start || {},
+                    end: end || {}
+                };
+
+            }),
+            line: this.line
         };
     }
+
+    generateCounts() {
+        return this.locations.map((item) => item.count);
+    }
 };

package/lib/converter/info-function.js

@@ -1,29 +1,17 @@
 module.exports = class InfoFunction {
-    constructor(sLoc, eLoc, count, name) {
-        this.startLine = sLoc.line;
-        this.startColumn = sLoc.column;
-        this.endLine = eLoc.line;
-        this.endColumn = eLoc.column;
+    constructor(loc, count, name) {
+        this.loc = loc;
+        this.line = loc.start.line;
         this.count = count;
         this.name = name || '(anonymous)';
     }
 
     generate() {
-        const loc = {
-            start: {
-                line: this.startLine,
-                column: this.startColumn
-            },
-            end: {
-                line: this.endLine,
-                column: this.endColumn
-            }
-        };
         return {
             name: this.name,
-            decl: loc,
-            loc: loc,
-            line: this.startLine
+            decl: this.loc,
+            loc: this.loc,
+            line: this.line
         };
     }
 };

package/lib/converter/info-line.js

@@ -1,8 +1,11 @@
 module.exports = class InfoLine {
     constructor(line, column, count = 1) {
+        // 1 based
         this.line = line;
         this.column = column;
         this.count = count;
+        // covered full line, could be false even count > 0
+        this.covered = count > 0;
     }
 
     generate() {

package/lib/generate.js

@@ -67,8 +67,12 @@ const getReportGroup = (reports, lcov, dataType) => {
     }
 
     const allSupportedReports = [
+
+        // v8
         'v8',
         'v8-json',
+
+        // istanbul
         'clover',
         'cobertura',
         'html',

package/lib/istanbul/istanbul.js

@@ -7,7 +7,7 @@ const istanbulLibReport = require('istanbul-lib-report');
 const Util = require('../utils/util.js');
 const IstanbulSummary = require('./istanbul-summary.js');
 
-const { initIstanbulSourcePath } = require('../converter/source-path.js');
+const { initIstanbulSourcePath } = require('../utils/source-path.js');
 
 const findHtmlPath = (outputDir) => {
     const defaultHtml = path.resolve(outputDir, 'index.html');