monocart-reporter 1.7.1 → 1.7.2

package/lib/plugins/coverage/converter/position-mapping.js

@@ -0,0 +1,183 @@
+
+const findLine = function(list, position) {
+    let start = 0;
+    let end = list.length - 1;
+    while (end - start > 1) {
+        const i = Math.floor((start + end) * 0.5);
+        const item = list[i];
+        if (position < item.start) {
+            end = i;
+            continue;
+        }
+        if (position > item.end) {
+            start = i;
+            continue;
+        }
+        return list[i];
+    }
+    // last two items, less is start
+    const endItem = list[end];
+    if (position < endItem.start) {
+        return list[start];
+    }
+    return list[end];
+};
+
+// =======================================================================================
+
+const isLineSingleCommented = (codeStr) => {
+    const singleBlock = /^\s*\/\//g;
+    return singleBlock.test(codeStr);
+};
+
+const isLineStartCommented = (codeStr) => {
+    const multiStartBlock = /^\s*\/\*/g;
+    return multiStartBlock.test(codeStr);
+};
+
+// multi-comment end but not at end
+const isLineEndCommented = (codeStr) => {
+    const multiEndBlock = /.*\*\//g;
+    return multiEndBlock.test(codeStr);
+};
+
+const isLineEndCommentedToEnd = (codeStr) => {
+    const multiEndBlock = /.*\*\/\s*$/g;
+    return multiEndBlock.test(codeStr);
+};
+
+const isLineBlank = (codeStr) => {
+    const blankBlock = /\S/;
+    return !blankBlock.test(codeStr);
+};
+
+class PositionMapping {
+    constructor(source) {
+        this.source = source;
+        this.lines = this.buildLines(source);
+        this.commentedLines = [];
+        this.blankLines = [];
+        this.parseLines(this.lines);
+    }
+
+    // =============================================================================
+
+    getSlice(s, e) {
+        return this.source.slice(s, e);
+    }
+
+    // 1-base
+    locationToOffset(location) {
+        const { line, column } = location;
+        // 1-based
+        const lineInfo = this.lines[line - 1];
+        if (lineInfo) {
+            if (column === Infinity) {
+                return lineInfo.start + lineInfo.length;
+            }
+            return lineInfo.start + column;
+        }
+        return 0;
+    }
+
+    // 1-base
+    offsetToLocation(offset) {
+        const lineInfo = findLine(this.lines, offset);
+
+        let indent = lineInfo.text.search(/\S/);
+        if (indent === -1) {
+            indent = lineInfo.length;
+        }
+
+        // 1-base
+        const line = lineInfo.line + 1;
+        const column = Math.min(Math.max(offset - lineInfo.start, 0), lineInfo.length);
+
+        return {
+            ... lineInfo,
+            line,
+            column,
+            indent
+        };
+    }
+
+    // 1-base
+    getLine(line) {
+        return this.lines[line - 1];
+    }
+
+    // =============================================================================
+
+    buildLines(content) {
+        let pos = 0;
+        const lines = content.split(/\n/).map((text, line) => {
+
+            let n = 1;
+            // may ends with \r (don't consider double \r\r for now)
+            const reg = /\r$/;
+            if (reg.test(text)) {
+                text = text.slice(0, -1);
+                n += 1;
+            }
+
+            const length = text.length;
+            const start = pos;
+            const end = start + length;
+
+            pos += length + n;
+
+            return {
+                line,
+                start,
+                end,
+                length,
+                text
+            };
+        });
+
+        return lines;
+    }
+
+    parseLines(lines) {
+        const commentedLines = [];
+        const blankLines = [];
+
+        let startCommented = false;
+
+        const multiEndHandler = (text, i) => {
+            if (isLineEndCommented(text)) {
+                startCommented = false;
+                if (isLineEndCommentedToEnd(text)) {
+                    commentedLines.push(i);
+                }
+                return;
+            }
+            commentedLines.push(i);
+        };
+
+        lines.forEach((line, i) => {
+            const text = line.text;
+            if (startCommented) {
+                return multiEndHandler(text, i);
+            }
+            if (isLineStartCommented(text)) {
+                startCommented = true;
+                return multiEndHandler(text, i);
+            }
+            if (isLineSingleCommented(text)) {
+                commentedLines.push(i);
+                return;
+            }
+            if (isLineBlank(text)) {
+                blankLines.push(i);
+            }
+        });
+
+        this.commentedLines = commentedLines;
+        this.blankLines = blankLines;
+    }
+
+}
+
+module.exports = PositionMapping;
+

package/lib/plugins/coverage/{coverage-utils.js → converter/source-path.js}

@@ -1,13 +1,5 @@
-const Util = require('../../utils/util.js');
-
-const sortRanges = (ranges) => {
-    ranges.sort((a, b) => {
-        if (a.start === b.start) {
-            return a.end - b.end;
-        }
-        return a.start - b.start;
-    });
-};
+const path = require('path');
+const Util = require('../../../utils/util.js');
 
 const resolveUrl = (input) => {
     let url;
@@ -65,6 +57,19 @@ const getSourcePath = (url, index = '', type = '') => {
     return filterPath(relPath);
 };
 
+const getSourceType = (sourcePath) => {
+    let ext = path.extname(sourcePath);
+    let type = '';
+    if (ext) {
+        ext = ext.slice(1);
+        const reg = /^[a-z0-9]+$/;
+        if (reg.test(ext)) {
+            type = ext;
+        }
+    }
+    return type;
+};
+
 // ========================================================================================================
 
 const mergeSourceRoot = (sourceRoot, sourceName) => {
@@ -74,51 +79,30 @@ const mergeSourceRoot = (sourceRoot, sourceName) => {
     return sourceRoot + sourceName;
 };
 
-const initSourceMapRootAndUrl = (sourceMap, fileUrls, fileSources) => {
+const initSourceMapSourcePath = (sourceMap, fileUrls, sourcePathHandler) => {
     // reset sourceRoot
     const sourceRoot = sourceMap.sourceRoot || '';
     sourceMap.sourceRoot = '';
 
     sourceMap.sources = sourceMap.sources.map((sourceName, i) => {
         const sourceUrl = mergeSourceRoot(sourceRoot, sourceName);
-        const sourcePath = getSourcePath(sourceUrl, i + 1);
-        fileUrls[sourcePath] = sourceUrl;
-        fileSources[sourcePath] = sourceMap.sourcesContent[i];
-        return sourcePath;
-    });
 
-};
-
-// ================================================================================================
-
-const convertFunctionsToRanges = (functions) => {
-
-    if (!Util.isList(functions)) {
-        return [];
-    }
-
-    const ranges = [];
-    for (const fun of functions) {
-        if (fun.ranges) {
-            for (const range of fun.ranges) {
-                // rename startOffset/endOffset to start/end, keep count
-                ranges.push({
-                    start: range.startOffset,
-                    end: range.endOffset,
-                    count: range.count
-                });
+        let sourcePath = getSourcePath(sourceUrl, i + 1);
+        if (typeof sourcePathHandler === 'function') {
+            const newSourcePath = sourcePathHandler(sourcePath);
+            if (typeof newSourcePath === 'string' && newSourcePath) {
+                sourcePath = newSourcePath;
             }
         }
-    }
 
-    sortRanges(ranges);
+        fileUrls[sourcePath] = sourceUrl;
+        return sourcePath;
+    });
 
-    return ranges;
 };
 
 module.exports = {
-    sortRanges,
     getSourcePath,
-    initSourceMapRootAndUrl,
-    convertFunctionsToRanges
+    getSourceType,
+    initSourceMapSourcePath
 };

package/lib/plugins/coverage/coverage.js

@@ -1,15 +1,15 @@
 const fs = require('fs');
 const path = require('path');
-const EC = require('eight-colors');
 
 const Util = require('../../utils/util.js');
-const { convertV8ToIstanbul, saveIstanbulReport } = require('./istanbul/istanbul.js');
+const { saveIstanbulReport } = require('./istanbul/istanbul.js');
 const {
     initV8ListAndSourcemap, mergeV8Coverage, saveV8Report
 } = require('./v8/v8.js');
 
-const { convertFunctionsToRanges } = require('./coverage-utils.js');
-const { unpackSourceMaps } = require('./v8/source-map.js');
+const { convertV8List } = require('./converter/converter.js');
+
+const artifactsDirName = '.artifacts';
 
 const defaultOptions = {
 
@@ -18,7 +18,7 @@ const defaultOptions = {
     // outputDir
     // outputName
 
-    // (Boolean) Whether to convert to Istanbul report
+    // (Boolean) Whether to convert to Istanbul report from V8 list. Defaults to `html-spa` report | (String) or using `html` report
     toIstanbul: false,
 
     // (Function) A filter function to execute for each element in the V8 list.
@@ -44,26 +44,26 @@ const defaultOptions = {
     // watermarks: [50, 80],
 
     // (Boolean) Whether inline all scripts to the single HTML file. V8 only.
-    inline: false,
+    inline: false
 
-    // (Boolean) The dist file which has source map will be included, and the temporary artifacts will not be removed.
-    debug: false
 };
 
 // ========================================================================================================
 
-const unpackV8List = async (v8list, options) => {
-    v8list.forEach((item, i) => {
-        if (item.type === 'js') {
-            item.ranges = convertFunctionsToRanges(item.functions);
-            delete item.functions;
-        }
-    });
+const generateV8ListReport = async (v8list, coverageData, fileSources, options) => {
+    const { toIstanbul, lcov } = options;
+    const istanbulReport = toIstanbul || lcov;
+    const v8Report = !toIstanbul;
 
-    // requires ranges before unpack
-    await unpackSourceMaps(v8list, options);
+    let report;
+    if (istanbulReport) {
+        report = await saveIstanbulReport(coverageData, fileSources, options);
+    }
+    if (v8Report) {
+        report = await saveV8Report(v8list, options);
+    }
 
-    // console.log(v8list.length);
+    return report;
 };
 
 // ========================================================================================================
@@ -88,6 +88,11 @@ const generateIstanbulReport = (coverageData, testInfo, options) => {
 
     const fileSources = options.fileSources || {};
 
+    // force to istanbul
+    if (!options.toIstanbul) {
+        options.toIstanbul = true;
+    }
+
     const report = saveIstanbulReport(coverageData, fileSources, options);
 
     saveReportAttachment(testInfo, report, options.htmlDir);
@@ -104,25 +109,9 @@ const generateV8Coverage = async (v8list, testInfo, options) => {
     const inlineSourceMap = true;
     v8list = await initV8ListAndSourcemap(v8list, options, inlineSourceMap);
 
-    // ================================================================
-
-    if (options.toIstanbul) {
+    const { coverageData, fileSources } = await convertV8List(v8list, options);
 
-        const { coverageData, fileSources } = await convertV8ToIstanbul(v8list, options);
-
-        const report = await saveIstanbulReport(coverageData, fileSources, options);
-
-        saveReportAttachment(testInfo, report, options.htmlDir);
-
-        return report;
-    }
-
-    // =================================================================
-
-    // functions to ranges, and unpack source maps
-    await unpackV8List(v8list, options);
-
-    const report = await saveV8Report(v8list, options);
+    const report = await generateV8ListReport(v8list, coverageData, fileSources, options);
 
     saveReportAttachment(testInfo, report, options.htmlDir);
 
@@ -131,8 +120,11 @@ const generateV8Coverage = async (v8list, testInfo, options) => {
 
 const attachCoverageReport = (coverageInput, testInfo, options = {}) => {
 
+    const reporterOptions = Util.resolveReporterOptions(testInfo);
+    Util.initLoggingLevel(reporterOptions.logging, 'coverage-attach');
+
     if (!coverageInput) {
-        EC.logRed('[MCR] invalid coverage input');
+        Util.logError('invalid coverage input');
         return;
     }
 
@@ -154,9 +146,7 @@ const attachCoverageReport = (coverageInput, testInfo, options = {}) => {
         i += 1;
     }
 
-    fs.mkdirSync(htmlDir, {
-        recursive: true
-    });
+    Util.initDir(htmlDir);
     options.htmlDir = htmlDir;
 
     if (Array.isArray(coverageInput)) {
@@ -171,12 +161,14 @@ const attachCoverageReport = (coverageInput, testInfo, options = {}) => {
 //  add coverage report to global, v8list only
 const addCoverageReport = async (v8list, testInfo) => {
 
+    const reporterOptions = Util.resolveReporterOptions(testInfo);
+    Util.initLoggingLevel(reporterOptions.logging, 'coverage-add');
+
     if (!Util.isList(v8list)) {
-        EC.logRed(`[MCR] invalid v8 list for test: ${testInfo.title}`);
+        Util.logError(`invalid v8 list for test: ${testInfo.title}`);
         return;
     }
 
-    const reporterOptions = Util.resolveReporterOptions(testInfo);
     const coverageOptions = reporterOptions.coverage || {};
 
     // reporter outputFile
@@ -192,9 +184,10 @@ const addCoverageReport = async (v8list, testInfo) => {
     };
 
     const reportDir = path.resolve(options.outputDir, options.outputName);
+    // do NOT empty dir, there are previous artifacts generated
 
     // artifactsDir for temp artifact files
-    const artifactsDir = path.resolve(reportDir, '.artifacts');
+    const artifactsDir = path.resolve(reportDir, artifactsDirName);
     options.artifactsDir = artifactsDir;
 
     const filename = `coverage-${Util.resolveTestIdWithRetry(testInfo)}.json`;
@@ -207,7 +200,6 @@ const addCoverageReport = async (v8list, testInfo) => {
     // console.log('addCoverageReport', coverageInput.map((it) => it.url));
 
     const report = {
-        // title for debug
         title: testInfo.title,
         // merge with data
         data: v8list
@@ -238,25 +230,9 @@ const getGlobalCoverageData = async (dataList, options) => {
     const v8list = await mergeV8Coverage(dataList, options);
     // console.log('after merge', v8list.map((it) => it.url));
 
-    // ================================================================
-
-    if (options.toIstanbul) {
-
-        const { coverageData, fileSources } = await convertV8ToIstanbul(v8list, options);
-
-        const report = await saveIstanbulReport(coverageData, fileSources, options);
+    const { coverageData, fileSources } = await convertV8List(v8list, options);
 
-        // console.log(report);
-
-        return report;
-    }
-
-    // ================================================================
-
-    // functions to ranges, and unpack source maps
-    await unpackV8List(v8list, options);
-
-    const report = await saveV8Report(v8list, options);
+    const report = await generateV8ListReport(v8list, coverageData, fileSources, options);
 
     return report;
 };
@@ -264,6 +240,8 @@ const getGlobalCoverageData = async (dataList, options) => {
 // global coverage report, run different process with addCoverageReport
 const generateGlobalCoverageReport = async (dataList, reporterOptions) => {
 
+    Util.logInfo('generating global coverage report ...');
+
     // reporter outputFile
     const outputFile = await Util.resolveOutputFile(reporterOptions.outputFile);
     const outputDir = path.dirname(outputFile);
@@ -278,15 +256,21 @@ const generateGlobalCoverageReport = async (dataList, reporterOptions) => {
     };
 
     const reportDir = path.resolve(options.outputDir, options.outputName);
-    if (!fs.existsSync(reportDir)) {
-        fs.mkdirSync(reportDir, {
-            recursive: true
+    // empty dir except artifacts dir
+
+    if (fs.existsSync(reportDir)) {
+        fs.readdirSync(reportDir).forEach((itemName) => {
+            if (itemName === artifactsDirName) {
+                return;
+            }
+            Util.rmSync(path.resolve(reportDir, itemName));
         });
     }
+
     options.htmlDir = reportDir;
 
     // artifactsDir for temp artifact files
-    const artifactsDir = path.resolve(reportDir, '.artifacts');
+    const artifactsDir = path.resolve(reportDir, artifactsDirName);
     options.artifactsDir = artifactsDir;
 
     const report = await getGlobalCoverageData(dataList, options);
@@ -294,7 +278,7 @@ const generateGlobalCoverageReport = async (dataList, reporterOptions) => {
 
     // =============================================================
     // remove artifacts dir after report generated
-    if (!options.debug) {
+    if (Util.loggingType !== 'debug') {
         Util.rmSync(artifactsDir);
     }
     // =============================================================