cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/browser/support/phantom-test.client.js

@@ -0,0 +1,49 @@
+/*global phantom, window,document */
+var system = require('system'),
+    page = require('webpage').create(),
+    args = Array.prototype.slice.call(system.args),
+    script = args.shift(),
+    port = args.shift(),
+    files = args,
+    done;
+
+console.log('Connecting to localhost, port: ' + port);
+console.log(files.length + ' files to be tested');
+
+page.onConsoleMessage = function (msg) { console.log(msg); };
+page.open('http://localhost:' + port + '/', function (status) {
+    if (status !== 'success') {
+        console.log('Unable to load main page!');
+        phantom.exit();
+    }
+    console.log('Page loaded');
+    window.setInterval(function () {
+        done = page.evaluate(function (files) {
+            if (!document.runningTests) {
+                console.log('Load wait...');
+                if (document.runTests) {
+                    console.log('Start tests ...');
+                    document.runningTests = true;
+                    document.runTests(files);
+                }
+            } else {
+                console.log('Wait...');
+                if (document.done) {
+                    console.log('All tests done');
+                    return true;
+                }
+            }
+            return false;
+        }, files);
+        if (done) {
+            console.log('Exit phantom');
+            phantom.exit();
+        }
+    }, 1000);
+});
+
+
+
+
+
+

data/vendor/node_modules/istanbul/test/browser/support/server.js

@@ -0,0 +1,154 @@
+/*jslint nomen: true */
+var handlebars = require('handlebars'),
+    path = require('path'),
+    fs = require('fs'),
+    templateFor = function (name) { return handlebars.compile(fs.readFileSync(path.resolve(__dirname, name), 'utf8')); },
+    reader = function () {
+        var args = Array.prototype.slice.call(arguments),
+            file;
+        args.unshift(__dirname);
+        file = path.resolve.apply(null, args);
+        return fs.readFileSync(file, 'utf8');
+    },
+    esprimaSource = reader('..', '..', '..', 'node_modules', 'esprima', 'esprima.js'),
+    escodegenSource = reader('..', '..', '..', 'node_modules', 'escodegen', 'escodegen.browser.js'),
+    vm = require('vm'),
+    server;
+
+function handleInitialPage(request, response) {
+    response.setHeader('content-type', 'text/html');
+    var template = templateFor('index.html');
+    response.end(template({ demo: server.demo ? 'yes' : '' }));
+}
+
+function handleEsprima(request, response) {
+    response.setHeader('content-type', 'application/javascript');
+    response.end(esprimaSource, 'utf8');
+}
+
+function handleEscodegen(request, response) {
+    response.setHeader('content-type', 'application/javascript');
+    response.end(escodegenSource, 'utf8');
+}
+
+function handleInstrumenter(request, response) {
+    response.setHeader('content-type', 'application/javascript');
+    var iPath = path.resolve(__dirname, '..', '..', '..', 'lib', 'instrumenter.js'),
+        instrumenterSource = fs.readFileSync(iPath, 'utf8');
+
+    if (server.instrumenter) {
+        response.end(server.instrumenter.instrumentSync(instrumenterSource, iPath), 'utf8');
+    } else {
+        response.end(instrumenterSource, 'utf8');
+    }
+}
+
+function handleFile(request, response) {
+    try {
+        var file = path.resolve(server.rootPath, request.url.substring(1)),
+            content;
+        content = fs.readFileSync(file, 'utf8');
+        response.setHeader('content-type', 'text/plain');
+        response.end(content, 'utf8');
+    } catch (ex) {
+        console.error(ex.message);
+        response.statusCode = 404;
+        response.end();
+    }
+}
+
+function getData(request, callback) {
+    var data = '';
+    request.setEncoding('utf8');
+    request.on('data', function (rdata) { data += rdata; });
+    request.on('end', function () {
+        callback(data);
+    });
+}
+
+function handleInstrumented(request, response) {
+    var script,
+        ok = true,
+        err = null;
+    getData(request, function (data) {
+        server.emit('instrumented', request.url.substring(1), data);
+        try {
+            script = vm.createScript(data, request.url);
+        } catch (ex) {
+            console.error('Invalid JS returned for:' + request.url);
+            ok = false;
+            err = ex.message || ex.toString();
+        }
+        response.setHeader('content-type', 'application/json');
+        response.end(JSON.stringify({ ok: ok, err: err }), 'utf8');
+    });
+}
+
+function handleEnd(request, response) {
+    var ok = true,
+        obj;
+    getData(request, function (data) {
+        try {
+            obj = JSON.parse(data);
+        } catch (ex) {
+            console.error(ex.message || ex);
+            console.error(ex.stack);
+            ok = false;
+        }
+        server.emit('done', obj);
+        response.end(JSON.stringify({ ok: ok }, 'utf8'));
+    });
+}
+
+function handler(request, response) {
+    console.log(request.method + ' ' + request.url);
+    if (request.method === 'GET') {
+        switch (request.url) {
+        case '/':
+            handleInitialPage(request, response);
+            break;
+        case '/_esprima.js':
+            handleEsprima(request, response);
+            break;
+        case '/_escodegen.js':
+            handleEscodegen(request, response);
+            break;
+        case '/_instrumenter.js':
+            handleInstrumenter(request, response);
+            break;
+        default:
+            handleFile(request, response);
+            break;
+        }
+    } else if (request.method === 'POST') {
+        switch (request.url) {
+        case '/':
+            handleEnd(request, response);
+            break;
+        default:
+            handleInstrumented(request, response);
+            break;
+        }
+    }
+}
+
+function create(port, instrumenter, root, demo) {
+    server = require('http').createServer(handler);
+    server.instrumenter = instrumenter;
+    server.rootPath = root;
+    server.listen(port);
+    server.demo = demo;
+    return server;
+}
+
+module.exports = {
+    create: create
+};
+
+if (module === require.main) {
+    (function () {
+        var port = process.argv[2] || 9000;
+        create(port, null, path.resolve(__dirname, '..', '..'), true);
+        console.log('Listening on http://localhost:' + port + '/');
+    }());
+}

data/vendor/node_modules/istanbul/test/browser/test-browser-instrumentation.js

@@ -0,0 +1,94 @@
+/*jslint nomen: true */
+var which = require('which'),
+    phantom,
+    path = require('path'),
+    fs = require('fs'),
+    child_process = require('child_process'),
+    filesFor = require('../../lib/util/file-matcher').filesFor,
+    Instrumenter = require('../../lib/instrumenter'),
+    instrumenter = new Instrumenter({ backdoor: { omitTrackerSuffix: true } }),
+    ROOT = path.resolve(__dirname, '..', '..', 'lib'),
+    common = require('../common'),
+    filesToInstrument,
+    server,
+    exited,
+    cp;
+
+function runPhantom(cmd, script, port, files) {
+    var args = [ script ];
+    args.push(port);
+    args.push.apply(args, files);
+    console.log('Start phantom');
+    cp = child_process.spawn(cmd, args);
+    cp.stdout.on('data', function (data) { process.stdout.write(data); });
+    cp.stderr.on('data', function (data) { process.stderr.write(data); });
+    cp.on('exit', function () {
+        exited = 1;
+    });
+}
+
+module.exports = {
+    setUp: function (cb) {
+        try {
+            phantom = which.sync('phantomjs');
+        } catch (ex) {}
+        filesFor({
+            root: ROOT,
+            includes: [ '**/*.js' ],
+            xexcludes: [ '**/instrumenter.js' ],
+            relative: true
+        }, function (err, files) {
+            filesToInstrument = files;
+            cb();
+        });
+    },
+    "should produce identical instrumentation results when instrumentation run on browser v/s nodejs": function (test) {
+        if (!phantom) {
+            console.error('******************************************************************');
+            console.error('No phantomjs found on path, skipping browser instrumentation test');
+            console.error('******************************************************************');
+            test.done();
+            return;
+        }
+        var finalFn = function () {
+            if (server) { server.close(); }
+            if (!cp.exited) { cp.kill(); }
+        },
+            server,
+            port = 9000;
+        try {
+            console.log('Start server');
+            server = require('./support/server').create(port, process.env.SELF_COVER ? instrumenter : null, ROOT);
+            server.on('instrumented', function (file, instrumented) {
+                var code = fs.readFileSync(path.resolve(ROOT, file), 'utf8'),
+                    serverSideInstrumented = instrumenter.instrumentSync(code, file);
+                test.equal(serverSideInstrumented, instrumented, 'No match for [' + file + ']');
+            });
+            server.on('done', function (coverage) {
+                if (common.isSelfCover()) {
+                    try {
+                        if (coverage) {
+                            fs.writeFileSync(path.resolve(common.getCoverageDir(), 'coverage-browser.json'), JSON.stringify(coverage), 'utf8');
+                        } else {
+                            console.log('No coverage found');
+                        }
+                    } catch (err) {
+                        console.error(err.message || err);
+                        console.error(err.stack);
+                        test.ok(false, err.message || err);
+                    }
+                }
+                finalFn();
+                test.done();
+            });
+            runPhantom(phantom, path.resolve(__dirname, 'support', 'phantom-test.client.js'), port, filesToInstrument);
+        } catch (ex) {
+            console.error(ex.message || ex);
+            console.error(ex.stack);
+            test.ok(false, ex.message || ex);
+            test.done();
+        }
+
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli-helper.js

@@ -0,0 +1,219 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    cp = require('child_process'),
+    Module = require('module'),
+    originalLoader = Module._extensions['.js'],
+    common = require('./common'),
+    MAIN_FILE = path.resolve(__dirname, '..', 'lib', 'cli.js'),
+    DEFAULT_CWD = path.resolve(__dirname, 'cli', 'sample-project'),
+    COVER_ROOT = path.resolve(__dirname, '..'),
+    EXCLUDES = [ '**/node_modules/**', '**/test/**', '**/yui-load-hook.js'],
+    COVER_VAR = '$$selfcover$$',
+    seq = 0,
+    verbose = false,
+    OPTS = {
+    };
+
+/*
+ * Danger, Will Robinson! A lot of small stuff has to fall in place just so
+ * for self-coverage to work correctly for command line tests.
+ *
+ * In no-self-cover mode, this class does very little - which is:
+ *
+ *  1. Create a child process to run the supplied istanbul command
+ *  2. Callback the test case with an object that allows the test case
+ *      to grep on stdout and stderr, inspect exit codes etc.
+ *  3. This is a "correct" test because we run the commands exactly as they
+ *      would be run by the user.
+ *
+ * In self-cover mode, this works slightly differently:
+ *
+ *  1. Sets up a bunch of environment variables to keep track of what it was
+ *      asked to do
+ *  2. Creates a child process forking _itself_. Returns the same object to
+ *      the caller for purposes of grepping stdout, inspecting status codes etc.
+ *  3. In the child process,
+ *      a. hooks the module loader to set up coverage for our library code
+ *      b. Ensures that the `hook` module is not loaded until all this happens
+  *         so that the hook module sees _our_ module loader hook as the original
+  *         loader. This ensures that our hook will be used to instrument this
+  *         library's code. Note that the hook set up by the `cover` command that
+  *         is executed only instruments the modules of the sample test library.
+  *     c. Calls Module.runMain on the command that it was asked to invoke
+  *     d. Sets up an exit handler to write the coverage information for our
+  *         library calls
+ *   4. The exit handler is also set up in special ways because in order to
+ *      instrument the `cover` command's exit handler, our exit handler has
+ *      to be added later so as to be able to track coverage for the cover
+ *      commands handler.
+ *
+ *      Since there is no general purpose way in which this can be correctly
+ *      done, test cases have to indicate which ones expect the exit handler
+ *      to be set up in the cover module and which ones do not. This is the
+ *      reason `setOpts` exists.
+ *
+ */
+
+function setVerbose(flag) {
+    verbose = flag;
+}
+function setOpts(userOpts) {
+    Object.keys(userOpts).forEach(function (k) { OPTS[k] = userOpts[k]; });
+}
+
+function resetOpts() {
+    OPTS = {};
+}
+
+function runCommand(command, args, envVars, callback) {
+    var cmd = 'node',
+        selfCover = common.isSelfCover(),
+        env = {},
+        handle,
+        out = '',
+        err = '',
+        exitCode = 1,
+        grepper = function (array) {
+            return function (pat) {
+                var filtered = array.filter(function (item) {
+                    return item.match(pat);
+                });
+                if (filtered.length === 0) {
+                    if (verbose) {
+                        console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
+                        console.log('Could not find: ' + pat + ' in:');
+                        console.log(array.join('\n'));
+                        console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
+                    }
+                }
+                return filtered.length > 0;
+            };
+        };
+
+    if (selfCover) {
+        seq += 1;
+        env.COMMAND_NAME = command || '';
+        env.COMMAND_ARGS = args.join('\t');
+        env.COVERAGE_FILE = 'coverage-' + seq + '.json';
+        env.LAZY_HOOK = OPTS.lazyHook ? '1' : '';
+        args = [ __filename ];
+    } else {
+        if (command) {
+            args.unshift(command);
+        }
+        args.unshift(MAIN_FILE);
+    }
+
+    if (!callback && typeof envVars === 'function') {
+        callback = envVars;
+        envVars = {};
+    }
+
+    Object.keys(process.env).forEach(function (key) {
+        env[key] = process.env[key];
+    });
+
+    Object.keys(envVars).forEach(function (key) {
+        env[key] = envVars[key];
+    });
+
+    handle = cp.spawn(cmd, args, { env: env, cwd: OPTS.cwd || DEFAULT_CWD });
+    handle.stdout.setEncoding('utf8');
+    handle.stderr.setEncoding('utf8');
+    handle.stdout.on('data', function (data) {
+        out += data;
+        if (verbose) {
+            process.stdout.write(data);
+        }
+    });
+    handle.stderr.on('data', function (data) {
+        err += data;
+        if (verbose) {
+            process.stderr.write(data);
+        }
+    });
+    handle.on('exit', function (code) {
+        exitCode = code;
+        setTimeout(function () {
+            out = out.split(/\r?\n/);
+            err = err.split(/\r?\n/);
+            callback({
+                succeeded: function () { return exitCode === 0; },
+                exitCode: exitCode,
+                stdout: function () { return out; },
+                stderr: function () { return err; },
+                grepOutput: grepper(out),
+                grepError: grepper(err)
+            });
+        }, 100);
+    });
+}
+
+function customHook(lazyHook, callback) {
+    var Instrumenter = require('../lib/instrumenter'),
+        instrumenter = new Instrumenter({ coverageVariable: COVER_VAR }),
+        transformer = function (file) {
+            return instrumenter.instrumentSync(fs.readFileSync(file, 'utf8'), file);
+        },
+        handler = function () {
+            process.once('exit', function () {
+                var file;
+                if (typeof global[COVER_VAR] !== 'undefined') {
+                    file = path.resolve(common.getCoverageDir(), process.env.COVERAGE_FILE);
+                    fs.writeFileSync(file, JSON.stringify(global[COVER_VAR], undefined, 4), 'utf8');
+                }
+            });
+        };
+
+    require('../lib/util/file-matcher').matcherFor({ root : COVER_ROOT, excludes: EXCLUDES, includes: [ '**/*.js'] }, function (err, matcher) {
+        var added = false;
+
+        Module._extensions['.js'] = function (module, filename) {
+            if (matcher(filename)) {
+                module._compile(transformer(filename), filename);
+            } else {
+                originalLoader(module, filename);
+            }
+        };
+
+        if (!lazyHook) {
+            handler();
+        } else {
+            process.on('newListener', function (event) {
+                if (event === 'exit') {
+                    if (!added) {
+                        added = true;
+                        process.nextTick(function () {
+                            handler();
+                        });
+                    }
+                }
+            });
+        }
+        callback();
+    });
+}
+
+module.exports = {
+    setVerbose: setVerbose,
+    runCommand: runCommand,
+    resetOpts: resetOpts,
+    setOpts: setOpts
+};
+
+if (require.main === module) { //we are running ourselves under self-cover
+    (function () {
+        var command = process.env.COMMAND_NAME,
+            args = process.env.COMMAND_ARGS ? process.env.COMMAND_ARGS.split(/\t/) : [],
+            fullArgs = [];
+
+        if (command) { fullArgs.push(command); }
+        fullArgs.push.apply(fullArgs, args);
+        customHook(process.env.LAZY_HOOK, function () {
+            console.error('Running command using CLI object:' + JSON.stringify({ cmd: command, args: args }));
+            require('../lib/cli').runToCompletion(fullArgs);
+        });
+    }());
+}
+