cssesc-source 0.1.0

data/vendor/node_modules/istanbul/lib/object-utils.js

@@ -0,0 +1,341 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/**
+ * utility methods to process coverage objects. A coverage object has the following
+ * format.
+ *
+ *      {
+ *          "/path/to/file1.js": { file1 coverage },
+ *          "/path/to/file2.js": { file2 coverage }
+ *      }
+ *
+ *  The internals of the file coverage object are intentionally not documented since
+ *  it is not a public interface.
+ *
+ *  *Note:* When a method of this module has the word `File` in it, it will accept
+ *  one of the sub-objects of the main coverage object as an argument. Other
+ *  methods accept the higher level coverage object with multiple keys.
+ *
+ * Works on `node` as well as the browser.
+ *
+ * Usage on nodejs
+ * ---------------
+ *
+ *      var objectUtils = require('istanbul').utils;
+ *
+ * Usage in a browser
+ * ------------------
+ *
+ * Load this file using a `script` tag or other means. This will set `window.coverageUtils`
+ * to this module's exports.
+ *
+ * @class ObjectUtils
+ * @static
+ */
+(function (isNode) {
+    /**
+     * adds line coverage information to a file coverage object, reverse-engineering
+     * it from statement coverage. The object passed in is updated in place.
+     *
+     * Note that if line coverage information is already present in the object,
+     * it is not recomputed.
+     *
+     * @method addDerivedInfoForFile
+     * @static
+     * @param {Object} fileCoverage the coverage object for a single file
+     */
+    function addDerivedInfoForFile(fileCoverage) {
+        var statementMap = fileCoverage.statementMap,
+            statements = fileCoverage.s,
+            lineMap;
+
+        if (!fileCoverage.l) {
+            fileCoverage.l = lineMap = {};
+            Object.keys(statements).forEach(function (st) {
+                var line = statementMap[st].start.line,
+                    count = statements[st],
+                    prevVal = lineMap[line];
+                if (typeof prevVal === 'undefined' || prevVal < count) {
+                    lineMap[line] = count;
+                }
+            });
+        }
+    }
+    /**
+     * adds line coverage information to all file coverage objects.
+     *
+     * @method addDerivedInfo
+     * @static
+     * @param {Object} coverage the coverage object
+     */
+    function addDerivedInfo(coverage) {
+        Object.keys(coverage).forEach(function (k) {
+            addDerivedInfoForFile(coverage[k]);
+        });
+    }
+    /**
+     * removes line coverage information from all file coverage objects
+     * @method removeDerivedInfo
+     * @static
+     * @param {Object} coverage the coverage object
+     */
+    function removeDerivedInfo(coverage) {
+        Object.keys(coverage).forEach(function (k) {
+            delete coverage[k].l;
+        });
+    }
+
+    function percent(covered, total) {
+        var tmp;
+        if (total > 0) {
+            tmp = 1000 * 100 * covered / total + 5;
+            return Math.floor(tmp / 10) / 100;
+        } else {
+            return 100.00;
+        }
+    }
+
+    function computeSimpleTotals(fileCoverage, property) {
+        var stats = fileCoverage[property],
+            ret = { total: 0, covered: 0 };
+
+        Object.keys(stats).forEach(function (key) {
+            ret.total += 1;
+            if (stats[key]) {
+                ret.covered += 1;
+            }
+        });
+        ret.pct = percent(ret.covered, ret.total);
+        return ret;
+    }
+
+    function computeBranchTotals(fileCoverage) {
+        var stats = fileCoverage.b,
+            ret = { total: 0, covered: 0 };
+
+        Object.keys(stats).forEach(function (key) {
+            var branches = stats[key],
+                covered = branches.filter(function (num) { return num > 0; });
+            ret.total += branches.length;
+            ret.covered += covered.length;
+        });
+        ret.pct = percent(ret.covered, ret.total);
+        return ret;
+    }
+    /**
+     * returns a blank summary metrics object. A metrics object has the following
+     * format.
+     *
+     *      {
+     *          lines: lineMetrics,
+     *          statements: statementMetrics,
+     *          functions: functionMetrics,
+     *          branches: branchMetrics
+     *      }
+     *
+     *  Each individual metric object looks as follows:
+     *
+     *      {
+     *          total: n,
+     *          covered: m,
+     *          pct: percent
+     *      }
+     *
+     * @method blankSummary
+     * @static
+     * @return {Object} a blank metrics object
+     */
+    function blankSummary() {
+        return {
+            lines: {
+                total: 0,
+                covered: 0,
+                pct: 'Unknown'
+            },
+            statements: {
+                total: 0,
+                covered: 0,
+                pct: 'Unknown'
+            },
+            functions: {
+                total: 0,
+                covered: 0,
+                pct: 'Unknown'
+            },
+            branches: {
+                total: 0,
+                covered: 0,
+                pct: 'Unknown'
+            }
+        };
+    }
+    /**
+     * returns the summary metrics given the coverage object for a single file. See `blankSummary()`
+     * to understand the format of the returned object.
+     *
+     * @method summarizeFileCoverage
+     * @static
+     * @param {Object} fileCoverage the coverage object for a single file.
+     * @return {Object} the summary metrics for the file
+     */
+    function summarizeFileCoverage(fileCoverage) {
+        var ret = blankSummary();
+        addDerivedInfoForFile(fileCoverage);
+        ret.lines = computeSimpleTotals(fileCoverage, 'l');
+        ret.functions = computeSimpleTotals(fileCoverage, 'f');
+        ret.statements = computeSimpleTotals(fileCoverage, 's');
+        ret.branches = computeBranchTotals(fileCoverage);
+        return ret;
+    }
+    /**
+     * merges two instances of file coverage objects *for the same file*
+     * such that the execution counts are correct.
+     *
+     * @method mergeFileCoverage
+     * @static
+     * @param {Object} first the first file coverage object for a given file
+     * @param {Object} second the second file coverage object for the same file
+     * @return {Object} an object that is a result of merging the two. Note that
+     *      the input objects are not changed in any way.
+     */
+    function mergeFileCoverage(first, second) {
+        var ret = JSON.parse(JSON.stringify(first)),
+            i;
+
+        delete ret.l; //remove derived info
+
+        Object.keys(second.s).forEach(function (k) {
+            ret.s[k] += second.s[k];
+        });
+        Object.keys(second.f).forEach(function (k) {
+            ret.f[k] += second.f[k];
+        });
+        Object.keys(second.b).forEach(function (k) {
+            var retArray = ret.b[k],
+                secondArray = second.b[k];
+            for (i = 0; i < retArray.length; i += 1) {
+                retArray[i] += secondArray[i];
+            }
+        });
+
+        return ret;
+    }
+    /**
+     * merges multiple summary metrics objects by summing up the `totals` and
+     * `covered` fields and recomputing the percentages. This function is generic
+     * and can accept any number of arguments.
+     *
+     * @method mergeSummaryObjects
+     * @static
+     * @param {Object} summary... multiple summary metrics objects
+     * @return {Object} the merged summary metrics
+     */
+    function mergeSummaryObjects() {
+        var ret = blankSummary(),
+            args = Array.prototype.slice.call(arguments),
+            keys = ['lines', 'statements', 'branches', 'functions'],
+            increment = function (obj) {
+                if (obj) {
+                    keys.forEach(function (key) {
+                        ret[key].total += obj[key].total;
+                        ret[key].covered += obj[key].covered;
+                    });
+                }
+            };
+        args.forEach(function (arg) {
+            increment(arg);
+        });
+        keys.forEach(function (key) {
+            ret[key].pct = percent(ret[key].covered, ret[key].total);
+        });
+
+        return ret;
+    }
+    /**
+     * returns the coverage summary for a single coverage object. This is
+     * wrapper over `summarizeFileCoverage` and `mergeSummaryObjects` for
+     * the common case of a single coverage object
+     * @method summarizeCoverage
+     * @static
+     * @param {Object} coverage  the coverage object
+     * @return {Object} summary coverage metrics across all files in the coverage object
+     */
+    function summarizeCoverage(coverage) {
+        var fileSummary = [];
+        Object.keys(coverage).forEach(function (key) {
+            fileSummary.push(summarizeFileCoverage(coverage[key]));
+        });
+        return mergeSummaryObjects.apply(null, fileSummary);
+    }
+
+    /**
+     * makes the coverage object generated by this library yuitest_coverage compatible.
+     * Note that this transformation is lossy since the returned object will not have
+     * statement and branch coverage.
+     *
+     * @method toYUICoverage
+     * @static
+     * @param {Object} coverage The `istanbul` coverage object
+     * @return {Object} a coverage object in `yuitest_coverage` format.
+     */
+    function toYUICoverage(coverage) {
+        var ret = {};
+
+        addDerivedInfo(coverage);
+
+        Object.keys(coverage).forEach(function (k) {
+            var fileCoverage = coverage[k],
+                lines = fileCoverage.l,
+                functions = fileCoverage.f,
+                fnMap = fileCoverage.fnMap,
+                o;
+
+            o = ret[k] = {
+                lines: {},
+                calledLines: 0,
+                coveredLines: 0,
+                functions: {},
+                calledFunctions: 0,
+                coveredFunctions: 0
+            };
+            Object.keys(lines).forEach(function (k) {
+                o.lines[k] = lines[k];
+                o.coveredLines += 1;
+                if (lines[k] > 0) {
+                    o.calledLines += 1;
+                }
+            });
+            Object.keys(functions).forEach(function (k) {
+                var name = fnMap[k].name + ':' + fnMap[k].line;
+                o.functions[name] = functions[k];
+                o.coveredFunctions += 1;
+                if (functions[k] > 0) {
+                    o.calledFunctions += 1;
+                }
+            });
+        });
+        return ret;
+    }
+
+    var exportables = {
+        addDerivedInfo: addDerivedInfo,
+        addDerivedInfoForFile: addDerivedInfoForFile,
+        removeDerivedInfo: removeDerivedInfo,
+        blankSummary: blankSummary,
+        summarizeFileCoverage: summarizeFileCoverage,
+        summarizeCoverage: summarizeCoverage,
+        mergeFileCoverage: mergeFileCoverage,
+        mergeSummaryObjects: mergeSummaryObjects,
+        toYUICoverage: toYUICoverage
+    };
+
+    if (isNode) {
+        module.exports = exportables;
+    } else {
+        window.coverageUtils = exportables;
+    }
+}(typeof module !== 'undefined' && typeof module.exports !== 'undefined' && typeof exports !== 'undefined'));
+

data/vendor/node_modules/istanbul/lib/register-plugins.js

@@ -0,0 +1,15 @@
+
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+var Store = require('./store'),
+    Report = require('./report'),
+    Command = require('./command');
+
+Store.loadAll();
+Report.loadAll();
+Command.loadAll();
+
+
+

data/vendor/node_modules/istanbul/lib/report/cobertura.js

@@ -0,0 +1,207 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+var path = require('path'),
+    Report = require('./index'),
+    FileWriter = require('../util/file-writer'),
+    TreeSummarizer = require('../util/tree-summarizer'),
+    utils = require('../object-utils');
+
+/**
+ * a `Report` implementation that produces a cobertura-style XML file that conforms to the
+ * http://cobertura.sourceforge.net/xml/coverage-04.dtd DTD.
+ *
+ * Usage
+ * -----
+ *
+ *      var report = require('istanbul').Report.create('cobertura');
+ *
+ * @class CoberturaReport
+ * @extends Report
+ * @constructor
+ * @param {Object} opts optional
+ * @param {String} [opts.dir] the directory in which to the cobertura-coverage.xml will be written
+ */
+function CoberturaReport(opts) {
+    Report.call(this);
+    opts = opts || {};
+    this.projectRoot = process.cwd();
+    this.dir = opts.dir || this.projectRoot;
+    this.file = opts.file || 'cobertura-coverage.xml';
+    this.opts = opts;
+}
+
+CoberturaReport.TYPE = 'cobertura';
+
+function asJavaPackage(node) {
+    return node.displayShortName().
+        replace(/\//g, '.').
+        replace(/\\/g, '.').
+        replace(/\.$/, '');
+}
+
+function asClassName(node) {
+    /*jslint regexp: true */
+    return node.fullPath().replace(/.*[\\\/]/, '');
+}
+
+function quote(thing) {
+    return '"' + thing + '"';
+}
+
+function attr(n, v) {
+    return ' ' + n + '=' + quote(v) + ' ';
+}
+
+function branchCoverageByLine(fileCoverage) {
+    var branchMap = fileCoverage.branchMap,
+        branches = fileCoverage.b,
+        ret = {};
+    Object.keys(branchMap).forEach(function (k) {
+        var line = branchMap[k].line,
+            branchData = branches[k];
+        ret[line] = ret[line] || [];
+        ret[line].push.apply(ret[line], branchData);
+    });
+    Object.keys(ret).forEach(function (k) {
+        var dataArray = ret[k],
+            covered = dataArray.filter(function (item) { return item > 0; }),
+            coverage = covered.length / dataArray.length * 100;
+        ret[k] = { covered: covered.length, total: dataArray.length, coverage: coverage };
+    });
+    return ret;
+}
+
+function addClassStats(node, fileCoverage, writer, projectRoot) {
+    var metrics = node.metrics,
+        branchByLine = branchCoverageByLine(fileCoverage),
+        fnMap,
+        lines;
+
+    writer.println('\t\t<class' +
+        attr('name', asClassName(node)) +
+        attr('filename', node.fullPath().replace(projectRoot + (path.sep || '/'), '')) +
+        attr('line-rate', metrics.lines.pct / 100.0) +
+        attr('branch-rate', metrics.branches.pct / 100.0) +
+        '>');
+
+    writer.println('\t\t<methods>');
+    fnMap = fileCoverage.fnMap;
+    Object.keys(fnMap).forEach(function (k) {
+        var name = fnMap[k].name,
+            hits = fileCoverage.f[k];
+
+        writer.println(
+            '\t\t\t<method' +
+            attr('name', name) +
+            attr('hits', hits) +
+            attr('signature', '()V') + //fake out a no-args void return
+            '>'
+        );
+
+        //Add the function definition line and hits so that jenkins cobertura plugin records method hits
+        writer.println(
+            '\t\t\t\t<lines>' +
+             '<line' +
+            attr('number', fnMap[k].line) +
+            attr('hits', fileCoverage.f[k]) +
+            '/>' +
+            '</lines>'
+        );
+
+        writer.println('\t\t\t</method>');
+
+    });
+    writer.println('\t\t</methods>');
+
+    writer.println('\t\t<lines>');
+    lines = fileCoverage.l;
+    Object.keys(lines).forEach(function (k) {
+        var str = '\t\t\t<line' +
+            attr('number', k) +
+            attr('hits', lines[k]),
+            branchDetail = branchByLine[k];
+
+        if (!branchDetail) {
+            str += attr('branch', false);
+        } else {
+            str += attr('branch', true) +
+                attr('condition-coverage', branchDetail.coverage +
+                    '% (' + branchDetail.covered + '/' + branchDetail.total + ')');
+        }
+        writer.println(str + '/>');
+    });
+    writer.println('\t\t</lines>');
+
+    writer.println('\t\t</class>');
+}
+
+function walk(node, collector, writer, level, projectRoot) {
+    var metrics;
+    if (level === 0) {
+        metrics = node.metrics;
+        writer.println('<?xml version="1.0" ?>');
+        writer.println('<!DOCTYPE coverage SYSTEM "http://cobertura.sourceforge.net/xml/coverage-04.dtd">');
+        writer.println('<coverage' +
+            attr('lines-valid', metrics.lines.total) +
+            attr('lines-covered', metrics.lines.covered) +
+            attr('line-rate', metrics.lines.pct / 100.0) +
+            attr('branches-valid', metrics.branches.total) +
+            attr('branches-covered', metrics.branches.covered) +
+            attr('branch-rate', metrics.branches.pct / 100.0) +
+            attr('timestamp', Date.now()) +
+            'complexity="0" version="0.1">');
+        writer.println('<sources>');
+        writer.println('\t<source>' + projectRoot + '</source>');
+        writer.println('</sources>');
+        writer.println('<packages>');
+    }
+    if (node.packageMetrics) {
+        metrics = node.packageMetrics;
+        writer.println('\t<package' +
+            attr('name', asJavaPackage(node)) +
+            attr('line-rate', metrics.lines.pct / 100.0) +
+            attr('branch-rate', metrics.branches.pct / 100.0) +
+            '>');
+        writer.println('\t<classes>');
+        node.children.filter(function (child) { return child.kind !== 'dir'; }).
+            forEach(function (child) {
+                addClassStats(child, collector.fileCoverageFor(child.fullPath()), writer, projectRoot);
+            });
+        writer.println('\t</classes>');
+        writer.println('\t</package>');
+    }
+    node.children.filter(function (child) { return child.kind === 'dir'; }).
+        forEach(function (child) {
+            walk(child, collector, writer, level + 1, projectRoot);
+        });
+
+    if (level === 0) {
+        writer.println('</packages>');
+        writer.println('</coverage>');
+    }
+}
+
+Report.mix(CoberturaReport, {
+    writeReport: function (collector, sync) {
+        var summarizer = new TreeSummarizer(),
+            outputFile = path.join(this.dir, this.file),
+            writer = this.opts.writer || new FileWriter(sync),
+            projectRoot = this.projectRoot,
+            tree,
+            root;
+
+        collector.files().forEach(function (key) {
+            summarizer.addFileCoverageSummary(key, utils.summarizeFileCoverage(collector.fileCoverageFor(key)));
+        });
+        tree = summarizer.getTreeSummary();
+        root = tree.root;
+        writer.writeFile(outputFile, function (contentWriter) {
+            walk(root, collector, contentWriter, 0, projectRoot);
+        });
+    }
+});
+
+module.exports = CoberturaReport;