traceur-rb 0.0.1

data/vendor/node_modules/traceur/node_modules/q-io/buffer-stream.js

@@ -0,0 +1,59 @@
+
+var Q = require("q");
+var Reader = require("./reader");
+
+module.exports = BufferStream;
+function BufferStream(chunks, charset) {
+    if (!(this instanceof BufferStream)) {
+        return new BufferStream(chunks, charset);
+    }
+    if (!chunks) {
+        chunks = [];
+    } else if (!Array.isArray(chunks)) {
+        chunks = [chunks];
+    }
+    this._charset = charset;
+    this._chunks = chunks;
+    this._close = Q.defer();
+    this.closed = this._close.promise;
+}
+
+BufferStream.prototype.forEach = function (write, thisp) {
+    var self = this;
+    var chunks = self._chunks;
+    return Q.fcall(function () {
+        chunks.splice(0, chunks.length).forEach(write, thisp);
+    });
+};
+
+BufferStream.prototype.read = function () {
+    var result;
+    result = Reader.join(this._chunks);
+    if (this._charset) {
+        result = result.toString(this._charset);
+    }
+    return Q.resolve(result);
+};
+
+BufferStream.prototype.write = function (chunk) {
+    if (this._charset) {
+        chunk = new Buffer(String(chunk), this._charset);
+    } else {
+        if (!(chunk instanceof Buffer)) {
+            throw new Error("Can't write strings to buffer stream without a charset: " + chunk);
+        }
+    }
+    this._chunks.push(chunk);
+    return Q.resolve();
+};
+
+BufferStream.prototype.close = function () {
+    this._close.resolve();
+    return Q.resolve();
+};
+
+BufferStream.prototype.destroy = function () {
+    this._close.resolve();
+    return Q.resolve();
+};
+

data/vendor/node_modules/traceur/node_modules/q-io/coverage-report.js

@@ -0,0 +1,44 @@
+
+require("collections/shim");
+var Q = require("q");
+var FS = require("./fs");
+
+FS.listTree(".coverage_data", function (name, stat) {
+    return (/^\.coverage_data\/coveragefile/).test(name);
+})
+.then(function (list) {
+    return Q.all(list.map(function (file) {
+        return FS.read(file)
+        .then(function (content) {
+            return JSON.parse(content);
+        })
+        .then(function (coverage) {
+            console.log("<table>");
+            console.log("    <thead>");
+            console.log("        <tr>");
+            console.log("            <th>File</th>");
+            console.log("            <th>Percentage</th>");
+            console.log("            <th>Missing</th>");
+            console.log("        </tr>");
+            console.log("    </thead>");
+            console.log("    <tbody>");
+            Object.forEach(coverage.files, function (file, path) {
+                path = FS.relativeFromDirectory(__dirname, path);
+                if (/^spec/.test(path))
+                    return;
+                console.log("        <tr>");
+                console.log("            <td><code>" + path + "</code></td>");
+                console.log("            <td>" + (file.stats.percentage * 100).toFixed(0) + "%</td>");
+                console.log("            <td>" + file.stats.missing + "</td>");
+                console.log("        </tr>");
+            });
+            console.log("    </tbody>");
+            console.log("</table>");
+        }, function (error) {
+            error.message = "Can't parse " + file + " because " + error.message;
+            throw error;
+        })
+    }))
+})
+.done()
+

data/vendor/node_modules/traceur/node_modules/q-io/deprecate.js

@@ -0,0 +1,51 @@
+/**
+ * @module deprecate
+ */
+
+/**
+ * Prints out a deprecation warning to the console.warn with the format:
+ * `name` is deprecated, use `alternative` instead.
+ * It can also print out a stack trace with the line numbers.
+ * @param {String} name - Name of the thing that is deprecated.
+ * @param {String} alternative - Name of alternative that should be used instead.
+ * @param {Number} [stackTraceLimit] - depth of the stack trace to print out. Set to falsy value to disable stack.
+ */
+exports.deprecationWarning = function deprecationWarning(name, alternative, stackTraceLimit) {
+    if (stackTraceLimit) {
+        var depth = Error.stackTraceLimit;
+        Error.stackTraceLimit = stackTraceLimit;
+    }
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+        var stack = (stackTraceLimit ? new Error("").stack : "") ;
+        if(alternative) {
+            console.warn(name + " is deprecated, use " + alternative + " instead.", stack);
+        } else {
+            //name is a complete message
+            console.warn(name, stack);
+        }
+    }
+    if (stackTraceLimit) {
+        Error.stackTraceLimit = depth;
+    }
+}
+
+/**
+ * Provides a function that can replace a method that has been deprecated.
+ * Prints out a deprecation warning to the console.warn with the format:
+ * `name` is deprecated, use `alternative` instead.
+ * It will also print out a stack trace with the line numbers.
+ * @param {Object} scope - The object that will be used as the `this` when the `deprecatedFunction` is applied.
+ * @param {Function} deprecatedFunction - The function object that is deprecated.
+ * @param {String} name - Name of the method that is deprecated.
+ * @param {String} alternative - Name of alternative method that should be used instead.
+ * @returns {Function} deprecationWrapper
+ */
+exports.deprecateMethod = function deprecate(scope, deprecatedFunction, name, alternative) {
+    var deprecationWrapper = function () {
+        // stackTraceLimit = 3 // deprecationWarning + deprecate + caller of the deprecated method
+        deprecationWarning(name, alternative, 3);
+        return deprecatedFunction.apply(scope ? scope : this, arguments);
+    };
+    deprecationWrapper.deprecatedFunction = deprecatedFunction;
+    return deprecationWrapper;
+}

data/vendor/node_modules/traceur/node_modules/q-io/fs-boot.js

@@ -0,0 +1,307 @@
+(function (exports) {
+
+// -- kriskowal Kris Kowal Copyright (C) 2009-2010 MIT License
+// -- tlrobinson Tom Robinson TODO
+
+/**
+ * Pure JavaScript implementations of file system path
+ * manipulation.
+ */
+
+// NOTE: this file may be used is the engine bootstrapping
+// process, so any "requires" must be accounted for in
+// narwhal.js
+
+/*whatsupdoc*/
+/*markup markdown*/
+
+var regExpEscape = function (str) {
+    return str.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&");
+};
+
+var path = require("path");
+
+/**
+ * @name ROOT
+ * * `/` on Unix
+ * * `\` on Windows
+ */
+
+/**
+ * @name SEPARATOR
+ * * `/` on Unix
+ * * `\` on Windows
+ */
+
+/**
+ * @name ALT_SEPARATOR
+ * * undefined on Unix
+ * * `/` on Windows
+ */
+
+exports.ROOT = exports.SEPARATOR = path.sep || (process.platform === "win32" ? "\\": "/");
+if (path.sep === "\\") {
+    exports.ALT_SEPARATOR = "/";
+} else {
+    exports.ALT_SEPARATOR = undefined;
+}
+
+// we need to make sure the separator regex is always in sync with the separators.
+// this caches the generated regex and rebuild if either separator changes.
+var separatorCached, altSeparatorCached, separatorReCached;
+/**
+ * @function
+ */
+exports.SEPARATORS_RE = function () {
+    if (
+        separatorCached !== exports.SEPARATOR ||
+        altSeparatorCached !== exports.ALT_SEPARATOR
+    ) {
+        separatorCached = exports.SEPARATOR;
+        altSeparatorCached = exports.ALT_SEPARATOR;
+        separatorReCached = new RegExp("[" +
+            (separatorCached || "").replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&") +
+            (altSeparatorCached || "").replace(/[-[\]{}()*+?.\\^$|,#\s]/g, "\\$&") +
+        "]", "g");
+    }
+    return separatorReCached;
+}
+
+/**
+ * separates a path into components.  If the path is
+ * absolute, the first path component is the root of the
+ * file system, indicated by an empty string on Unix, and a
+ * drive letter followed by a colon on Windows.
+ * @returns {Array * String}
+ */
+exports.split = function (path) {
+    var parts;
+    try {
+        parts = String(path).split(exports.SEPARATORS_RE());
+    } catch (exception) {
+        throw new Error("Cannot split " + (typeof path) + ", " + JSON.stringify(path));
+    }
+    // this special case helps isAbsolute
+    // distinguish an empty path from an absolute path
+    // "" -> [] NOT [""]
+    if (parts.length === 1 && parts[0] === "")
+        return [];
+    // "a" -> ["a"]
+    // "/a" -> ["", "a"]
+    return parts;
+};
+
+/**
+ * Takes file system paths as variadic arguments and treats
+ * each as a file or directory path and returns the path
+ * arrived by traversing into the those paths.  All
+ * arguments except for the last must be paths to
+ * directories for the result to be meaningful.
+ * @returns {String} path
+ */
+exports.join = function () {
+    if (arguments.length === 1 && Array.isArray(arguments[0]))
+        return exports.normal.apply(exports, arguments[0]);
+    return exports.normal.apply(exports, arguments);
+};
+
+/**
+ * Takes file system paths as variadic arguments and treats
+ * each path as a location, in the URL sense, resolving each
+ * new location based on the previous.  For example, if the
+ * first argument is the absolute path of a JSON file, and
+ * the second argument is a path mentioned in that JSON
+ * file, `resolve` returns the absolute path of the
+ * mentioned file.
+ * @returns {String} path
+ */
+exports.resolve = function () {
+    var root = "";
+    var parents = [];
+    var children = [];
+    var leaf = "";
+    for (var i = 0; i < arguments.length; i++) {
+        var path = String(arguments[i]);
+        if (path == "")
+            continue;
+        var parts = path.split(exports.SEPARATORS_RE());
+        if (exports.isAbsolute(path)) {
+            root = parts.shift() + exports.SEPARATOR;
+            parents = [];
+            children = [];
+        }
+        leaf = parts.pop();
+        if (leaf == "." || leaf == "..") {
+            parts.push(leaf);
+            leaf = "";
+        }
+        for (var j = 0; j < parts.length; j++) {
+            var part = parts[j];
+            if (part == "." || part == "") {
+            } else if (part == "..") {
+                if (children.length) {
+                    children.pop();
+                } else {
+                    if (root) {
+                    } else {
+                        parents.push("..");
+                    }
+                }
+            } else {
+                children.push(part);
+            }
+        };
+    }
+    path = parents.concat(children).join(exports.SEPARATOR);
+    if (path) leaf = exports.SEPARATOR + leaf;
+    return root + path + leaf;
+};
+
+/**
+ * Takes paths as any number of arguments and reduces them
+ * into a single path in normal form, removing all "." path
+ * components, and reducing ".." path components by removing
+ * the previous path component if possible.
+ * @returns {String} path
+ */
+exports.normal = function () {
+    var root = "";
+    var parents = [];
+    var children = [];
+    for (var i = 0, ii = arguments.length; i < ii; i++) {
+        var path = String(arguments[i]);
+        // empty paths have no affect
+        if (path === "")
+            continue;
+        var parts = path.split(exports.SEPARATORS_RE());
+        if (exports.isAbsolute(path)) {
+            root = parts.shift() + exports.SEPARATOR;
+            parents = [];
+            children = [];
+        }
+        for (var j = 0, jj = parts.length; j < jj; j++) {
+            var part = parts[j];
+            if (part === "." || part === "") {
+            } else if (part == "..") {
+                if (children.length) {
+                    children.pop();
+                } else {
+                    if (root) {
+                    } else {
+                        parents.push("..");
+                    }
+                }
+            } else {
+                children.push(part);
+            }
+        }
+    }
+    path = parents.concat(children).join(exports.SEPARATOR);
+    return root + path;
+};
+
+/***
+ * @returns {Boolean} whether the given path begins at the
+ * root of the file system or a drive letter.
+ */
+exports.isAbsolute = function (path) {
+    // for absolute paths on any operating system,
+    // the first path component always determines
+    // whether it is relative or absolute.  On Unix,
+    // it is empty, so ["", "foo"].join("/") == "/foo",
+    // "/foo".split("/") == ["", "foo"].
+    var parts = exports.split(path);
+    // split("") == [].  "" is not absolute.
+    // split("/") == ["", ""] is absolute.
+    // split(?) == [""] does not occur.
+    if (parts.length == 0)
+        return false;
+    return exports.isRoot(parts[0]);
+};
+
+/**
+ * @returns {Boolean} whether the given path does not begin
+ * at the root of the file system or a drive letter.
+ */
+exports.isRelative = function (path) {
+    return !exports.isAbsolute(path);
+};
+
+/**
+ * @returns {Boolean} whether the given path component
+ * corresponds to the root of the file system or a drive
+ * letter, as applicable.
+ */
+exports.isRoot = function (first) {
+    if (exports.SEPARATOR === "\\") {
+        return /[a-zA-Z]:$/.test(first);
+    } else {
+        return first == "";
+    }
+};
+
+/**
+ * @returns {String} the Unix root path or corresponding
+ * Windows drive for a given path.
+ */
+exports.root = function (path) {
+    if (!exports.isAbsolute(path))
+        path = require("./fs").absolute(path);
+    var parts = exports.split(path);
+    return exports.join(parts[0], "");
+};
+
+/**
+ * @returns {String} the parent directory of the given path.
+ */
+exports.directory = function (path) {
+    path = exports.normal(path);
+    var absolute = exports.isAbsolute(path);
+    var parts = exports.split(path);
+    // XXX needs to be sensitive to the root for
+    // Windows compatibility
+    if (parts.length) {
+        if (parts[parts.length - 1] == "..") {
+            parts.push("..");
+        } else {
+            parts.pop();
+        }
+    } else {
+        parts.unshift("..");
+    }
+    return parts.join(exports.SEPARATOR) || (
+        exports.isRelative(path) ?
+        "" : exports.ROOT
+    );
+};
+
+/**
+ * @returns {String} the last component of a path, without
+ * the given extension if the extension is provided and
+ * matches the given file.
+ * @param {String} path
+ * @param {String} extention an optional extention to detect
+ * and remove if it exists.
+ */
+exports.base = function (path, extension) {
+    var base = path.split(exports.SEPARATORS_RE()).pop();
+    if (extension)
+        base = base.replace(
+            new RegExp(regExpEscape(extension) + "$"),
+            ""
+        );
+    return base;
+};
+
+/**
+ * @returns {String} the extension (e.g., `txt`) of the file
+ * at the given path.
+ */
+exports.extension = function (path) {
+    path = exports.base(path);
+    path = path.replace(/^\.*/, "");
+    var index = path.lastIndexOf(".");
+    return index <= 0 ? "" : path.substring(index);
+};
+
+})(typeof exports !== "undefined" ? exports : FS_BOOT = {});