cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/cli/test-html-report.js

@@ -0,0 +1,125 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    helper = require('../cli-helper'),
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    COVER_COMMAND = 'cover',
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    Reporter = require('../../lib/report/html'),
+    Collector = require('../../lib/collector'),
+    existsSync = fs.existsSync || path.existsSync;
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should test files written": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            htmlReport = path.resolve(OUTPUT_DIR),
+            reporter = new Reporter({ dir: OUTPUT_DIR, verbose: true }),
+            obj,
+            collector = new Collector(),
+            fileFor = function () {
+                var args = Array.prototype.slice.call(arguments);
+                args.unshift(htmlReport);
+                return path.resolve.apply(null, args);
+            };
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(htmlReport));
+        test.ok(existsSync(fileFor('index.html')));
+        test.ok(existsSync(fileFor('lib', 'index.html')));
+        test.ok(existsSync(fileFor('lib', 'util', 'index.html')));
+        test.ok(existsSync(fileFor('lib', 'foo.js.html')));
+        test.ok(existsSync(fileFor('lib', 'bar.js.html')));
+        test.ok(existsSync(fileFor('lib', 'util', 'generate-names.js.html')));
+        test.ok(fs.readFileSync(fileFor('lib', 'bar.js.html'), 'utf8') !== '');
+        test.done();
+    },
+
+    "should test files written with defaults": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            htmlReport = path.resolve(process.cwd(), 'html-report'),
+            reporter = new Reporter(),
+            obj,
+            collector = new Collector(),
+            fileFor = function () {
+                var args = Array.prototype.slice.call(arguments);
+                args.unshift(htmlReport);
+                return path.resolve.apply(null, args);
+            };
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(htmlReport));
+        test.ok(existsSync(fileFor('index.html')));
+        test.ok(existsSync(fileFor('lib', 'bar.js.html')));
+        test.ok(fs.readFileSync(fileFor('lib', 'bar.js.html'), 'utf8') !== '');
+        test.done();
+    },
+
+    "should test files written when code packed into coverage object": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            htmlReport = path.resolve(OUTPUT_DIR),
+            reporter = new Reporter({ dir: OUTPUT_DIR, verbose: true }),
+            obj,
+            copy = {},
+            collector = new Collector(),
+            mangler = function (name) {
+                return name.replace(/\.js/,'-mangled.js');
+            },
+            fileFor = function () {
+                var args = Array.prototype.slice.call(arguments);
+                args.unshift(htmlReport);
+                return mangler(path.resolve.apply(null, args));
+            },
+            contentFor = function (file) {
+                return fs.readFileSync(file, 'utf8').split(/\r?\n/);
+            };
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        //stick in the code and mangle the file paths in the coverage object so that default behavior will not work
+        Object.keys(obj).forEach(function (k) {
+            var code = contentFor(k),
+                mangled = mangler(k);
+            obj[k].code = code;
+            obj[k].path = mangled;
+            copy[mangled] = obj[k];
+            test.ok(mangled !== k); //verify something _did_ get mangled
+            test.ok(copy[mangled].code);
+        });
+        collector.add(copy);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(htmlReport));
+        test.ok(existsSync(fileFor('index.html')));
+        test.ok(existsSync(fileFor('lib', 'index.html')));
+        test.ok(existsSync(fileFor('lib', 'util', 'index.html')));
+        test.ok(existsSync(fileFor('lib', 'foo.js.html')));
+        test.ok(existsSync(fileFor('lib', 'bar.js.html')));
+        test.ok(existsSync(fileFor('lib', 'util', 'generate-names.js.html')));
+        test.ok(fs.readFileSync(fileFor('lib', 'bar.js.html'), 'utf8') !== '');
+        test.done();
+    },
+
+    "test contents": function (test) {
+        console.error('Figure out a way to run meaningful tests for HTML report contents');
+        test.ok(1);
+        test.done();
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-instrument-command.js

@@ -0,0 +1,167 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    existsSync = fs.existsSync || path.existsSync,
+    vm = require('vm'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    INPUT_DIR_CC = path.join(__dirname, '../other/data-complete-copy/'),
+    OUTPUT_DIR = path.resolve(process.cwd(), 'output'),
+    COMMAND = 'instrument',
+    DIR = path.resolve(__dirname, 'sample-project'),
+    helper = require('../cli-helper'),
+    existsSync = fs.existsSync || path.existsSync,
+    run = helper.runCommand.bind(null, COMMAND),
+    INPUT_DIR_JS_FILE_COUNT = 0;
+
+fs.readdirSync(INPUT_DIR_CC).forEach(function(file) {
+    var extenstion = path.extname(file);
+
+    if (extenstion === '.js') {
+        INPUT_DIR_JS_FILE_COUNT++;
+    }
+});
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        cb();
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should work with default options for a single file": function (test) {
+        run([ 'lib/foo.js' ], function (results) {
+            test.ok(results.succeeded());
+            test.doesNotThrow(function () {
+                vm.createScript(results.stdout().join('\n'), path.resolve(DIR, 'lib', 'foo.js'));
+            }, "Invalid code generated; logging interference perhaps?");
+            test.done();
+        });
+    },
+    "should work with compact as default": function (test) {
+        run([ 'lib/foo.js' ], function (results) {
+            test.ok(results.succeeded());
+            var compact = results.stdout().join('\n');
+            run([ 'lib/foo.js', '--no-compact' ], function (results2) {
+                var full = results2.stdout().join('\n');
+                test.ok(full.length > compact.length);
+                test.done();
+            });
+        });
+    },
+    "should work with explicit output option for a single file": function (test) {
+        run([ 'lib/foo.js', '--output', path.resolve(OUTPUT_DIR, 'foo.js') ], function (results) {
+            test.ok(results.succeeded());
+            test.doesNotThrow(function () {
+                vm.createScript(fs.readFileSync(path.resolve(OUTPUT_DIR, 'foo.js'), 'utf8'), path.resolve(DIR, 'lib', 'foo.js'));
+            }, "Invalid code generated; logging interference perhaps?");
+            test.done();
+        });
+    },
+    "should instrument multiple files": function (test) {
+        run([ 'lib', '--output', OUTPUT_DIR, '-v' ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'foo.js')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'bar.js')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'util', 'generate-names.js')));
+            test.equal(fs.readFileSync(path.resolve(DIR, 'lib', 'util', 'bad.js'), 'utf8'),
+                fs.readFileSync(path.resolve(OUTPUT_DIR, 'util', 'bad.js'), 'utf8'));
+            test.ok(results.grepOutput(/Processed: foo\.js/));
+            test.ok(results.grepOutput(/Processed \[\d+\] files in/));
+            test.ok(results.grepOutput(/The following 1 file\(s\) had errors and were copied as-is/));
+            test.done();
+        });
+    },
+    "should instrument multiple files without errors": function (test) {
+        run([ 'lib', '--output', OUTPUT_DIR, '-x', '**/bad.js' ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'foo.js')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'bar.js')));
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'util', 'bad.js')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'util', 'generate-names.js')));
+            test.ok(!results.grepOutput(/Processed: foo\.js/));
+            test.ok(results.grepOutput(/Processed \[\d+\] files in/));
+            test.ok(!results.grepOutput(/The following 1 file\(s\) had errors and were copied as-is/));
+            test.done();
+        });
+    },
+    "should save baseline coverage when requested": function (test) {
+        var covFile = path.resolve(OUTPUT_DIR, 'cov.json');
+        run([ 'lib/foo.js', '--save-baseline', '--baseline-file=' + covFile ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(covFile));
+            test.ok(results.grepOutput(/Saving baseline coverage at/));
+            test.done();
+        });
+    },
+    "should barf on no args": function (test) {
+        run([], function (results) {
+            test.ok(!results.succeeded());
+            test.ok(results.grepError(/Need exactly one filename\/ dirname argument/));
+            test.done();
+        });
+    },
+    "should barf on directory coverage when output option is not provided": function (test) {
+        run([ 'lib'], function (results) {
+            test.ok(!results.succeeded());
+            test.ok(results.grepError(/Need an output directory/));
+            test.done();
+        });
+    },
+    "should barf on directory coverage when output === input": function (test) {
+        run([ 'lib', '--output', 'lib'], function (results) {
+            test.ok(!results.succeeded());
+            test.ok(results.grepError(/Cannot instrument into the same directory/));
+            test.done();
+        });
+    },
+    "should not copy non js files when using no-complete-copy": function(test) {
+        var inputFileCount;
+
+        inputFileCount = fs.readdirSync(INPUT_DIR_CC).length;
+
+        test.equal(fs.readdirSync(INPUT_DIR_CC).length, 6);
+        test.equal(fs.readdirSync(OUTPUT_DIR).length, 0);
+
+        run([ INPUT_DIR_CC, '--output', OUTPUT_DIR, '--no-complete-copy'], function (results) {
+            test.ok(results.succeeded());
+            test.equal(fs.readdirSync(OUTPUT_DIR).length, INPUT_DIR_JS_FILE_COUNT);
+            test.done();
+        });
+    },
+    "should not copy non js files when not specifying complete-copy": function(test) {
+        // Backward compatibility test
+        var inputFileCount;
+
+        inputFileCount = fs.readdirSync(INPUT_DIR_CC).length;
+
+        test.equal(fs.readdirSync(INPUT_DIR_CC).length, 6);
+        test.equal(fs.readdirSync(OUTPUT_DIR).length, 0);
+
+        run([ INPUT_DIR_CC, '--output', OUTPUT_DIR], function (results) {
+            test.ok(results.succeeded());
+            test.equal(fs.readdirSync(OUTPUT_DIR).length, INPUT_DIR_JS_FILE_COUNT);
+            test.done();
+        });
+    },
+    "should copy non js files when using complete-copy": function(test) {
+        var inputFileCount;
+
+        inputFileCount = fs.readdirSync(INPUT_DIR_CC).length;
+
+        test.equal(fs.readdirSync(INPUT_DIR_CC).length, 6);
+        test.equal(fs.readdirSync(OUTPUT_DIR).length, 0);
+
+        run([ INPUT_DIR_CC, '--output', OUTPUT_DIR, '--complete-copy'], function (results) {
+            test.ok(results.succeeded());
+            test.equal(fs.readdirSync(OUTPUT_DIR).length, inputFileCount);
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'subdir', 'x.css')));
+            test.done();
+        });
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-json-report.js

@@ -0,0 +1,60 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    helper = require('../cli-helper'),
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    COVER_COMMAND = 'cover',
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    Reporter = require('../../lib/report/json'),
+    Collector = require('../../lib/collector'),
+    existsSync = fs.existsSync || path.existsSync;
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should produce json report consuming coverage file": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            jsonFile = path.resolve(OUTPUT_DIR, 'coverage-final.json'),
+            reporter = new Reporter({ dir: OUTPUT_DIR }),
+            obj,
+            reportObj,
+            collector = new Collector();
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(jsonFile));
+        reportObj = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+        Object.keys(reportObj).forEach(function (k) {
+            delete reportObj[k].l;
+        });
+        test.deepEqual(obj, reportObj);
+        test.done();
+    },
+    "should produce coverage-final.json at cwd when no options specified": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            jsonFile = path.resolve('coverage-final.json'),
+            reporter = new Reporter(),
+            collector = new Collector();
+
+        collector.add(JSON.parse(fs.readFileSync(file, 'utf8')));
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(jsonFile));
+        fs.unlinkSync(jsonFile);
+        test.done();
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-lcov-report.js

@@ -0,0 +1,58 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    helper = require('../cli-helper'),
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    COVER_COMMAND = 'cover',
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    Reporter = require('../../lib/report/lcov'),
+    Collector = require('../../lib/collector'),
+    existsSync = fs.existsSync || path.existsSync;
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should produce lcov report consuming coverage file": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            lcovFile = path.resolve(OUTPUT_DIR, 'lcov.info'),
+            lcovReport = path.resolve(OUTPUT_DIR, 'lcov-report'),
+            reporter = new Reporter({ dir: OUTPUT_DIR }),
+            obj,
+            collector = new Collector();
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(lcovFile));
+        test.ok(existsSync(lcovReport));
+        test.done();
+    },
+    "should produce lcov.info and lcov-report at cwd when no options specified": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            lcovFile = path.resolve('lcov.info'),
+            lcovReport = path.resolve('lcov-report'),
+            reporter = new Reporter(),
+            collector = new Collector();
+
+        collector.add(JSON.parse(fs.readFileSync(file, 'utf8')));
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(lcovFile));
+        fs.unlinkSync(lcovFile);
+        rimraf.sync(lcovReport);
+        test.done();
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-lcovonly-report.js

@@ -0,0 +1,61 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    helper = require('../cli-helper'),
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    COVER_COMMAND = 'cover',
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    Reporter = require('../../lib/report/lcovonly'),
+    Collector = require('../../lib/collector'),
+    existsSync = fs.existsSync || path.existsSync;
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should produce lcovonly report consuming coverage file": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            lcovFile = path.resolve(OUTPUT_DIR, 'lcov.info'),
+            reporter = new Reporter({ dir: OUTPUT_DIR }),
+            obj,
+            collector = new Collector(),
+            lines,
+            numFiles;
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        numFiles = Object.keys(obj).length;
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(lcovFile));
+        lines = fs.readFileSync(lcovFile, 'utf8').split(/\r?\n/);
+        test.ok(lines.filter(function (line) { return line.indexOf('SF:') === 0; }).length, numFiles);
+        test.ok(lines.filter(function (line) { return line.indexOf('TN:') === 0; }).length, numFiles);
+        test.ok(lines.filter(function (line) { return line.indexOf('end_of_record') === 0; }).length, numFiles);
+        test.done();
+    },
+    "should produce lcov.info at cwd when no options specified": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            lcovFile = path.resolve('lcov.info'),
+            reporter = new Reporter(),
+            collector = new Collector();
+
+        collector.add(JSON.parse(fs.readFileSync(file, 'utf8')));
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(lcovFile));
+        fs.unlinkSync(lcovFile);
+        test.done();
+    }
+};
+