cssesc-source 0.1.0 → 1.0.1

data/vendor/node_modules/istanbul/test/other/test-index-xface.js

@@ -1,17 +0,0 @@
-var main = require('../../index');
-
-
-module.exports = {
-    "xface": function (test) {
-        [ 'Instrumenter', 'Store', 'Collector', 'Report', '_yuiLoadHook'].forEach(function (key) {
-            test.ok(main[key] && typeof main[key] === 'function', key + ' was not exported as a function!');
-        });
-        [ 'hook', 'utils' ].forEach(function (key) {
-            test.ok(main[key] && typeof main[key] === 'object', key + ' was not exported as an object!');
-        });
-        [ 'assetsDir'].forEach(function (key) {
-            test.ok(main[key] && typeof main[key] === 'string', key + ' was not exported as a string!');
-        });
-        test.done();
-    }
-};

data/vendor/node_modules/istanbul/test/other/test-input-error.js

@@ -1,10 +0,0 @@
-var inputError = require('../../lib/util/input-error');
-
-module.exports = {
-    "should produce an Error object distinguishable from unexpected errors": function (test) {
-        var e = inputError.create('bad user!');
-        test.equal('bad user!', e.message);
-        test.ok(e.inputError);
-        test.done();
-    }
-};

data/vendor/node_modules/istanbul/test/other/test-insertion-text.js

@@ -1,102 +0,0 @@
-/*jslint nomen: true */
-var InsertionText = require('../../lib/util/insertion-text'),
-    it;
-
-module.exports = {
-    "with a regular insertion text": {
-        setUp: function (cb) {
-            it = new InsertionText("hello world");
-            cb();
-        },
-        "should be able to span hello": function (test) {
-            it.insertAt(0, '<span class="h">');
-            it.insertAt(5, '</span>');
-            test.equals(it.toString(), '<span class="h">hello</span> world');
-            test.done();
-        },
-        "should be able to span world": function (test) {
-            it.insertAt(6, '<span class="w">');
-            it.insertAt(11, '</span>');
-            test.equals(it.toString(), 'hello <span class="w">world</span>');
-            test.done();
-        },
-        "should be able to nest spans around hello (improperly)": function (test) {
-            it.insertAt(0, '<span class="h">');
-            it.insertAt(5, '</span>');
-            it.insertAt(0, '<div class="w">');
-            it.insertAt(5, '</div>');
-            test.equals(it.toString(), '<span class="h"><div class="w">hello</span></div> world');
-            test.done();
-        },
-        "should be able to nest spans around hello (properly)": function (test) {
-            it.insertAt(0, '<span class="w">', true);
-            it.insertAt(5, '</span>');
-            it.insertAt(0, '<div class="h">', true);
-            it.insertAt(5, '</div>');
-            test.equals(it.toString(), '<div class="h"><span class="w">hello</span></div> world');
-            test.done();
-        },
-        "should be able to use syntactic sugar for wrapping text": function (test) {
-            it.wrap(0, '<span class="h">', 5, '</span>');
-            it.wrap(0, '<div class="w">', 5, '</div>');
-            test.equals(it.toString(), '<div class="w"><span class="h">hello</span></div> world');
-            test.done();
-        },
-        "should be able to chain calls for wrapping text": function (test) {
-            it.wrap(0, '<span class="h">', 5, '</span>').
-                wrap(0, '<div class="w">', 5, '</div>');
-            test.equals(it.toString(), '<div class="w"><span class="h">hello</span></div> world');
-            test.done();
-        },
-        "should be able to insert text between two insertions": function (test) {
-            it.wrap(0, '<span class="h">', 5, '</span>').
-                insertAt(3, "w");
-            test.equals(it.toString(), '<span class="h">helwlo</span> world');
-            test.done();
-        },
-        "should prepend on negative insertion index": function (test) {
-            it.insertAt(-3, "XXX");
-            test.equals(it.toString(), 'XXXhello world');
-            test.done();
-        },
-        "should append on out-of-bounds insertion index": function (test) {
-            it.insertAt(100, "XXX");
-            test.equals(it.toString(), 'hello worldXXX');
-            test.done();
-        },
-        "should wrap entire line correctly": function (test) {
-            it.wrapLine('<span>', '</span>');
-            test.equals(it.toString(), '<span>hello world</span>');
-            test.done();
-        },
-        "should be able to consume blanks in an individual call": function (test) {
-            it = new InsertionText("  hello world  ");
-            it.wrap(2, '<span>', 13, '</span>', true);
-            test.equals(it.toString(), '<span>  hello world  </span>');
-            test.done();
-        }
-    },
-    "with a blank consuming insertion text and input with spaces on either end": {
-        setUp: function (cb) {
-            it = new InsertionText("    hello world    ", true);
-            cb();
-        },
-        "spanning first word should consume leading spaces": function (test) {
-            it.wrap(4, '<span class="h">', 9, '</span>');
-            test.equals(it.toString(), '<span class="h">    hello</span> world    ');
-            test.done();
-        },
-        "spanning second word should consume trailing spaces": function (test) {
-            it.wrap(10, '<span class="h">', 15, '</span>');
-            test.equals(it.toString(), '    hello <span class="h">world    </span>');
-            test.done();
-        },
-        "should be able to suppress blank consumption in an individual call": function (test) {
-            it = new InsertionText("  hello world  ");
-            it.wrap(2, '<span>', 13, '</span>', false);
-            test.equals(it.toString(), '  <span>hello world</span>  ');
-            test.done();
-        }
-    }
-};
-

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

@@ -1,93 +0,0 @@
-/*jslint nomen: true */
-var path = require('path'),
-    fileset = require('fileset'),
-    root = path.resolve(__dirname, 'data', 'matcher'),
-    src = '../../lib/util/file-matcher.js',
-    fileMatcher = require(src),
-    allFiles;
-
-module.exports = {
-    setUp: function (cb) {
-        if (!allFiles) {
-            fileset('**/*.js', '', { cwd: root}, function (err, files) {
-                allFiles = files.map(function (file) { return path.resolve(root, file); });
-                cb();
-            });
-        } else {
-            cb();
-        }
-    },
-    "should return all files except those under node_modules by default": function (test) {
-        fileMatcher.filesFor(function (err, files) {
-            test.ok(!err);
-            allFiles.forEach(function (file) {
-                var matcher = function (f) { return f === file; },
-                    shouldMatch = file.indexOf('file.js') < 0;
-                if (shouldMatch) {
-                    test.ok(files.filter(matcher).length, 'Should match [' + file + '] but did not');
-                } else {
-                    test.ok(!files.filter(matcher).length, 'Should NOT match [' + file + '] but did');
-                }
-            });
-            test.done();
-        });
-    },
-    "should return relative filenames when requested": function (test) {
-        fileMatcher.filesFor({ root: root, relative: true }, function (err, files) {
-            test.ok(!err);
-            allFiles.forEach(function (file) {
-                var matcher = function (f) { return path.resolve(root, f) === file; },
-                    shouldMatch = file.indexOf('file.js') < 0;
-                if (shouldMatch) {
-                    test.ok(files.filter(matcher).length, 'Should match [' + file + '] but did not');
-                } else {
-                    test.ok(!files.filter(matcher).length, 'Should NOT match [' + file + '] but did');
-                }
-            });
-            test.done();
-        });
-    },
-    "should match stuff under cwd": function (test) {
-        fileMatcher.matcherFor(function (err, matchFn) {
-            test.ok(!err);
-            test.ok(matchFn(path.resolve(__dirname, src)), 'should match itself');
-            test.done();
-        });
-    },
-    "should match stuff under cwd overriding relative opts passed in": function (test) {
-        fileMatcher.matcherFor({ relative: true }, function (err, matchFn) {
-            test.ok(!err);
-            test.ok(matchFn(path.resolve(__dirname, src)), 'should match itself');
-            test.done();
-        });
-    },
-    "should ignore node_modules": function (test) {
-        fileMatcher.matcherFor({ root: root }, function (err, matchFn) {
-            test.ok(!err);
-            allFiles.forEach(function (file) {
-                var shouldMatch = file.indexOf('file.js') < 0;
-                if (shouldMatch) {
-                    test.ok(matchFn(file), 'Should match [' + file + '] but did not');
-                } else {
-                    test.ok(!matchFn(file), 'Should NOT match [' + file + '] but did');
-                }
-            });
-            test.done();
-        });
-    },
-    "should match stuff with explicit includes and excludes": function (test) {
-        fileMatcher.matcherFor({ root: root, includes: [ '**/general/**/*.js' ], excludes: [ '**/general.js' ] }, function (err, matchFn) {
-            test.ok(!err);
-            allFiles.forEach(function (file) {
-                if (file.indexOf('/general/') < 0) { return; }
-                var shouldMatch = file.indexOf('file.js') >= 0;
-                if (shouldMatch) {
-                    test.ok(matchFn(file), 'Should match [' + file + '] but did not');
-                } else {
-                    test.ok(!matchFn(file), 'Should NOT match [' + file + '] but did');
-                }
-            });
-            test.done();
-        });
-    }
-};

data/vendor/node_modules/istanbul/test/other/test-object-utils.js

@@ -1,201 +0,0 @@
-/*jslint nomen: true */
-var utils = require('../../lib/object-utils'),
-    it,
-    it2,
-    it3;
-
-module.exports = {
-    "with some coverage info": {
-        setUp: function (cb) {
-            it = {
-                foo: {
-                    s: {
-                        1: 1,
-                        2: 2,
-                        3: 3,
-                        4: 4
-                    },
-                    statementMap: {
-                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
-                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
-                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
-                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }}
-                    }
-                }
-            };
-            cb();
-        },
-        "should add/ remove derived coverage correctly": function (test) {
-            utils.addDerivedInfo(it);
-            var l = it.foo.l;
-            test.ok(l);
-            test.equals(3, Object.keys(l).length);
-            test.equals(1, l[1]);
-            test.equals(3, l[2]);
-            test.equals(4, l[7]);
-            l[7] = 0;
-            utils.addDerivedInfo(it);
-            test.equals(0, it.foo.l[7]); //does not change
-            utils.removeDerivedInfo(it);
-            test.ok(!it.foo.l);
-            test.done();
-        }
-    },
-    "with full coverage info": {
-        setUp: function (cb) {
-            it = {
-                foo: {
-                    s: {
-                        1: 1,
-                        2: 2,
-                        3: 3,
-                        4: 4,
-                        5: 0
-                    },
-                    statementMap: {
-                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
-                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
-                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
-                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }},
-                        5: { start: { line: 41, column: 0 }, end: { line: 42, column: 10 }}
-                    },
-                    f: {
-                        1: 10,
-                        2: 0
-                    },
-                    fnMap: {
-                        1: { name: 'foo', line: 1 },
-                        2: { name: 'anonymous_1', line: 7 }
-                    },
-                    b: {
-                        1: [ 10, 0, 2],
-                        2: [ 0, 0]
-                    },
-                    branchMap: {
-                        1: { line: 2, type: 'switch', locations: [ ] },
-                        2: { line: 3, type: 'if', locations: [ ] }
-                    }
-                }
-            };
-            it2 = it;
-            it3 = {
-                foo: {
-                    s: {
-                        1: 2,
-                        2: 1,
-                        3: 78,
-                        4: 99,
-                        5: 0
-                    },
-                    statementMap: {
-                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
-                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
-                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
-                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }},
-                        5: { start: { line: 41, column: 0 }, end: { line: 42, column: 10 }}
-                    },
-                    f: {
-                        1: 9,
-                        2: 1
-                    },
-                    fnMap: {
-                        1: { name: 'foo', line: 1 },
-                        2: { name: 'anonymous_1', line: 7 }
-                    },
-                    b: {
-                        1: [ 0, 1, 1],
-                        2: [ 3, 0]
-                    },
-                    branchMap: {
-                        1: { line: 2, type: 'switch', locations: [ ] },
-                        2: { line: 3, type: 'if', locations: [ ] }
-                    }
-                }
-            };
-            cb();
-        },
-        "should calculate correct summary": function (test) {
-            var ret = utils.summarizeFileCoverage(it.foo);
-            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
-            test.done();
-        },
-        "should return a pct of 100 when nothing is available": function (test) {
-            it.foo.b = {};
-            var ret = utils.summarizeFileCoverage(it.foo);
-            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 0, covered: 0, pct: 100 }, ret.branches);
-            test.done();
-        },
-        "should merge summary correctly": function (test) {
-            var s1 = utils.summarizeFileCoverage(it.foo),
-                s2 = utils.summarizeFileCoverage(it2.foo),
-                ret = utils.mergeSummaryObjects(s1, s2);
-            test.deepEqual({ total: 8, covered: 6, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 10, covered: 8, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 4, covered: 2, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 10, covered: 4, pct: 40 }, ret.branches);
-            test.done();
-        },
-        "should merge summary correctly in one call": function (test) {
-            var coverage = { foo: it.foo, 'bar': it2.foo },
-                ret = utils.summarizeCoverage(coverage);
-            test.deepEqual({ total: 8, covered: 6, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 10, covered: 8, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 4, covered: 2, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 10, covered: 4, pct: 40 }, ret.branches);
-            test.done();
-        },
-        "can merge with a blank object in first position": function (test) {
-            var s1 = null,
-                s2 = utils.summarizeFileCoverage(it2.foo),
-                ret = utils.mergeSummaryObjects(s1, s2);
-            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
-            test.done();
-        },
-        "can merge with a blank object in second position": function (test) {
-            var s1 = utils.summarizeFileCoverage(it2.foo),
-                s2 = null,
-                ret = utils.mergeSummaryObjects(s1, s2);
-            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
-            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
-            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
-            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
-            test.done();
-        },
-        "can turn it into a YUI coverage object": function (test) {
-            var ret = utils.toYUICoverage(it);
-            test.deepEqual({ '1': 1, '2': 3, '7': 4, '41': 0 }, ret.foo.lines);
-            test.deepEqual({ 'foo:1': 10, 'anonymous_1:7': 0 }, ret.foo.functions);
-            test.equal(3, ret.foo.calledLines);
-            test.equal(4, ret.foo.coveredLines);
-            test.equal(1, ret.foo.calledFunctions);
-            test.equal(2, ret.foo.coveredFunctions);
-            test.done();
-        },
-        "merge two like coverage objects for the same file correctly": function (test) {
-            var base = JSON.parse(JSON.stringify(it.foo)),
-                ret = utils.mergeFileCoverage(base, it3.foo),
-                foo = it.foo;
-            foo.s[1] += 2;
-            foo.s[2] += 1;
-            foo.s[3] += 78;
-            foo.s[4] += 99;
-            foo.f[1] += 9;
-            foo.f[2] += 1;
-            foo.b[1][1] += 1;
-            foo.b[1][2] += 1;
-            foo.b[2][0] += 3;
-
-            test.deepEqual(ret, foo);
-            test.done();
-        }
-    }
-};

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

@@ -1,129 +0,0 @@
-/*jslint nomen: true */
-var Store = require('../../lib/store'),
-    path = require('path'),
-    fs = require('fs'),
-    util = require('util'),
-    foo = path.resolve(__dirname, 'data', 'foo.js'),
-    baz = path.resolve(__dirname, 'data', 'baz.js'),
-    anon = path.resolve(__dirname, 'data', 'does_not_exist.js'),
-    fooContents = fs.readFileSync(foo, 'utf8'),
-    bazContents = fs.readFileSync(baz, 'utf8');
-
-module.exports = {
-    "fslookup store should work correctly": function (test) {
-        var store = Store.create('fslookup');
-
-        store.set(foo, 'content');
-        test.ok(store.hasKey(foo));
-        test.ok(store.hasKey(baz));
-        test.ok(!store.hasKey(anon));
-        test.equal(0, store.keys().length);
-
-        test.equals(fooContents, store.get(foo));
-        test.equals(bazContents, store.get(baz));
-        test.throws(function () {
-            store.get(anon);
-        });
-        test.throws(function () {
-            store.set(anon, 'foo');
-        }, Error, /non-existent/);
-        test.done();
-    },
-
-    "tmp store should work as expected": function (test) {
-        var store = Store.create('tmp');
-
-        test.equal(0, store.keys().length);
-        store.set(foo, 'content');
-        test.ok(store.hasKey(foo));
-        test.ok(!store.hasKey(baz));
-        test.equal(1, store.keys().length);
-        store.set(baz, 'baz content');
-        test.equal(2, store.keys().length);
-
-        test.equals('content', store.get(foo));
-        test.equals('baz content', store.get(baz));
-        test.throws(function () {
-            store.get(anon);
-        });
-        store.dispose();
-        test.ok(!store.hasKey(foo));
-        test.equal(0, store.keys().length);
-        test.done();
-    },
-
-    "memory store should work as expected": function (test) {
-        var store = Store.create('memory');
-
-        test.equal(0, store.keys().length);
-        store.set(foo, 'content');
-        test.ok(store.hasKey(foo));
-        test.ok(!store.hasKey(baz));
-        test.equal(1, store.keys().length);
-        store.set(baz, 'baz content');
-        test.equal(2, store.keys().length);
-
-        test.equals('content', store.get(foo));
-        test.equals('baz content', store.get(baz));
-        test.throws(function () {
-            store.get(anon);
-        });
-        store.dispose();
-        test.ok(!store.hasKey(foo));
-        test.equal(0, store.keys().length);
-        test.done();
-    },
-
-    "should be able to register a new store": function (test) {
-        function NStore() {
-        }
-        NStore.prototype = {
-            set: function (/* file, content */) { return 'x'; }
-        };
-        NStore.TYPE = 'nstore';
-
-        Store.register(NStore);
-        var store = Store.create('nstore');
-        test.ok(store);
-        test.equals('x', store.set('foo', 'bar'));
-        test.done();
-    },
-
-    "should not be able to register an invalid store": function (test) {
-        function NStore() {}
-        test.throws(function () {
-            Store.register(NStore);
-        },
-            /TYPE/);
-        test.done();
-    },
-
-    "invalid store should not be created": function (test) {
-        test.throws(
-            function () { Store.create('foo'); },
-            /Invalid store \[foo\], allowed values are /
-        );
-        test.done();
-    },
-
-    "should require overriding of all overrideables": function (test) {
-        function NStore() {}
-        NStore.TYPE = 'nstore';
-        util.inherits(NStore, Store);
-        Store.register(NStore);
-
-        var store = Store.create('nstore'),
-            asserter = function (fn) {
-                test.throws(function () {
-                    fn();
-                },
-                    /must be overridden/);
-            };
-        asserter(function () { store.set('foo', 'bar'); });
-        asserter(function () { store.get('foo'); });
-        asserter(function () { store.hasKey('foo'); });
-        asserter(function () { store.keys(); });
-        test.doesNotThrow(function () { store.dispose(); });
-        test.done();
-    }
-};