.

qwen/nodejs/node_modules/istanbul-lib-coverage/lib/coverage-map.js

@@ -0,0 +1,134 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const { FileCoverage } = require('./file-coverage');
+const { CoverageSummary } = require('./coverage-summary');
+
+function maybeConstruct(obj, klass) {
+    if (obj instanceof klass) {
+        return obj;
+    }
+
+    return new klass(obj);
+}
+
+function loadMap(source) {
+    const data = Object.create(null);
+    if (!source) {
+        return data;
+    }
+
+    Object.entries(source).forEach(([k, cov]) => {
+        data[k] = maybeConstruct(cov, FileCoverage);
+    });
+
+    return data;
+}
+
+/** CoverageMap is a map of `FileCoverage` objects keyed by file paths. */
+class CoverageMap {
+    /**
+     * @constructor
+     * @param {Object} [obj=undefined] obj A coverage map from which to initialize this
+     * map's contents. This can be the raw global coverage object.
+     */
+    constructor(obj) {
+        if (obj instanceof CoverageMap) {
+            this.data = obj.data;
+        } else {
+            this.data = loadMap(obj);
+        }
+    }
+
+    /**
+     * merges a second coverage map into this one
+     * @param {CoverageMap} obj - a CoverageMap or its raw data. Coverage is merged
+     *  correctly for the same files and additional file coverage keys are created
+     *  as needed.
+     */
+    merge(obj) {
+        const other = maybeConstruct(obj, CoverageMap);
+        Object.values(other.data).forEach(fc => {
+            this.addFileCoverage(fc);
+        });
+    }
+
+    /**
+     * filter the coveragemap based on the callback provided
+     * @param {Function (filename)} callback - Returns true if the path
+     *  should be included in the coveragemap. False if it should be
+     *  removed.
+     */
+    filter(callback) {
+        Object.keys(this.data).forEach(k => {
+            if (!callback(k)) {
+                delete this.data[k];
+            }
+        });
+    }
+
+    /**
+     * returns a JSON-serializable POJO for this coverage map
+     * @returns {Object}
+     */
+    toJSON() {
+        return this.data;
+    }
+
+    /**
+     * returns an array for file paths for which this map has coverage
+     * @returns {Array{string}} - array of files
+     */
+    files() {
+        return Object.keys(this.data);
+    }
+
+    /**
+     * returns the file coverage for the specified file.
+     * @param {String} file
+     * @returns {FileCoverage}
+     */
+    fileCoverageFor(file) {
+        const fc = this.data[file];
+        if (!fc) {
+            throw new Error(`No file coverage available for: ${file}`);
+        }
+        return fc;
+    }
+
+    /**
+     * adds a file coverage object to this map. If the path for the object,
+     * already exists in the map, it is merged with the existing coverage
+     * otherwise a new key is added to the map.
+     * @param {FileCoverage} fc the file coverage to add
+     */
+    addFileCoverage(fc) {
+        const cov = new FileCoverage(fc);
+        const { path } = cov;
+        if (this.data[path]) {
+            this.data[path].merge(cov);
+        } else {
+            this.data[path] = cov;
+        }
+    }
+
+    /**
+     * returns the coverage summary for all the file coverage objects in this map.
+     * @returns {CoverageSummary}
+     */
+    getCoverageSummary() {
+        const ret = new CoverageSummary();
+        Object.values(this.data).forEach(fc => {
+            ret.merge(fc.toSummary());
+        });
+
+        return ret;
+    }
+}
+
+module.exports = {
+    CoverageMap
+};