monocart-coverage-reports 2.10.9 → 2.11.0

package/lib/reports/raw.js

@@ -1,19 +1,90 @@
 const fs = require('fs');
 const path = require('path');
 const Util = require('../utils/util.js');
+const { ZipFile } = require('../packages/monocart-coverage-vendor.js');
+const { mergeIstanbulDataList } = require('../istanbul/istanbul.js');
+const { mergeV8DataList } = require('../v8/v8.js');
 
-const rawReport = (reportData, reportOptions, options) => {
+const getMergedData = (type, dataList) => {
+    if (type === 'istanbul') {
+        return mergeIstanbulDataList(dataList);
+    }
+    return mergeV8DataList(dataList);
+};
+
+const mergeReport = async (rawDir, rawParent) => {
+    const coverageFiles = fs.readdirSync(rawDir).filter((n) => n.endsWith('.json') && n.startsWith('coverage-'));
+    // console.log(coverageFiles);
+
+    let type;
+    const dataList = [];
+    for (const coverageFile of coverageFiles) {
+        const jsonPath = path.resolve(rawDir, coverageFile);
+        const json = await Util.readJson(jsonPath);
+        if (json) {
+            // 'id', 'type', 'data'
+            type = json.type;
+            dataList.push(json);
+        }
+        Util.rmSync(jsonPath);
+    }
+
+    const mergedData = await getMergedData(type, dataList);
+
+    const dataId = Util.uid();
+    const results = {
+        id: dataId,
+        type,
+        data: mergedData
+    };
+
+    const { cachePath } = Util.getCacheFileInfo('coverage', `${dataId}.merged`, rawDir);
+    await Util.writeFile(cachePath, JSON.stringify(results));
+
+};
+
+const zipReport = (rawDir, rawParent) => {
+    const zipName = path.basename(rawDir);
+    const zipPath = path.resolve(rawParent, `${zipName}.zip`);
+
+    return new Promise((resolve) => {
+        const zipFile = new ZipFile();
+        zipFile.outputStream.pipe(fs.createWriteStream(zipPath)).on('close', function() {
+
+            // remove raw files after zip
+            Util.rmSync(rawDir);
+
+            resolve();
+
+            // console.log('done');
+        });
+        const list = fs.readdirSync(rawDir);
+        list.forEach((jsonName) => {
+            zipFile.addFile(path.resolve(rawDir, jsonName), `${zipName}/${jsonName}`);
+        });
+        zipFile.end();
+    });
+};
+
+const rawReport = async (reportData, reportOptions, options) => {
     const rawOptions = {
         outputDir: 'raw',
+        merge: false,
+        zip: false,
         ... reportOptions
     };
 
     const cacheDir = options.cacheDir;
+    if (!fs.existsSync(cacheDir)) {
+        // there is no cache if only inputDir
+        Util.logInfo('There is no cache dir for "raw" report');
+        return;
+    }
+
     const rawDir = path.resolve(options.outputDir, rawOptions.outputDir);
     // console.log(rawDir, cacheDir);
     if (fs.existsSync(rawDir)) {
-        Util.logError(`Failed to save raw report because the dir already exists: ${Util.relativePath(rawDir)}`);
-        return;
+        Util.rmSync(rawDir);
     }
 
     const rawParent = path.dirname(rawDir);
@@ -26,6 +97,17 @@ const rawReport = (reportData, reportOptions, options) => {
     // just rename the cache folder name
     fs.renameSync(cacheDir, rawDir);
 
+    // merge
+    if (rawOptions.merge) {
+        await mergeReport(rawDir, rawParent);
+    }
+
+    // zip
+    if (rawOptions.zip) {
+        await zipReport(rawDir, rawParent);
+    }
+
+
 };
 
 module.exports = {

package/lib/utils/dedupe.js

@@ -1,8 +1,12 @@
+/**
+ * The ranges are first ordered by ascending `startOffset` and then by descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
 
 const sortRanges = (ranges) => {
     ranges.sort((a, b) => {
         if (a.start === b.start) {
-            return a.end - b.end;
+            return b.end - a.end;
         }
         return a.start - b.start;
     });
@@ -33,8 +37,9 @@ const dedupeFlatRanges = (ranges) => {
             if (range.end === prevRange.end) {
                 return prevRange;
             }
-            // great than the prev end, update the end
-            prevRange.end = range.end;
+
+            // less than prev end after new sort
+
             return prevRange;
         }
 

package/lib/utils/merge/merge.js

@@ -0,0 +1,439 @@
+/**
+ * The `mergeV8Coverage` was extracted from following repos for fixing several issues
+ * https://github.com/bcoe/v8-coverage
+ * https://github.com/demurgos/v8-coverage
+ */
+
+const RangeTree = require('./range-tree.js');
+
+
+/**
+ * Compares two range coverages.
+ *
+ * The ranges are first ordered by ascending `startOffset` and then by
+ * descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
+function compareRangeCovs(a, b) {
+    if (a.startOffset !== b.startOffset) {
+        return a.startOffset - b.startOffset;
+    }
+    return b.endOffset - a.endOffset;
+}
+
+/**
+ * Compares two function coverages.
+ *
+ * The result corresponds to the comparison of the root ranges.
+ */
+function compareFunctionCovs(a, b) {
+    return compareRangeCovs(a.ranges[0], b.ranges[0]);
+}
+
+/**
+ * @precodition `ranges` are well-formed and pre-order sorted
+ */
+function fromSortedRanges(ranges) {
+    let root;
+    // Stack of parent trees and parent counts.
+    const stack = [];
+    for (const range of ranges) {
+        const node = new RangeTree(range.startOffset, range.endOffset, range.count, []);
+        if (!root) {
+            root = node;
+            stack.push([node, range.count]);
+            continue;
+        }
+        let parent;
+        let parentCount;
+        while (true) {
+            [parent, parentCount] = stack[stack.length - 1];
+            // assert: `top !== undefined` (the ranges are sorted)
+            if (range.startOffset < parent.end) {
+                break;
+            } else {
+                stack.pop();
+            }
+
+            // prevent crash when v8 incorrectly merges static_initializer's
+            if (stack.length === 0) {
+                break;
+            }
+        }
+        node.delta -= parentCount;
+        parent.children.push(node);
+        stack.push([node, range.count]);
+    }
+    return root;
+}
+
+/**
+ * Normalizes a function coverage.
+ *
+ * Sorts the ranges (pre-order sort).
+ * TODO: Tree-based normalization of the ranges.
+ *
+ * @param funcCov Function coverage to normalize.
+ */
+function normalizeFunctionCov(funcCov) {
+    funcCov.ranges.sort(compareRangeCovs);
+    const tree = fromSortedRanges(funcCov.ranges);
+    tree.normalize();
+    funcCov.ranges = tree.toRanges();
+}
+
+/**
+ * Normalizes a script coverage.
+ *
+ * Sorts the function by root range (pre-order sort).
+ * This does not normalize the function coverages.
+ *
+ * @param scriptCov Script coverage to normalize.
+ */
+function normalizeScriptCov(scriptCov) {
+    scriptCov.functions.sort(compareFunctionCovs);
+}
+
+
+/**
+ * Normalizes a script coverage deeply.
+ *
+ * Normalizes the function coverages deeply, then normalizes the script coverage
+ * itself.
+ *
+ * @param scriptCov Script coverage to normalize.
+ */
+function deepNormalizeScriptCov(scriptCov) {
+    for (const funcCov of scriptCov.functions) {
+        normalizeFunctionCov(funcCov);
+    }
+    normalizeScriptCov(scriptCov);
+}
+
+
+/**
+ * Returns a string representation of the root range of the function.
+ *
+ * This string can be used to match function with same root range.
+ * The string is derived from the start and end offsets of the root range of
+ * the function.
+ * This assumes that `ranges` is non-empty (true for valid function coverages).
+ *
+ * @param funcCov Function coverage with the range to stringify
+ * @internal
+ */
+function stringifyFunctionRootRange(funcCov) {
+    const rootRange = funcCov.ranges[0];
+    return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`;
+}
+
+
+function insertChild(parentToNested, parentIndex, tree) {
+    let nested = parentToNested.get(parentIndex);
+    if (!nested) {
+        nested = [];
+        parentToNested.set(parentIndex, nested);
+    }
+    nested.push(tree);
+}
+
+function nextChild(openRange, parentToNested) {
+    const matchingTrees = [];
+
+    for (const nested of parentToNested.values()) {
+        if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) {
+            matchingTrees.push(nested[0]);
+        } else {
+            matchingTrees.push(new RangeTree(
+                openRange.start,
+                openRange.end,
+                0,
+                nested
+            ));
+        }
+    }
+    parentToNested.clear();
+    return mergeRangeTrees(matchingTrees);
+}
+
+class StartEventQueue {
+
+    constructor(queue) {
+        this.queue = queue;
+        this.nextIndex = 0;
+        this.pendingOffset = 0;
+        this.pendingTrees = null;
+    }
+
+    setPendingOffset(offset) {
+        this.pendingOffset = offset;
+    }
+
+    pushPendingTree(tree) {
+        if (this.pendingTrees === null) {
+            this.pendingTrees = [];
+        }
+        this.pendingTrees.push(tree);
+    }
+
+    next() {
+        const pendingTrees = this.pendingTrees;
+        const nextEvent = this.queue[this.nextIndex];
+        if (pendingTrees === null) {
+            this.nextIndex++;
+            return nextEvent;
+        }
+        if (!nextEvent) {
+            this.pendingTrees = null;
+            return {
+                offset: this.pendingOffset,
+                trees: pendingTrees
+            };
+        }
+        if (this.pendingOffset < nextEvent.offset) {
+            this.pendingTrees = null;
+            return {
+                offset: this.pendingOffset,
+                trees: pendingTrees
+            };
+        }
+        if (this.pendingOffset === nextEvent.offset) {
+            this.pendingTrees = null;
+            for (const tree of pendingTrees) {
+                nextEvent.trees.push(tree);
+            }
+        }
+        this.nextIndex++;
+        return nextEvent;
+
+
+    }
+}
+
+function fromParentTrees(parentTrees) {
+    const startToTrees = new Map();
+    for (const [parentIndex, parentTree] of parentTrees.entries()) {
+        for (const child of parentTree.children) {
+            let trees = startToTrees.get(child.start);
+            if (!trees) {
+                trees = [];
+                startToTrees.set(child.start, trees);
+            }
+            trees.push({
+                parentIndex,
+                tree: child
+            });
+        }
+    }
+    const queue = [];
+    for (const [startOffset, trees] of startToTrees) {
+        queue.push({
+            offset: startOffset,
+            trees
+        });
+    }
+    queue.sort((a, b) => {
+        return a.offset - b.offset;
+    });
+    return new StartEventQueue(queue);
+}
+
+// eslint-disable-next-line complexity
+function mergeRangeTreeChildren(parentTrees) {
+    const result = [];
+    const startEventQueue = fromParentTrees(parentTrees);
+    const parentToNested = new Map();
+    let openRange = null;
+
+    while (true) {
+        const event = startEventQueue.next();
+        if (!event) {
+            break;
+        }
+
+        if (openRange !== null && openRange.end <= event.offset) {
+            result.push(nextChild(openRange, parentToNested));
+            openRange = null;
+        }
+
+        if (openRange === null) {
+            let openRangeEnd = event.offset + 1;
+            for (const { parentIndex, tree } of event.trees) {
+                openRangeEnd = Math.max(openRangeEnd, tree.end);
+                insertChild(parentToNested, parentIndex, tree);
+            }
+            startEventQueue.setPendingOffset(openRangeEnd);
+            openRange = {
+                start: event.offset, end: openRangeEnd
+            };
+        } else {
+            for (const { parentIndex, tree } of event.trees) {
+                if (tree.end > openRange.end) {
+                    const right = tree.split(openRange.end);
+                    startEventQueue.pushPendingTree({
+                        parentIndex,
+                        tree: right
+                    });
+                }
+                insertChild(parentToNested, parentIndex, tree);
+            }
+        }
+    }
+    if (openRange !== null) {
+        result.push(nextChild(openRange, parentToNested));
+    }
+
+    return result;
+}
+
+/**
+ * @precondition Same `start` and `end` for all the trees
+ */
+function mergeRangeTrees(trees) {
+    if (trees.length <= 1) {
+        return trees[0];
+    }
+    const first = trees[0];
+    let delta = 0;
+    for (const tree of trees) {
+        delta += tree.delta;
+    }
+    const children = mergeRangeTreeChildren(trees);
+    return new RangeTree(first.start, first.end, delta, children);
+}
+
+/**
+ * Merges a list of matching function coverages.
+ *
+ * Functions are matching if their root ranges have the same span.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param funcCovs Function coverages to merge.
+ * @return Merged function coverage, or `undefined` if the input list was empty.
+ */
+function mergeFunctionCovs(funcCovs) {
+    if (funcCovs.length === 0) {
+        return;
+    }
+
+    if (funcCovs.length === 1) {
+        const merged = funcCovs[0];
+        normalizeFunctionCov(merged);
+        return merged;
+    }
+
+    const first = funcCovs[0];
+    const functionName = first.functionName;
+    // assert: `first.ranges.length > 0`
+    const startOffset = first.ranges[0].startOffset;
+    const endOffset = first.ranges[0].endOffset;
+    let count = 0;
+
+    const trees = [];
+    for (const funcCov of funcCovs) {
+        // assert: `funcCov.ranges.length > 0`
+        // assert: `funcCov.ranges` is sorted
+        count += typeof funcCov.count === 'number' ? funcCov.count : funcCov.ranges[0].count;
+        if (funcCov.isBlockCoverage) {
+            trees.push(fromSortedRanges(funcCov.ranges));
+        }
+    }
+
+    let isBlockCoverage;
+    let ranges;
+    if (trees.length > 0) {
+        isBlockCoverage = true;
+        const mergedTree = mergeRangeTrees(trees);
+        mergedTree.normalize();
+        ranges = mergedTree.toRanges();
+    } else {
+        isBlockCoverage = false;
+        ranges = [{
+            startOffset,
+            endOffset,
+            count
+        }];
+    }
+
+    const merged = {
+        functionName,
+        ranges,
+        isBlockCoverage
+    };
+    if (count !== ranges[0].count) {
+        merged.count = count;
+    }
+    // assert: `merged` is normalized
+    return merged;
+}
+
+
+/**
+ * Merges a list of matching script coverages.
+ *
+ * Scripts are matching if they have the same `url`.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param scriptCovs Process coverages to merge.
+ * @return Merged script coverage, or `undefined` if the input list was empty.
+ */
+
+// eslint-disable-next-line complexity
+function mergeV8Coverage(scriptCovs) {
+    if (!Array.isArray(scriptCovs)) {
+        return {
+            functions: []
+        };
+    }
+
+    if (scriptCovs.length === 0) {
+        return {
+            functions: []
+        };
+    }
+
+    if (scriptCovs.length === 1) {
+        const merged = scriptCovs[0];
+        deepNormalizeScriptCov(merged);
+        return merged;
+    }
+
+
+    const rangeToFuncs = new Map();
+    for (const scriptCov of scriptCovs) {
+        for (const funcCov of scriptCov.functions) {
+            const rootRange = stringifyFunctionRootRange(funcCov);
+            let funcCovs = rangeToFuncs.get(rootRange);
+            if (!funcCovs) {
+                funcCovs = [];
+                rangeToFuncs.set(rootRange, funcCovs);
+            }
+            funcCovs.push(funcCov);
+        }
+    }
+
+    const functions = [];
+    for (const funcCovs of rangeToFuncs.values()) {
+        // assert: `funcCovs.length > 0`
+        const block = mergeFunctionCovs(funcCovs);
+        if (block) {
+            functions.push(block);
+        }
+    }
+
+    const merged = {
+        functions
+    };
+    normalizeScriptCov(merged);
+    return merged;
+}
+
+module.exports = {
+    mergeV8Coverage
+};

package/lib/utils/merge/range-tree.js

@@ -0,0 +1,123 @@
+class RangeTree {
+
+    constructor(
+        start,
+        end,
+        delta,
+        children
+    ) {
+        this.start = start;
+        this.end = end;
+        this.delta = delta;
+        this.children = children;
+    }
+
+    // eslint-disable-next-line complexity
+    normalize() {
+        const children = [];
+        let curEnd;
+        let head;
+        const tail = [];
+        for (const child of this.children) {
+            if (!head) {
+                head = child;
+            } else if (child.delta === head.delta && child.start === curEnd) {
+                tail.push(child);
+            } else {
+                endChain();
+                head = child;
+            }
+            curEnd = child.end;
+        }
+        if (head) {
+            endChain();
+        }
+
+        if (children.length === 1) {
+            const child = children[0];
+            if (child.start === this.start && child.end === this.end) {
+                this.delta += child.delta;
+                this.children = child.children;
+                // `.lazyCount` is zero for both (both are after normalization)
+                return;
+            }
+        }
+
+        this.children = children;
+
+        function endChain() {
+            if (tail.length !== 0) {
+                head.end = tail[tail.length - 1].end;
+                for (const tailTree of tail) {
+                    for (const subChild of tailTree.children) {
+                        subChild.delta += tailTree.delta - head.delta;
+                        head.children.push(subChild);
+                    }
+                }
+                tail.length = 0;
+            }
+            head.normalize();
+            children.push(head);
+        }
+    }
+
+    /**
+     * @precondition `tree.start < value && value < tree.end`
+     * @return RangeTree Right part
+     */
+    split(value) {
+        let leftChildLen = this.children.length;
+        let mid;
+
+        // TODO(perf): Binary search (check overhead)
+        for (let i = 0; i < this.children.length; i++) {
+            const child = this.children[i];
+            if (child.start < value && value < child.end) {
+                mid = child.split(value);
+                leftChildLen = i + 1;
+                break;
+            } else if (child.start >= value) {
+                leftChildLen = i;
+                break;
+            }
+        }
+
+        const rightLen = this.children.length - leftChildLen;
+        const rightChildren = this.children.splice(leftChildLen, rightLen);
+        if (mid) {
+            rightChildren.unshift(mid);
+        }
+        const result = new RangeTree(
+            value,
+            this.end,
+            this.delta,
+            rightChildren
+        );
+        this.end = value;
+        return result;
+    }
+
+    /**
+     * Get the range coverages corresponding to the tree.
+     *
+     * The ranges are pre-order sorted.
+     */
+    toRanges() {
+        const ranges = [];
+        // Stack of parent trees and counts.
+        const stack = [[this, 0]];
+        while (stack.length > 0) {
+            const [cur, parentCount] = stack.pop();
+            const count = parentCount + cur.delta;
+            ranges.push({
+                startOffset: cur.start, endOffset: cur.end, count
+            });
+            for (let i = cur.children.length - 1; i >= 0; i--) {
+                stack.push([cur.children[i], count]);
+            }
+        }
+        return ranges;
+    }
+}
+
+module.exports = RangeTree;