all files / lib/ CoverageTransformer.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
 
1×
 
1×
 
1×
 
1×
 
1×
 
1×
 
3×
 
1×
1×
 
1×
 
1×
 
1×
 
1×
 
 
1×
1×
 
1×
 
1×
 
1×
1×
15×
 
15×
15×
26×
 
15×
1×
3×
 
 
 
15×
15×
 
 
1×
 
 
14×
 
14×
 
14×
 
2×
2×
2×
 
 
12×
107×
107×
 
107×
 
107×
50×
 
 
 
12×
79×
79×
 
79×
 
79×
56×
 
 
 
12×
370×
370×
 
370×
 
370×
276×
 
 
 
 
 
 
13×
 
13×
15×
1×
1×
 
 
14×
14×
 
 
 
 
 
13×
 
13×
 
13×
 
13×
14×
 
14×
14×
 
 
 
13×
 
13×
 
 
1×
 
 
1×
 
'use strict';
 
var _keys = require('babel-runtime/core-js/object/keys');
 
var _keys2 = _interopRequireDefault(_keys);
 
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
 
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
 
var _createClass2 = require('babel-runtime/helpers/createClass');
 
var _createClass3 = _interopRequireDefault(_createClass2);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
var path = require('path');
var minimatch = require('minimatch');
 
var _require = require('istanbul');
 
var Collector = _require.Collector;
 
var _require2 = require('./SparceCoverageCollector');
 
var SparceCoverageCollector = _require2.SparceCoverageCollector;
 
 
var remapFunction = require('./remapFunction');
var remapBranch = require('./remapBranch');
 
var _require3 = require('./MappingProvider');
 
var MappingProvider = _require3.MappingProvider;
 
var CoverageTransformer = function () {
  function CoverageTransformer(options) {
    (0, _classCallCheck3.default)(this, CoverageTransformer);
 
    this.warn = options.warn || console.warn;
    this.exclude = function () {
      return false;
    };
    if (options.exclude) {
      this.exclude = function (fileName) {
        return minimatch(fileName, options.exclude);
      };
    }
 
    this.sparceCoverageCollector = new SparceCoverageCollector();
    this.mappingProvider = new MappingProvider(options, this.sparceCoverageCollector);
  }
 
  (0, _createClass3.default)(CoverageTransformer, [{
    key: 'addFileCoverage',
    value: function addFileCoverage(filePath, fileCoverage) {
      var _this = this;
 
      var getMappingResolved = this.mappingProvider.getMappingResolver(filePath, fileCoverage.code);
 
      if (!getMappingResolved) {
        /* We couldn't find a source map, so will copy coverage after warning. */
        this.warn(new Error('Could not find source map for: "' + filePath + '"'));
        this.sparceCoverageCollector.setCoverage(path.resolve(process.cwd(), filePath), fileCoverage);
        return;
      }
 
      (0, _keys2.default)(fileCoverage.branchMap).forEach(function (index) {
        var genItem = fileCoverage.branchMap[index];
        var hits = fileCoverage.b[index];
 
        var info = remapBranch(genItem, getMappingResolved);
 
        if (info) {
          _this.sparceCoverageCollector.updateBranch(info.source, info.srcItem, hits);
        }
      });
 
      (0, _keys2.default)(fileCoverage.fnMap).forEach(function (index) {
        var genItem = fileCoverage.fnMap[index];
        var hits = fileCoverage.f[index];
 
        var info = remapFunction(genItem, getMappingResolved);
 
        if (info) {
          _this.sparceCoverageCollector.updateFunction(info.source, info.srcItem, hits);
        }
      });
 
      (0, _keys2.default)(fileCoverage.statementMap).forEach(function (index) {
        var genItem = fileCoverage.statementMap[index];
        var hits = fileCoverage.s[index];
 
        var mapping = getMappingResolved(genItem);
 
        if (mapping) {
          _this.sparceCoverageCollector.updateStatement(mapping.source, mapping.loc, hits);
        }
      });
    }
  }, {
    key: 'addCoverage',
    value: function addCoverage(item) {
      var _this2 = this;
 
      (0, _keys2.default)(item).forEach(function (filePath) {
        if (_this2.exclude(filePath)) {
          _this2.warn('Excluding: "' + filePath + '"');
          return;
        }
 
        var fileCoverage = item[filePath];
        _this2.addFileCoverage(filePath, fileCoverage);
      });
    }
  }, {
    key: 'getFinalCoverage',
    value: function getFinalCoverage() {
      var _this3 = this;
 
      var collector = new Collector();
 
      var srcCoverage = this.sparceCoverageCollector.getFinalCoverage();
 
      collector.add((0, _keys2.default)(srcCoverage).filter(function (filePath) {
        return !_this3.exclude(filePath);
      }).reduce(function (obj, name) {
        obj[name] = srcCoverage[name];
        return obj;
      }, {}));
 
      /* refreshes the line counts for reports */
      collector.getFinalCoverage();
 
      return collector;
    }
  }]);
  return CoverageTransformer;
}();
 
module.exports.CoverageTransformer = CoverageTransformer;
//# sourceMappingURL=CoverageTransformer.js.map