add linting (and some initial fixes)

1 files changed, 160 insertions, 0 deletions

diff --git a/node_modules/istanbul-lib-source-maps/lib/map-store.js b/node_modules/istanbul-lib-source-maps/lib/map-store.js
new file mode 100644
index 000000000..8b31d4229
--- /dev/null
+++ b/node_modules/istanbul-lib-source-maps/lib/map-store.js
@@ -0,0 +1,160 @@
+/*
+ Copyright 2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+"use strict";
+
+var debug = require('debug')('istanbuljs'),
+    path = require('path'),
+    fs = require('fs'),
+    pathutils = require('./pathutils'),
+    sourceStore = require('./source-store'),
+    transformer = require('./transformer'),
+    SMC = require('source-map').SourceMapConsumer;
+
+/**
+ * tracks source maps for registered files
+ * @param {Object} opts [opts=undefined] options.
+ * @param {Boolean} opts.verbose [opts.verbose=false] verbose mode
+ * @param {String} opts.baseDir [opts.baseDir=null] alternate base directory
+ *  to resolve sourcemap files
+ * @param {String} opts.sourceStore [opts.sourceStore='memory'] - store that tracks
+ *  embedded sources found in source maps, one of 'memory' or 'file'
+ * @param {String} opts.tmpdir [opts.tmpdir=undefined] - temporary directory
+ *   to use for storing files.
+ * @constructor
+ */
+function MapStore(opts) {
+    opts = opts || {};
+    this.baseDir = opts.baseDir || null;
+    this.verbose = opts.verbose || false;
+    this.sourceStore = sourceStore.create(opts.sourceStore, { tmpdir: opts.tmpdir});
+    this.data = {};
+}
+/**
+ * registers a source map URL with this store. It makes some input sanity checks
+ * and silently fails on malformed input.
+ * @param transformedFilePath - the file path for which the source map is valid.
+ *  This must *exactly* match the path stashed for the coverage object to be
+ *  useful.
+ * @param sourceMapUrl - the source map URL, **not** a comment
+ */
+MapStore.prototype.registerURL = function (transformedFilePath, sourceMapUrl) {
+    var d = 'data:',
+        b64 = 'base64,',
+        pos;
+
+    if (sourceMapUrl.length > d.length && sourceMapUrl.substring(0, d.length) === d) {
+        pos = sourceMapUrl.indexOf(b64);
+        if (pos > 0) {
+            this.data[transformedFilePath] = {
+                type: 'encoded',
+                data: sourceMapUrl.substring(pos + b64.length)
+            };
+        } else {
+            debug('Unable to interpret source map URL: ' + sourceMapUrl);
+        }
+        return;
+    }
+    var dir = path.dirname(path.resolve(transformedFilePath)),
+        file = path.resolve(dir, sourceMapUrl);
+    this.data[transformedFilePath] = { type: 'file', data: file };
+};
+/**
+ * registers a source map object with this store. Makes some basic sanity checks
+ * and silently fails on malformed input.
+ * @param transformedFilePath - the file path for which the source map is valid
+ * @param sourceMap - the source map object
+ */
+MapStore.prototype.registerMap = function (transformedFilePath, sourceMap) {
+    if (sourceMap && sourceMap.version) {
+        this.data[transformedFilePath] = { type: 'object', data: sourceMap };
+    } else {
+        debug('Invalid source map object:' + JSON.stringify(sourceMap, null, 2));
+    }
+};
+/**
+ * transforms the coverage map provided into one that refers to original
+ * sources when valid mappings have been registered with this store.
+ * @param {CoverageMap} coverageMap - the coverage map to transform
+ * @returns {Object} an object with 2 properties. `map` for the transformed
+ * coverage map and `sourceFinder` which is a function to return the source
+ * text for a file.
+ */
+MapStore.prototype.transformCoverage = function (coverageMap) {
+    var that = this,
+        mappedCoverage,
+        sourceFinder;
+
+    sourceFinder = function (filePath) {
+        var content = that.sourceStore.getSource(filePath);
+        if (content !== null) {
+            return content;
+        }
+        if (pathutils.isAbsolute(filePath)) {
+            return fs.readFileSync(filePath, 'utf8');
+        }
+        return fs.readFileSync(pathutils.asAbsolute(filePath, that.baseDir));
+    };
+
+    coverageMap.files().forEach(function (file) {
+        var coverage = coverageMap.fileCoverageFor(file);
+        if (coverage.data.inputSourceMap && !that.data[file]) {
+            that.registerMap(file, coverage.data.inputSourceMap);
+        }
+    });
+
+    if (Object.keys(this.data).length === 0) {
+        return {
+            map: coverageMap,
+            sourceFinder: sourceFinder
+        };
+    }
+    mappedCoverage = transformer.create(function (filePath) {
+        try {
+            if (!that.data[filePath]) {
+                return null;
+            }
+            var d = that.data[filePath],
+                obj,
+                smc;
+
+            if (d.type === 'file') {
+                obj = JSON.parse(fs.readFileSync(d.data, 'utf8'));
+            } else if (d.type === 'encoded') {
+                obj = JSON.parse(new Buffer(d.data, 'base64').toString());
+            } else {
+                obj = d.data;
+            }
+            smc = new SMC(obj);
+            smc.sources.forEach(function (s) {
+                var content = smc.sourceContentFor(s),
+                    sourceFilePath = pathutils.relativeTo(s, filePath);
+                if (content) {
+                    that.sourceStore.registerSource(sourceFilePath, content);
+                }
+            });
+            return smc;
+        } catch (ex) {
+            debug('Error returning source map for ' + filePath);
+            debug(ex.stack);
+            return null;
+        }
+    }).transform(coverageMap);
+
+    return {
+        map: mappedCoverage,
+        sourceFinder: sourceFinder
+    };
+};
+
+/**
+ * disposes temporary resources allocated by this map store
+ */
+MapStore.prototype.dispose = function () {
+    this.sourceStore.dispose();
+};
+
+module.exports = {
+    MapStore: MapStore
+};