cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/other/test-summarizer.js

@@ -0,0 +1,172 @@
+var TreeSummarizer = require('../../lib/util/tree-summarizer'),
+    utils = require('../../lib/object-utils'),
+    summarizer,
+    tree,
+    s1,
+    s2,
+    s3;
+
+module.exports = {
+    setUp: function (cb) {
+        summarizer = new TreeSummarizer();
+        s1 = {
+            statements: { covered: 5, total: 10, pct: 50 },
+            lines: { covered: 5, total: 10, pct: 50 },
+            functions: { covered: 15, total: 20, pct: 75 },
+            branches: { covered: 100, total: 200, pct: 50 }
+        };
+        s2 = {
+            statements: { covered: 10, total: 20, pct: 50 },
+            lines: { covered: 10, total: 20, pct: 50 },
+            functions: { covered: 75, total: 100, pct: 75 },
+            branches: { covered: 1, total: 2, pct: 50 }
+        };
+        s3 = {
+            statements: { covered: 9, total: 10, pct: 90 },
+            lines: { covered: 9, total: 10, pct: 90 },
+            functions: { covered: 15, total: 15, pct: 100 },
+            branches: { covered: 101, total: 101, pct: 100 }
+        };
+        cb();
+    },
+    "with a few files in a few dirs": {
+        setUp: function (cb) {
+            summarizer.addFileCoverageSummary('/tmp/lib/foo.js', s1);
+            summarizer.addFileCoverageSummary('/tmp/lib/bar.js', s2);
+            summarizer.addFileCoverageSummary('/tmp/lib/util/baz.js', s3);
+            tree = summarizer.getTreeSummary();
+            cb();
+        },
+        "should be JSON serializable": function (test) {
+            test.ok(JSON.stringify(tree));
+            test.done();
+        },
+        "should have the correct tree with root hoisted one level above code": function (test) {
+            var node = tree.root,
+                utilSummary = utils.mergeSummaryObjects(s3),
+                libSummary = utils.mergeSummaryObjects(s1, s2),
+                fullSummary = utils.mergeSummaryObjects(utilSummary, libSummary);
+            test.equal('/tmp/', node.fullPath());
+            test.equal('', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(fullSummary, node.metrics);
+            test.ok(node === tree.getNode(''));
+            node = tree.root.children[0];
+            test.equal('/tmp/lib/', node.fullPath());
+            test.equal('lib/', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(libSummary, node.metrics);
+            test.deepEqual(s2, node.children[0].metrics);
+            test.deepEqual(s1, node.children[1].metrics);
+            test.ok(node === tree.getNode('lib/'));
+            node = tree.root.children[1];
+            test.equal('/tmp/lib/util/', node.fullPath());
+            test.equal('lib/util/', node.displayShortName());
+            test.equal(1, node.children.length);
+            test.deepEqual(utilSummary, node.metrics);
+            test.deepEqual(s3, node.children[0].metrics);
+            test.ok(node === tree.getNode('lib/util/'));
+            test.ok(tree.getNode('lib/foo.js'));
+            test.ok(tree.getNode('lib/bar.js'));
+            test.ok(tree.getNode('lib/util/baz.js'));
+            test.done();
+        }
+    },
+    "with the same few files organized differently": {
+        setUp: function (cb) {
+            summarizer.addFileCoverageSummary('/tmp/lib/main/foo.js', s1);
+            summarizer.addFileCoverageSummary('/tmp/lib/main/bar.js', s2);
+            summarizer.addFileCoverageSummary('/tmp/lib/util/baz.js', s3);
+            tree = summarizer.getTreeSummary();
+            cb();
+        },
+        "should have the correct tree with no root hoisting": function (test) {
+            var node = tree.root,
+                utilSummary = utils.mergeSummaryObjects(s3),
+                libSummary = utils.mergeSummaryObjects(s1, s2),
+                fullSummary = utils.mergeSummaryObjects(utilSummary, libSummary);
+            test.equal('/tmp/lib/', node.fullPath());
+            test.equal('', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(fullSummary, node.metrics);
+            test.ok(node === tree.getNode(''));
+            node = tree.root.children[0];
+            test.equal('/tmp/lib/main/', node.fullPath());
+            test.equal('main/', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(libSummary, node.metrics);
+            test.deepEqual(s2, node.children[0].metrics);
+            test.deepEqual(s1, node.children[1].metrics);
+            test.ok(node === tree.getNode('main/'));
+            node = tree.root.children[1];
+            test.equal('/tmp/lib/util/', node.fullPath());
+            test.equal('util/', node.displayShortName());
+            test.equal(1, node.children.length);
+            test.deepEqual(utilSummary, node.metrics);
+            test.deepEqual(s3, node.children[0].metrics);
+            test.ok(node === tree.getNode('util/'));
+            test.ok(tree.getNode('main/foo.js'));
+            test.ok(tree.getNode('main/bar.js'));
+            test.ok(tree.getNode('util/baz.js'));
+            test.done();
+        }
+    },
+    "with no room for hoisting": {
+        setUp: function (cb) {
+            summarizer.addFileCoverageSummary('/foo.js', s1);
+            summarizer.addFileCoverageSummary('/bar.js', s2);
+            summarizer.addFileCoverageSummary('/util/baz.js', s3);
+            tree = summarizer.getTreeSummary();
+            //console.log(JSON.stringify(tree, undefined, 2));
+            cb();
+        },
+        "should build a correct tree but with a mangled name for the main dir": function (test) {
+            var node = tree.root,
+                utilSummary = utils.mergeSummaryObjects(s3),
+                libSummary = utils.mergeSummaryObjects(s1, s2),
+                fullSummary = utils.mergeSummaryObjects(utilSummary, libSummary);
+            test.equal('/', node.fullPath());
+            test.equal('', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(fullSummary, node.metrics);
+            test.ok(node === tree.getNode(''));
+            node = tree.root.children[0];
+            test.equal('/__root__/', node.fullPath());
+            test.equal('__root__/', node.displayShortName());
+            test.equal(2, node.children.length);
+            test.deepEqual(libSummary, node.metrics);
+            test.deepEqual(s2, node.children[0].metrics);
+            test.deepEqual(s1, node.children[1].metrics);
+            test.ok(node === tree.getNode('__root__/'));
+            node = tree.root.children[1];
+            test.equal('/util/', node.fullPath());
+            test.equal('util/', node.displayShortName());
+            test.equal(1, node.children.length);
+            test.deepEqual(utilSummary, node.metrics);
+            test.deepEqual(s3, node.children[0].metrics);
+            test.ok(node === tree.getNode('util/'));
+            test.ok(tree.getNode('foo.js'));
+            test.ok(tree.getNode('bar.js'));
+            test.ok(tree.getNode('util/baz.js'));
+            test.done();
+        }
+    },
+    "with no summaries provided at all": {
+        setUp: function (cb) {
+            tree = summarizer.getTreeSummary();
+            cb();
+        },
+        "should build a blank tree with a root": function (test) {
+            var node = tree.root,
+                blank = utils.blankSummary();
+
+            blank.statements.pct = blank.lines.pct = blank.branches.pct = blank.functions.pct = 100;
+            test.ok(node);
+            test.equal('/', node.fullPath());
+            test.equal('', node.displayShortName());
+            test.equal(0, node.children.length);
+            test.deepEqual(blank, node.metrics);
+            test.done();
+        }
+    }
+};

data/vendor/node_modules/istanbul/test/run-again.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+var nodeunit = require('nodeunit'),
+    mkdirp = require('mkdirp'),
+    loader = require('./loader'),
+    common = require('./common');
+
+function runTests() {
+    var outputDir = common.getBuildDir();
+
+    mkdirp.sync(outputDir);
+    loader.runTests(process.argv[2], nodeunit.reporters['default'], undefined, function (err) {
+        if (err) { throw err; }
+    });
+}
+
+runTests();
+
+

data/vendor/node_modules/istanbul/test/run.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/*
+ * Test runner for all unit tests, also set up as the "npm test" command for the package.
+ *
+ * Usage: run.js <test-pat> <force-cover>
+ *     where <test-pat> is a string to run only those test cases that have the string in the filename
+ *          <force-cover> is set to, say, 1, to indicate that the tests also need to be run in self-cover
+ *             mode. Otherwise, self-cover is determined by the `npm_config_coverage` variable
+ *             set by `npm test --coverage`
+ *
+ *  How self-cover works:
+ *
+ *      1. First run all the required tests and make sure that they pass
+ *      2. Set an environment variable to indicate that self-coverage is in progress
+ *      3. Run the equivalent of `istanbul cover test/run-junit.js` which
+ *          will "turn on" coverage for all simple unit tests.
+ *      4. The CLI tests need to turn on coverage across a process boundary so that
+ *          coverage is performed in a sub-process when the commands are forked.
+ *          The `cli-helper.js` has specific code to turn this on.
+ *          It should be noted that the behavior of CLI tests is not exactly
+ *          identical in regular v/s self-cover mode. It is possible for CLI
+ *          tests to fail in one mode and pass in the other because of this.
+ *          The bottom line is: make changes to `cli-helper.js` with great care :)
+ *      5. The browser test is a similar beast in that the local server sends regular
+ *          versus covered versions of instrumenter.js to the phantomJS browser
+ *          based on the coverage environment variable. This test is less
+ *          sensitive to modes of operation.
+ */
+
+/*jslint nomen: true */
+var nodeunit = require('nodeunit'),
+    fs = require('fs'),
+    path = require('path'),
+    loader = require('./loader'),
+    child_process = require('child_process'),
+    rimraf = require('rimraf'),
+    common = require('./common'),
+    cliHelper = require('./cli-helper');
+
+function runTests(pat, forceCover) {
+    var defaultReporter = nodeunit.reporters['default'],
+        selfCover = forceCover || process.env.npm_config_coverage, //set by npm test --coverage
+        args,
+        proc;
+
+    cliHelper.setVerbose(process.env.VERBOSE);
+    loader.runTests(pat, defaultReporter, undefined, function (err) {
+        var coverageDir = common.getCoverageDir();
+        //if any test failed then we cannot obviously run self-coverage
+        if (err) { throw err; }
+        if (selfCover) {
+            //delet the build dir
+            rimraf.sync(common.getBuildDir());
+            //set up environment variable to set CLI and browser
+            //tests know that they need to run in self-cover mode
+            common.setSelfCover(true);
+            console.log('Running self-coverage....');
+            // run the equivalent of
+            // $ istanbul cover run-again.js -- <pat>
+            args = [
+                path.resolve(__dirname, '..', 'lib', 'cli.js'),
+                'cover',
+                '--self-test',
+                '--dir',
+                coverageDir,
+                '--report',
+                'none',
+                '--x',
+                '**/node_modules/**',
+                '--x',
+                '**/test/**',
+                '--x',
+                '**/yui-load-hook.js',
+                path.resolve(__dirname, 'run-again.js'),
+                '--',
+                pat || ''
+            ];
+            console.log('Run node ' + args.join(' '));
+            proc = child_process.spawn('node', args);
+            proc.stdout.on('data', function (data) { process.stdout.write(data); });
+            proc.stderr.on('data', function (data) { process.stderr.write(data); });
+            proc.on('exit', function (exitCode) {
+                if (exitCode !== 0) {
+                    throw new Error('self-cover returned exit code [' + exitCode + ']');
+                }
+                var Collector = require('../lib/collector'),
+                    collector = new Collector(),
+                    Report = require('../lib/report'),
+                    reporter = Report.create('lcov', { dir: coverageDir }),
+                    summary = Report.create('text-summary'),
+                    detail = Report.create('text');
+                fs.readdirSync(coverageDir).forEach(function (file) {
+                    if (file.indexOf('cov') === 0 && file.indexOf('.json') > 0) {
+                        collector.add(JSON.parse(fs.readFileSync(path.resolve(coverageDir, file), 'utf8')));
+                    }
+                });
+                reporter.writeReport(collector, true);
+                detail.writeReport(collector, true);
+                summary.writeReport(collector, true);
+            });
+        }
+    });
+}
+
+runTests(process.argv[2], process.argv[3]);
+
+

data/vendor/node_modules/istanbul/yui-coverage-comparison.md

@@ -0,0 +1,85 @@
+Comparison with YUI coverage
+============================
+
+Differences in features
+-----------------------
+
+* YUI coverage - line and function coverage. Istanbul - statement, function and branch coverage.
+Reverse-engineers line-coverage from statement coverage with 100% fidelity at reporting time.
+
+* Output report formats are not as extensive as YUI coverage reporting. It supports LCOV and a custom
+HTML format (all-JS implementation) that only highlights missing coverage. "Standard" LCOV HTML reports can be
+gotten by running `genhtml` on the `lcov.info` file. Notice that this will also have branch coverage
+information, assuming you are using a recent `lcov` version.
+
+Differences in processing
+-------------------------
+
+YUI coverage emits a function call to increment line/ function coverage as
+appropriate. The function call also tests to see if that specific line/ function
+was covered before and, if not, increments the coverage count for lines/ functions
+as appropriate.
+
+Istanbul emits code that does simple post-increments of object attributes without resorting
+to function calls at all. This also means that it does not keep track of derived information
+and does not bother to keep track of "how many statements/ branches/ functions have been
+covered so far", preferring to do this at report generation time.
+
+Differences in coverage object and generated code
+-------------------------------------------------
+
+These are the ways in which the objects differ:
+
+* The YUI coverage object tracks line and function execution counts and also keeps track
+of how many lines/ functions were covered. The Istanbul coverage object only keeps
+tracks of statement, function and branch execution counts.
+
+* Due to the backwards-incompatible format of the Istanbul coverage object, it is not
+named `_yuitest_coverage` but `__coverage__` by default. You can change this to any name you
+want using an instrumenter option.
+
+* The YUI coverage object packs the entire source code of the file into an array for every
+file. The Istanbul coverage objects prefers to not do this by default and thereby does not automatically double
+the size of every JS file. YAGNI. Unless you do, in which case you have to ask for it.
+
+* All access to the YUI coverage object is of the form `global_object['/path/to/file'].property`
+Istanbul generates a temporary variable name based on the MD5 hash of the file path and uses
+that for assignment, as in: `_covRanDomJunk = global_object['/path/to/file']` and, subsequently
+`_covRanDomJunk.property[index]++` - this avoids a hash lookup for every increment call and also
+makes the generated code size smaller.
+
+* YUI coverage emits code that is human-readable and tries to keep the lines of the generated code
+in around the same place as the source. Istanbul emits minified code by default unless told not to.
+There is no reason the covered code needs to look anything like the original as long as it works the
+same way.
+
+In short, Istanbul provides smaller code size and faster execution at the expense of maintaining only
+raw data and no derived information (even though it tracks one extra metric).
+
+Differences in tooling
+----------------------
+
+* Istanbul wants to be as unobtrusive as possible and provides module load hooks (for `require` and
+`vm.createScript`) to transparently instrument code in a `node` environment. YUI coverage, being java,
+necessitates a pre-processing build step (or an expensive runtime one).
+
+* The same concept should be applicable for instrumenting and testing JS code meant for the browser.
+Just serve your file using a nodejs server (or Yeti) and instrument your code using custom middleware/
+interceptors/ whatever.
+
+* The instrumentation command accepts wildcarded exclusion patterns so as to be able to run all the
+required instrumentation in one command for the 'pre-processing step' case.
+
+Known bugs in YUI coverage fixed
+--------------------------------
+
+The following known bugs in YUI coverage do not exist in Istanbul. This, of course, says nothing about
+what _other_ bugs Istanbul might have :)
+
+* No function calls for incrementing execution counts which implies no "Deep recursion" message from older IE (or something like that)
+  when IE sees a bunch of repeated function calls to the same function.
+* Statements with labels correctly handled
+* `if (a) foo() else if (b) bar() else baz()` case correctly handled
+* Coverage object for a file is assigned to the global object at module load only if it already does not exist in it.
+This handles cases where a module is reloaded in node (as a result of nuking the `require` cache) correctly and
+preserves all execution counts from the previously loaded version.

data/vendor/node_modules/qunit-clib/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2011-2013 John-David Dalton <http://allyoucanleet.com/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/node_modules/qunit-clib/README.md

@@ -0,0 +1,2 @@
+This project is now maintained at [jdalton/qunit-extras](https://github.com/jdalton/qunit-extras).<br>
+Please refer to the [qunit-extras](https://github.com/jdalton/qunit-extras) repo for all future updates.

data/vendor/node_modules/qunit-clib/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "qunit-clib",
+  "version": "1.3.0",
+  "description": "QUnit CLIB helps extend QUnit’s CLI support to many common CLI environments.",
+  "license": "MIT",
+  "main": "qunit-clib.js",
+  "keywords": [
+    "qunit",
+    "cli"
+  ],
+  "author": {
+    "name": "John-David Dalton",
+    "email": "john.david.dalton@gmail.com",
+    "url": "http://allyoucanleet.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/jdalton/qunit-extras/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jdalton/qunit-extras.git"
+  },
+  "engines": [
+    "node",
+    "rhino"
+  ],
+  "files": [
+    "LICENSE.txt",
+    "qunit-clib.js"
+  ],
+  "readme": "This project is now maintained at [jdalton/qunit-extras](https://github.com/jdalton/qunit-extras).<br>\nPlease refer to the [qunit-extras](https://github.com/jdalton/qunit-extras) repo for all future updates.\n",
+  "readmeFilename": "README.md",
+  "homepage": "https://github.com/jdalton/qunit-extras",
+  "_id": "qunit-clib@1.3.0",
+  "_from": "qunit-clib@~1.3.0"
+}