| /* | |
| 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').FileCoverage; | |
| const CoverageSummary = require('./file').CoverageSummary; | |
| function loadMap(source) { | |
| const data = Object.create(null); | |
| Object.keys(source).forEach(k => { | |
| const cov = source[k]; | |
| if (cov instanceof FileCoverage) { | |
| data[k] = cov; | |
| } else { | |
| data[k] = new FileCoverage(cov); | |
| } | |
| }); | |
| return data; | |
| } | |
| /** | |
| * CoverageMap is a map of `FileCoverage` objects keyed by file paths. | |
| * @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 | |
| */ | |
| function CoverageMap(obj) { | |
| if (!obj) { | |
| this.data = Object.create(null); | |
| } else 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. | |
| */ | |
| CoverageMap.prototype.merge = function(obj) { | |
| let other; | |
| if (obj instanceof CoverageMap) { | |
| other = obj; | |
| } else { | |
| other = new CoverageMap(obj); | |
| } | |
| Object.keys(other.data).forEach(k => { | |
| const fc = other.data[k]; | |
| if (this.data[k]) { | |
| this.data[k].merge(fc); | |
| } else { | |
| this.data[k] = 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. | |
| */ | |
| CoverageMap.prototype.filter = function(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} | |
| */ | |
| CoverageMap.prototype.toJSON = function() { | |
| return this.data; | |
| }; | |
| /** | |
| * returns an array for file paths for which this map has coverage | |
| * @returns {Array{string}} - array of files | |
| */ | |
| CoverageMap.prototype.files = function() { | |
| return Object.keys(this.data); | |
| }; | |
| /** | |
| * returns the file coverage for the specified file. | |
| * @param {String} file | |
| * @returns {FileCoverage} | |
| */ | |
| CoverageMap.prototype.fileCoverageFor = function(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 | |
| */ | |
| CoverageMap.prototype.addFileCoverage = function(fc) { | |
| const cov = new FileCoverage(fc); | |
| const path = cov.path; | |
| 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} | |
| */ | |
| CoverageMap.prototype.getCoverageSummary = function() { | |
| const ret = new CoverageSummary(); | |
| this.files().forEach(key => { | |
| ret.merge(this.fileCoverageFor(key).toSummary()); | |
| }); | |
| return ret; | |
| }; | |
| module.exports = { | |
| CoverageMap | |
| }; |