cssesc-source 0.1.0

data/vendor/node_modules/istanbul/index.js

@@ -0,0 +1,115 @@
+/*
+Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+*/
+
+/**
+ * provides access to the key libraries in istanbul so you can write
+ * your own tools using `istanbul` as a library.
+ *
+ * @module istanbul
+ */
+
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    Store = require('./lib/store'),
+    Report = require('./lib/report'),
+    meta = require('./lib/util/meta');
+
+//register our standard plaugins
+require('./lib/register-plugins');
+
+/**
+ * the top-level API for `istanbul`.
+ *
+ * Usage
+ * -----
+ *
+ *      var istanbul = require('istanbul');
+ *
+ *
+ * @class API
+ */
+
+module.exports = {
+    /**
+     * the Instrumenter class.
+     * @property {Instrumenter} Instrumenter
+     * @static
+     */
+    Instrumenter: require('./lib/instrumenter'),
+    /**
+     * the Store class.
+     * @property {Store} Store
+     * @static
+     */
+    Store: Store,
+    /**
+     * the Collector class
+     * @property {Collector} Collector
+     * @static
+     */
+    Collector: require('./lib/collector'),
+    /**
+     * the hook module
+     * @property {Hook} hook
+     * @static
+     */
+    hook: require('./lib/hook'),
+    /**
+     * the Report class
+     * @property {Report} Report
+     * @static
+     */
+    Report: Report,
+    /**
+     * utility for processing coverage objects
+     * @property {ObjectUtils} utils
+     * @static
+     */
+    utils: require('./lib/object-utils'),
+    /**
+     * asynchronously returns a function that can match filesystem paths.
+     * The function returned in the callback may be passed directly as a `matcher`
+     * to the functions in the `hook` module.
+     *
+     * When no options are passed, the match function is one that matches all JS
+     * files under the current working directory except ones under `node_modules`
+     *
+     * Match patterns are `ant`-style patterns processed using the `fileset` library.
+     * Examples not provided due to limitations in putting asterisks inside
+     * jsdoc comments. Please refer to tests under `test/other/test-matcher.js`
+     * for examples.
+     *
+     * @method matcherFor
+     * @static
+     * @param {Object} options Optional. Lookup options.
+     * @param {String} [options.root] the root of the filesystem tree under
+     *     which to match files. Defaults to `process.cwd()`
+     * @param {Array} [options.includes] an array of include patterns to match.
+     *     Defaults to all JS files under the root.
+     * @param {Array} [options.excludes] and array of exclude patterns. File paths
+     *     matching these patterns will be excluded by the returned matcher.
+     *     Defaults to files under `node_modules` found anywhere under root.
+     * @param {Function(err, matchFunction)} callback  The callback that is
+     *      called with two arguments. The first is an `Error` object in case
+     *      of errors or a falsy value if there were no errors. The second
+     *      is a function that may be use as a matcher.
+     */
+    matcherFor: require('./lib/util/file-matcher').matcherFor,
+    /**
+     * the version of the library
+     * @property {String} VERSION
+     * @static
+     */
+    VERSION: meta.VERSION,
+    //undocumented
+    _yuiLoadHook: require('./lib/util/yui-load-hook'),
+    //undocumented
+    TreeSummarizer: require('./lib/util/tree-summarizer'),
+    //undocumented
+    assetsDir: path.resolve(__dirname, 'lib', 'vendor')
+};
+
+

data/vendor/node_modules/istanbul/lib/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+
+var Command = require('./command'),
+    inputError = require('./util/input-error'),
+    util = require('util'),
+    exit = process.exit; //hold a reference to original process.exit so that we are not affected even when a test changes it
+
+require('./register-plugins');
+
+function findCommandPosition(args) {
+    var i;
+
+    for (i = 0; i < args.length; i += 1) {
+        if (args[i].charAt(0) !== '-') {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+function errHandler (ex) {
+    if (!ex) { return; }
+    if (!ex.inputError) {
+        throw ex; // turn it into an uncaught exception
+    } else {
+        //don't print nasty traces but still exit(1)
+        util.error(ex.message);
+        util.error('Try "istanbul help" for usage');
+        exit(1);
+    }
+}
+
+function runCommand(args, callback) {
+    var pos = findCommandPosition(args),
+        command,
+        commandArgs,
+        commandObject;
+
+    if (pos < 0) {
+        return callback(inputError.create('Need a command to run'));
+    }
+
+    commandArgs = args.slice(0, pos);
+    command = args[pos];
+    commandArgs.push.apply(commandArgs, args.slice(pos + 1));
+
+    try {
+        commandObject = Command.create(command);
+    } catch (ex) {
+        errHandler(inputError.create(ex.message));
+    }
+    commandObject.run(commandArgs, errHandler);
+}
+
+function runToCompletion(args) {
+    runCommand(args, errHandler);
+}
+
+if (require.main === module) {
+    var args = Array.prototype.slice.call(process.argv, 2);
+    runToCompletion(args);
+}
+
+module.exports = {
+    runToCompletion: runToCompletion
+};
+

data/vendor/node_modules/istanbul/lib/collector.js

@@ -0,0 +1,121 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+var MemoryStore = require('./store/memory'),
+    utils = require('./object-utils');
+
+/**
+ * a mechanism to merge multiple coverage objects into one. Handles the use case
+ * of overlapping coverage information for the same files in multiple coverage
+ * objects and does not double-count in this situation. For example, if
+ * you pass the same coverage object multiple times, the final merged object will be
+ * no different that any of the objects passed in (except for execution counts).
+ *
+ * The `Collector` is built for scale to handle thousands of coverage objects.
+ * By default, all processing is done in memory since the common use-case is of
+ * one or a few coverage objects. You can work around memory
+ * issues by passing in a `Store` implementation that stores temporary computations
+ * on disk (the `tmp` store, for example).
+ *
+ * The `getFinalCoverage` method returns an object with merged coverage information
+ * and is provided as a convenience for implementors working with coverage information
+ * that can fit into memory. Reporters, in the interest of generality, should *not* use this method for
+ * creating reports.
+ *
+ * Usage
+ * -----
+ *
+ *      var collector = new require('istanbul').Collector();
+ *
+ *      files.forEach(function (f) {
+ *          //each coverage object can have overlapping information about multiple files
+ *          collector.add(JSON.parse(fs.readFileSync(f, 'utf8')));
+ *      });
+ *
+ *      collector.files().forEach(function(file) {
+ *          var fileCoverage = collector.fileCoverageFor(file);
+ *          console.log('Coverage for ' + file + ' is:' + JSON.stringify(fileCoverage));
+ *      });
+ *
+ *      // convenience method: do not use this when dealing with a large number of files
+ *      var finalCoverage = collector.getFinalCoverage();
+ *
+ * @class Collector
+ * @constructor
+ * @param {Object} options Optional. Configuration options.
+ * @param {Store} options.store - an implementation of `Store` to use for temporary
+ *      calculations.
+ */
+function Collector(options) {
+    options = options || {};
+    this.store = options.store || new MemoryStore();
+}
+
+Collector.prototype = {
+    /**
+     * adds a coverage object to the collector.
+     *
+     * @method add
+     * @param {Object} coverage the coverage object.
+     * @param {String} testName Optional. The name of the test used to produce the object.
+     *      This is currently not used.
+     */
+    add: function (coverage /*, testName */) {
+        var store = this.store;
+        Object.keys(coverage).forEach(function (key) {
+            var fileCoverage = coverage[key];
+            if (store.hasKey(key)) {
+                store.setObject(key, utils.mergeFileCoverage(fileCoverage, store.getObject(key)));
+            } else {
+                store.setObject(key, fileCoverage);
+            }
+        });
+    },
+    /**
+     * returns a list of unique file paths for which coverage information has been added.
+     * @method files
+     * @return {Array} an array of file paths for which coverage information is present.
+     */
+    files: function () {
+        return this.store.keys();
+    },
+    /**
+     * return file coverage information for a single file
+     * @method fileCoverageFor
+     * @param {String} fileName the path for the file for which coverage information is
+     *      required. Must be one of the values returned in the `files()` method.
+     * @return {Object} the coverage information for the specified file.
+     */
+    fileCoverageFor: function (fileName) {
+        var ret = this.store.getObject(fileName);
+        utils.addDerivedInfoForFile(ret);
+        return ret;
+    },
+    /**
+     * returns file coverage information for all files. This has the same format as
+     * any of the objects passed in to the `add` method. The number of keys in this
+     * object will be a superset of all keys found in the objects passed to `add()`
+     * @method getFinalCoverage
+     * @return {Object} the merged coverage information
+     */
+    getFinalCoverage: function () {
+        var ret = {},
+            that = this;
+        this.files().forEach(function (file) {
+            ret[file] = that.fileCoverageFor(file);
+        });
+        return ret;
+    },
+    /**
+     * disposes this collector and reclaims temporary resources used in the
+     * computation. Calls `dispose()` on the underlying store.
+     * @method dispose
+     */
+    dispose: function () {
+        this.store.dispose();
+    }
+};
+
+module.exports = Collector;

data/vendor/node_modules/istanbul/lib/command/check-coverage.js

@@ -0,0 +1,115 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+var nopt = require('nopt'),
+    path = require('path'),
+    fs = require('fs'),
+    Collector = require('../collector'),
+    formatOption = require('../util/help-formatter').formatOption,
+    util = require('util'),
+    utils = require('../object-utils'),
+    filesFor = require('../util/file-matcher').filesFor,
+    Command = require('./index');
+
+function CheckCoverageCommand() {
+    Command.call(this);
+}
+
+CheckCoverageCommand.TYPE = 'check-coverage';
+util.inherits(CheckCoverageCommand, Command);
+
+Command.mix(CheckCoverageCommand, {
+    synopsis: function () {
+        return "checks overall coverage against thresholds from coverage JSON files. Exits 1 if thresholds are not met, 0 otherwise";
+    },
+
+    usage: function () {
+        util.error('\nUsage: ' + this.toolName() + ' ' + this.type() + ' <options> [<include-pattern>]\n\nOptions are:\n\n' +
+            [
+                formatOption('--statements <threshold>', 'statement coverage threshold'),
+                formatOption('--functions <threshold>', 'function coverage threshold'),
+                formatOption('--branches <threshold>', 'branch coverage threshold'),
+                formatOption('--lines <threshold>', 'line coverage threshold')
+            ].join('\n\n') + '\n');
+
+        util.error('\n\n');
+
+        util.error('Thresholds, when specified as a positive number are taken to be the minimum percentage required.');
+        util.error('When a threshold is specified as a negative number it represents the maximum number of uncovered entities allowed.\n');
+        util.error('For example, --statements 90 implies minimum statement coverage is 90%.');
+        util.error('             --statements -10 implies that no more than 10 uncovered statements are allowed\n');
+        util.error('<include-pattern> is a fileset pattern that can be used to select one or more coverage files ' +
+            'for merge. This defaults to "**/coverage*.json"');
+
+        util.error('\n');
+    },
+
+    run: function (args, callback) {
+
+        var config = {
+                root: path,
+                dir: path,
+                statements: Number,
+                lines: Number,
+                branches: Number,
+                functions: Number,
+                verbose: Boolean
+            },
+            opts = nopt(config, { v : '--verbose' }, args, 0),
+            includePattern = '**/coverage*.json',
+            root,
+            collector = new Collector(),
+            errors = [];
+
+        if (opts.argv.remain.length > 0) {
+            includePattern = opts.argv.remain[0];
+        }
+
+        root = opts.root || process.cwd();
+        filesFor({
+            root: root,
+            includes: [ includePattern ]
+        }, function (err, files) {
+            if (err) { throw err; }
+            files.forEach(function (file) {
+                var coverageObject =  JSON.parse(fs.readFileSync(file, 'utf8'));
+                collector.add(coverageObject);
+            });
+            var thresholds = {
+                statements: opts.statements || 0,
+                branches: opts.branches || 0,
+                lines: opts.lines || 0,
+                functions: opts.functions || 0
+            },
+                actuals = utils.summarizeCoverage(collector.getFinalCoverage());
+
+            if (opts.verbose) {
+                console.log('Compare actuals against thresholds');
+                console.log(JSON.stringify({ actuals: actuals, thresholds: thresholds }, undefined, 4));
+            }
+
+            Object.keys(thresholds).forEach(function (key) {
+                var actual = actuals[key].pct,
+                    actualUncovered = actuals[key].total - actuals[key].covered,
+                    threshold = thresholds[key];
+
+                if (threshold < 0) {
+                    if (threshold * -1 < actualUncovered) {
+                        errors.push('ERROR: Uncovered count for ' + key + ' (' + actualUncovered + ') exceeds threshold (' + -1 * threshold + ')');
+                    }
+                } else {
+                    if (actual < threshold) {
+                        errors.push('ERROR: Coverage for ' + key + ' (' + actual + '%) does not meet threshold (' + threshold + '%)');
+                    }
+                }
+            });
+            return callback(errors.length === 0 ? null : errors.join("\n"));
+        });
+    }
+});
+
+module.exports = CheckCoverageCommand;
+
+

data/vendor/node_modules/istanbul/lib/command/common/run-with-cover.js

@@ -0,0 +1,199 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+var Module = require('module'),
+    path = require('path'),
+    fs = require('fs'),
+    nopt = require('nopt'),
+    which = require('which'),
+    mkdirp = require('mkdirp'),
+    existsSync = fs.existsSync || path.existsSync,
+    inputError = require('../../util/input-error'),
+    matcherFor = require('../../util/file-matcher').matcherFor,
+    Instrumenter = require('../../instrumenter'),
+    Collector = require('../../collector'),
+    formatOption = require('../../util/help-formatter').formatOption,
+    hook = require('../../hook'),
+    Report = require('../../report'),
+    resolve = require('resolve'),
+    DEFAULT_REPORT_FORMAT = 'lcov';
+
+function usage(arg0, command) {
+    console.error('\nUsage: ' + arg0 + ' ' + command + ' [<options>] <executable-js-file-or-command> [-- <arguments-to-jsfile>]\n\nOptions are:\n\n'
+        + [
+            formatOption('--root <path> ', 'the root path to look for files to instrument, defaults to .'),
+            formatOption('-x <exclude-pattern> [-x <exclude-pattern>]', 'one or more fileset patterns e.g. "**/vendor/**"'),
+            formatOption('--[no-]default-excludes', 'apply default excludes [ **/node_modules/**, **/test/**, **/tests/** ], defaults to true'),
+            formatOption('--hook-run-in-context', 'hook vm.runInThisContext in addition to require (supports RequireJS), defaults to false'),
+            formatOption('--post-require-hook <file> | <module>', 'JS module that exports a function for post-require processing'),
+            formatOption('--report <report-type>', 'report type, one of html, lcov, lcovonly, none, defaults to lcov (= lcov.info + HTML)'),
+            formatOption('--dir <report-dir>', 'report directory, defaults to ./coverage'),
+            formatOption('--print <type>', 'type of report to print to console, one of summary (default), detail, both or none'),
+            formatOption('--verbose, -v', 'verbose mode')
+        ].join('\n\n') + '\n');
+    console.error('\n');
+}
+
+function run(args, commandName, enableHooks, callback) {
+
+    var config = {
+            root: path,
+            x: [Array, String],
+            report: String,
+            dir: path,
+            verbose: Boolean,
+            yui: Boolean,
+            'default-excludes': Boolean,
+            print: String,
+            'self-test': Boolean,
+            'hook-run-in-context': Boolean,
+            'post-require-hook': String
+        },
+        opts = nopt(config, { v : '--verbose' }, args, 0),
+        cmdAndArgs = opts.argv.remain,
+        cmd,
+        cmdArgs,
+        reportingDir,
+        reportClassName,
+        reports = [],
+        runFn,
+        excludes;
+
+    if (cmdAndArgs.length === 0) {
+        return callback(inputError.create('Need a filename argument for the ' + commandName + ' command!'));
+    }
+
+    cmd = cmdAndArgs.shift();
+    cmdArgs = cmdAndArgs;
+
+    if (!existsSync(cmd)) {
+        try {
+            cmd = which.sync(cmd);
+        } catch (ex) {
+            return callback(inputError.create('Unable to resolve file [' + cmd + ']'));
+        }
+    } else {
+        cmd = path.resolve(cmd);
+    }
+
+    runFn = function () {
+        process.argv = ["node", cmd].concat(cmdArgs);
+        if (opts.verbose) {
+            console.log('Running: ' + process.argv.join(' '));
+        }
+        process.env.running_under_istanbul=1;
+        Module.runMain(cmd, null, true);
+    };
+
+    excludes = typeof opts['default-excludes'] === 'undefined' || opts['default-excludes'] ?
+            [ '**/node_modules/**', '**/test/**', '**/tests/**' ] : [];
+    excludes.push.apply(excludes, opts.x);
+
+    if (enableHooks) {
+        reportingDir = opts.dir || path.resolve(process.cwd(), 'coverage');
+        mkdirp.sync(reportingDir); //ensure we fail early if we cannot do this
+        reportClassName = opts.report || DEFAULT_REPORT_FORMAT;
+        reports.push(Report.create(reportClassName, { dir: reportingDir }));
+        if (opts.print !== 'none') {
+            switch (opts.print) {
+            case 'detail':
+                reports.push(Report.create('text'));
+                break;
+            case 'both':
+                reports.push(Report.create('text'));
+                reports.push(Report.create('text-summary'));
+                break;
+            default:
+                reports.push(Report.create('text-summary'));
+                break;
+            }
+        }
+
+        matcherFor({
+            root: opts.root || process.cwd(),
+            includes: [ '**/*.js' ],
+            excludes: excludes
+        },
+            function (err, matchFn) {
+                if (err) { return callback(err); }
+
+                var coverageVar = '$$cov_' + new Date().getTime() + '$$',
+                    instrumenter = new Instrumenter({ coverageVariable: coverageVar }),
+                    transformer = instrumenter.instrumentSync.bind(instrumenter),
+                    hookOpts = { verbose: opts.verbose },
+                    postRequireHook = opts['post-require-hook'],
+                    postLoadHookFile;
+
+                if (postRequireHook) {
+                    postLoadHookFile = path.resolve(postRequireHook);
+                } else if (opts.yui) { //EXPERIMENTAL code: do not rely on this in anyway until the docs say it is allowed
+                    postLoadHookFile = path.resolve(__dirname, '../../util/yui-load-hook');
+                }
+
+                if (postRequireHook) {
+                    if (!existsSync(postLoadHookFile)) { //assume it is a module name and resolve it
+                        try {
+                            postLoadHookFile = resolve.sync(postRequireHook, { basedir: process.cwd() });
+                        } catch (ex) {
+                            if (opts.verbose) { console.error('Unable to resolve [' + postRequireHook + '] as a node module'); }
+                        }
+                    }
+                }
+                if (postLoadHookFile) {
+                    if (opts.verbose) { console.log('Use post-load-hook: ' + postLoadHookFile); }
+                    hookOpts.postLoadHook = require(postLoadHookFile)(matchFn, transformer, opts.verbose);
+                }
+
+                if (opts['self-test']) {
+                    hook.unloadRequireCache(matchFn);
+                }
+                // runInThisContext is used by RequireJS [issue #23]
+                if (opts['hook-run-in-context']) {
+                    hook.hookRunInThisContext(matchFn, transformer, hookOpts);
+                }
+                hook.hookRequire(matchFn, transformer, hookOpts);
+
+                //initialize the global variable to stop mocha from complaining about leaks
+                global[coverageVar] = {};
+
+                process.once('exit', function () {
+                    var file = path.resolve(reportingDir, 'coverage.json'),
+                        collector,
+                        cov;
+                    if (typeof global[coverageVar] === 'undefined' || Object.keys(global[coverageVar]).length === 0) {
+                        console.error('No coverage information was collected, exit without writing coverage information');
+                        return;
+                    } else {
+                        cov = global[coverageVar];
+                    }
+                    //important: there is no event loop at this point
+                    //everything that happens in this exit handler MUST be synchronous
+                    mkdirp.sync(reportingDir); //yes, do this again since some test runners could clean the dir initially created
+                    if (opts.print !== 'none') {
+                        console.error('=============================================================================');
+                        console.error('Writing coverage object [' + file + ']');
+                    }
+                    fs.writeFileSync(file, JSON.stringify(cov), 'utf8');
+                    collector = new Collector();
+                    collector.add(cov);
+                    if (opts.print !== 'none') {
+                        console.error('Writing coverage reports at [' + reportingDir + ']');
+                        console.error('=============================================================================');
+                    }
+                    reports.forEach(function (report) {
+                        report.writeReport(collector, true);
+                    });
+                    return callback();
+                });
+                runFn();
+            });
+    } else {
+        runFn();
+    }
+}
+
+module.exports = {
+    run: run,
+    usage: usage
+};