cssesc-source 0.1.0

data/vendor/node_modules/istanbul/lib/util/file-writer.js

@@ -0,0 +1,131 @@
+/*
+ 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'),
+    util = require('util'),
+    fs = require('fs'),
+    async = require('async'),
+    mkdirp = require('mkdirp'),
+    writer = require('./writer'),
+    Writer = writer.Writer,
+    ContentWriter = writer.ContentWriter;
+
+function extend(cons, proto) {
+    Object.keys(proto).forEach(function (k) {
+        cons.prototype[k] = proto[k];
+    });
+}
+
+function BufferedContentWriter() {
+    ContentWriter.call(this);
+    this.content = '';
+}
+util.inherits(BufferedContentWriter, ContentWriter);
+
+extend(BufferedContentWriter, {
+    write: function (str) {
+        this.content += str;
+    },
+    getContent: function () {
+        return this.content;
+    }
+});
+
+function StreamContentWriter(stream) {
+    ContentWriter.call(this);
+    this.stream = stream;
+}
+util.inherits(StreamContentWriter, ContentWriter);
+
+extend(StreamContentWriter, {
+    write: function (str) {
+        this.stream.write(str);
+    }
+});
+
+function SyncFileWriter() {
+    Writer.call(this);
+}
+util.inherits(SyncFileWriter, Writer);
+
+extend(SyncFileWriter, {
+    writeFile: function (file, callback) {
+        mkdirp.sync(path.dirname(file));
+        var cw = new BufferedContentWriter();
+        callback(cw);
+        fs.writeFileSync(file, cw.getContent(), 'utf8');
+    },
+    done: function () {
+        this.emit('done'); //everything already done
+    }
+});
+
+function AsyncFileWriter() {
+    this.queue = async.queue(this.processFile.bind(this), 20);
+    this.openFileMap = {};
+}
+
+util.inherits(AsyncFileWriter, Writer);
+
+extend(AsyncFileWriter, {
+    writeFile: function (file, callback) {
+        this.openFileMap[file] = true;
+        this.queue.push({ file: file, callback: callback });
+    },
+    processFile: function (task, cb) {
+        var file = task.file,
+            userCallback = task.callback,
+            that = this,
+            stream,
+            contentWriter;
+
+        mkdirp.sync(path.dirname(file));
+        stream = fs.createWriteStream(file);
+        stream.on('close', function () {
+            delete that.openFileMap[file];
+            cb();
+            that.checkDone();
+        });
+        stream.on('error', function (err) { that.emit('error', err); });
+        contentWriter = new StreamContentWriter(stream);
+        userCallback(contentWriter);
+        stream.end();
+    },
+    done: function () {
+        this.doneCalled = true;
+        this.checkDone();
+    },
+    checkDone: function () {
+        if (!this.doneCalled) { return; }
+        if (Object.keys(this.openFileMap).length === 0) {
+            this.emit('done');
+        }
+    }
+});
+
+function FileWriter(sync) {
+    Writer.call(this);
+    var that = this;
+    this.delegate = sync ? new SyncFileWriter() : new AsyncFileWriter();
+    this.delegate.on('error', function (err) { that.emit('error', err); });
+    this.delegate.on('done', function () { that.emit('done'); });
+}
+
+util.inherits(FileWriter, Writer);
+
+extend(FileWriter, {
+    copyFile: function (source, dest) {
+        mkdirp.sync(path.dirname(dest));
+        fs.writeFileSync(dest, fs.readFileSync(source));
+    },
+    writeFile: function (file, callback) {
+        this.delegate.writeFile(file, callback);
+    },
+    done: function () {
+        this.delegate.done();
+    }
+});
+
+module.exports = FileWriter;

data/vendor/node_modules/istanbul/lib/util/flow-control.js

@@ -0,0 +1,26 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+
+/**
+ * Wrap a function and make sure it's called only once.
+ *
+ * @param {Function} func Function to wrap.
+ * @return {Function} Wrapped function.
+ */
+function callOnce(func) {
+    var called = false;
+
+    return function wrapped() {
+        if (!called) {
+            called = true;
+            func.apply(null, arguments);
+        }
+    };
+}
+
+module.exports = {
+    'callOnce': callOnce
+};

data/vendor/node_modules/istanbul/lib/util/help-formatter.js

@@ -0,0 +1,24 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+var OPT_PREFIX = "      ",
+    OPT_START = OPT_PREFIX.length,
+    TEXT_START = 14,
+    STOP = 80,
+    wrap = require('wordwrap')(TEXT_START, STOP);
+
+function formatOption(option, helpText) {
+    var formattedText = wrap(helpText);
+
+    if (option.length > TEXT_START - OPT_START - 2) {
+        return OPT_PREFIX + option + '\n' + formattedText;
+    } else {
+        return OPT_PREFIX + option + formattedText.substring((OPT_PREFIX + option).length);
+    }
+}
+
+module.exports = {
+    formatOption: formatOption
+};

data/vendor/node_modules/istanbul/lib/util/input-error.js

@@ -0,0 +1,12 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+module.exports.create = function (message) {
+    var err = new Error(message);
+    err.inputError = true;
+    return err;
+};
+
+

data/vendor/node_modules/istanbul/lib/util/insertion-text.js

@@ -0,0 +1,109 @@
+/*
+ Copyright (c) 2012, Yahoo! Inc.  All rights reserved.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+function InsertionText(text, consumeBlanks) {
+    this.text = text;
+    this.origLength = text.length;
+    this.offsets = [];
+    this.consumeBlanks = consumeBlanks;
+    this.startPos = this.findFirstNonBlank();
+    this.endPos = this.findLastNonBlank();
+}
+
+var WHITE_RE = /[ \f\n\r\t\v\u00A0\u2028\u2029]/;
+
+InsertionText.prototype = {
+
+    findFirstNonBlank: function () {
+        var pos = -1,
+            text = this.text,
+            len = text.length,
+            i;
+        for (i = 0; i < len; i += 1) {
+            if (!text.charAt(i).match(WHITE_RE)) {
+                pos = i;
+                break;
+            }
+        }
+        return pos;
+    },
+    findLastNonBlank: function () {
+        var text = this.text,
+            len = text.length,
+            pos = text.length + 1,
+            i;
+        for (i = len - 1; i >= 0; i -= 1) {
+            if (!text.charAt(i).match(WHITE_RE)) {
+                pos = i;
+                break;
+            }
+        }
+        return pos;
+    },
+    originalLength: function () {
+        return this.origLength;
+    },
+
+    insertAt: function (col, str, insertBefore, consumeBlanks) {
+        consumeBlanks = typeof consumeBlanks === 'undefined' ? this.consumeBlanks : consumeBlanks;
+        col = col > this.originalLength() ? this.originalLength() : col;
+        col = col < 0 ? 0 : col;
+
+        if (consumeBlanks) {
+            if (col <= this.startPos) {
+                col = 0;
+            }
+            if (col > this.endPos) {
+                col = this.origLength;
+            }
+        }
+
+        var len = str.length,
+            offset = this.findOffset(col, len, insertBefore),
+            realPos = col + offset,
+            text = this.text;
+        this.text = text.substring(0, realPos) + str + text.substring(realPos);
+        return this;
+    },
+
+    findOffset: function (pos, len, insertBefore) {
+        var offsets = this.offsets,
+            offsetObj,
+            cumulativeOffset = 0,
+            i;
+
+        for (i = 0; i < offsets.length; i += 1) {
+            offsetObj = offsets[i];
+            if (offsetObj.pos < pos || (offsetObj.pos === pos && !insertBefore)) {
+                cumulativeOffset += offsetObj.len;
+            }
+            if (offsetObj.pos >= pos) {
+                break;
+            }
+        }
+        if (offsetObj && offsetObj.pos === pos) {
+            offsetObj.len += len;
+        } else {
+            offsets.splice(i, 0, { pos: pos, len: len });
+        }
+        return cumulativeOffset;
+    },
+
+    wrap: function (startPos, startText, endPos, endText, consumeBlanks) {
+        this.insertAt(startPos, startText, true, consumeBlanks);
+        this.insertAt(endPos, endText, false, consumeBlanks);
+        return this;
+    },
+
+    wrapLine: function (startText, endText) {
+        this.wrap(0, startText, this.originalLength(), endText);
+    },
+
+    toString: function () {
+        return this.text;
+    }
+};
+
+module.exports = InsertionText;

data/vendor/node_modules/istanbul/lib/util/meta.js

@@ -0,0 +1,13 @@
+/*
+ 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'),
+    fs = require('fs'),
+    pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', '..', 'package.json'), 'utf8'));
+
+module.exports = {
+    NAME: pkg.name,
+    VERSION: pkg.version
+};
+

data/vendor/node_modules/istanbul/lib/util/tree-summarizer.js

@@ -0,0 +1,213 @@
+/*
+ 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'),
+    SEP = path.sep || '/',
+    utils = require('../object-utils');
+
+function commonArrayPrefix(first, second) {
+    var len = first.length < second.length ? first.length : second.length,
+        i,
+        ret = [];
+    for (i = 0; i < len; i += 1) {
+        if (first[i] === second[i]) {
+            ret.push(first[i]);
+        } else {
+            break;
+        }
+    }
+    return ret;
+}
+
+function findCommonArrayPrefix(args) {
+    if (args.length === 0) {
+        return [];
+    }
+
+    var separated = args.map(function (arg) { return arg.split(SEP); }),
+        ret = separated.pop();
+
+    if (separated.length === 0) {
+        return ret.slice(0, ret.length - 1);
+    } else {
+        return separated.reduce(commonArrayPrefix, ret);
+    }
+}
+
+function Node(fullName, kind, metrics) {
+    this.name = fullName;
+    this.fullName = fullName;
+    this.kind = kind;
+    this.metrics = metrics || null;
+    this.parent = null;
+    this.children = [];
+}
+
+Node.prototype = {
+    displayShortName: function () {
+        return this.relativeName;
+    },
+    fullPath: function () {
+        return this.fullName;
+    },
+    addChild: function (child) {
+        this.children.push(child);
+        child.parent = this;
+    },
+    toJSON: function () {
+        return {
+            name: this.name,
+            relativeName: this.relativeName,
+            fullName: this.fullName,
+            kind: this.kind,
+            metrics: this.metrics,
+            parent: this.parent === null ? null : this.parent.name,
+            children: this.children.map(function (node) { return node.toJSON(); })
+        };
+    }
+};
+
+function TreeSummary(summaryMap, commonPrefix) {
+    this.prefix = commonPrefix;
+    this.convertToTree(summaryMap, commonPrefix);
+}
+
+TreeSummary.prototype = {
+    getNode: function (shortName) {
+        return this.map[shortName];
+    },
+    convertToTree: function (summaryMap, arrayPrefix) {
+        var nodes = [],
+            rootPath = arrayPrefix.join(SEP) + SEP,
+            root = new Node(rootPath, 'dir'),
+            tmp,
+            tmpChildren,
+            seen = {},
+            filesUnderRoot = false;
+
+        seen[rootPath] = root;
+        Object.keys(summaryMap).forEach(function (key) {
+            var metrics = summaryMap[key],
+                node,
+                parentPath,
+                parent;
+            node = new Node(key, 'file', metrics);
+            seen[key] = node;
+            nodes.push(node);
+            parentPath = path.dirname(key) + SEP;
+            if (parentPath === SEP + SEP) {
+                parentPath = SEP + '__root__' + SEP;
+            }
+            parent = seen[parentPath];
+            if (!parent) {
+                parent = new Node(parentPath, 'dir');
+                root.addChild(parent);
+                seen[parentPath] = parent;
+            }
+            parent.addChild(node);
+            if (parent === root) { filesUnderRoot = true; }
+        });
+
+        if (filesUnderRoot && arrayPrefix.length > 0) {
+            arrayPrefix.pop(); //start at one level above
+            tmp = root;
+            tmpChildren = tmp.children;
+            tmp.children = [];
+            root = new Node(arrayPrefix.join(SEP) + SEP, 'dir');
+            root.addChild(tmp);
+            tmpChildren.forEach(function (child) {
+                if (child.kind === 'dir') {
+                    root.addChild(child);
+                } else {
+                    tmp.addChild(child);
+                }
+            });
+        }
+        this.fixupNodes(root, arrayPrefix.join(SEP) + SEP);
+        this.calculateMetrics(root);
+        this.root = root;
+        this.map = {};
+        this.indexAndSortTree(root, this.map);
+    },
+
+    fixupNodes: function (node, prefix, parent) {
+        var that = this;
+        if (node.name.indexOf(prefix) === 0) {
+            node.name = node.name.substring(prefix.length);
+        }
+        if (node.name.charAt(0) === SEP) {
+            node.name = node.name.substring(1);
+        }
+        if (parent) {
+            if (parent.name !== '__root__/') {
+                node.relativeName = node.name.substring(parent.name.length);
+            } else {
+                node.relativeName = node.name;
+            }
+        } else {
+            node.relativeName = node.name.substring(prefix.length);
+        }
+        node.children.forEach(function (child) {
+            that.fixupNodes(child, prefix, node);
+        });
+    },
+    calculateMetrics: function (entry) {
+        var that = this,
+            fileChildren;
+        if (entry.kind !== 'dir') {return; }
+        entry.children.forEach(function (child) {
+            that.calculateMetrics(child);
+        });
+        entry.metrics = utils.mergeSummaryObjects.apply(
+            null,
+            entry.children.map(function (child) { return child.metrics; })
+        );
+        // calclulate "java-style" package metrics where there is no hierarchy
+        // across packages
+        fileChildren = entry.children.filter(function (n) { return n.kind !== 'dir'; });
+        if (fileChildren.length > 0) {
+            entry.packageMetrics = utils.mergeSummaryObjects.apply(
+                null,
+                fileChildren.map(function (child) { return child.metrics; })
+            );
+        } else {
+            entry.packageMetrics = null;
+        }
+    },
+    indexAndSortTree: function (node, map) {
+        var that = this;
+        map[node.name] = node;
+        node.children.sort(function (a, b) {
+            a = a.relativeName;
+            b = b.relativeName;
+            return a < b ? -1 : a > b ? 1 : 0;
+        });
+        node.children.forEach(function (child) {
+            that.indexAndSortTree(child, map);
+        });
+    },
+    toJSON: function () {
+        return {
+            prefix: this.prefix,
+            root: this.root.toJSON()
+        };
+    }
+};
+
+function TreeSummarizer() {
+    this.summaryMap = {};
+}
+
+TreeSummarizer.prototype = {
+    addFileCoverageSummary: function (filePath, metrics) {
+        this.summaryMap[filePath] = metrics;
+    },
+    getTreeSummary: function () {
+        var commonArrayPrefix = findCommonArrayPrefix(Object.keys(this.summaryMap));
+        return new TreeSummary(this.summaryMap, commonArrayPrefix);
+    }
+};
+
+module.exports = TreeSummarizer;