traceur-rb 0.0.1 → 0.0.2

data/vendor/node_modules/traceur/node_modules/q-io/http-apps/route.js

@@ -1,125 +0,0 @@
-
-var Q = require("q");
-var StatusApps = require("./status");
-
-/**
- * Makes a  Q-JSGI app that only responds when there is nothing left
- * on the path to route.  If the there is unprocessed data on the
- * path, the returned app either forwards to the `notFound` app or
- * returns a `404 Not Found` response.
- *
- * @param {App} app a Q-JSGI application to
- * respond to this end of the routing chain.
- * @param {App} notFound (optional) defaults
- * to the `notFound` app.
- * @returns {App}
- */
-exports.Cap = function (app, notFound) {
-    notFound = notFound || StatusApps.notFound;
-    return function (request, response) {
-        // TODO Distinguish these cases
-        if (request.pathInfo === "" || request.pathInfo === "/") {
-            return app(request, response);
-        } else {
-            return notFound(request, response);
-        }
-    };
-};
-
-/**
- * Wraps an app with a function that will observe incoming requests
- * before giving the app an opportunity to respond.  If the "tap"
- * function returns a response, it will be used in lieu of forwarding
- * the request to the wrapped app.
- */
-exports.Tap = function (app, tap) {
-    return function (request, response) {
-        var self = this, args = arguments;
-        return Q.when(tap.apply(this, arguments), function (response) {
-            if (response) {
-                return response;
-            } else {
-                return app.apply(self, args);
-            }
-        });
-    };
-};
-
-/**
- * Wraps an app with a "trap" function that intercepts and may
- * alter or replace the response of the wrapped application.
- */
-exports.Trap = function (app, trap) {
-    return function (request, response) {
-        return Q.when(app.apply(this, arguments), function (response) {
-            if (response) {
-                response.headers = response.headers || {};
-                return trap(response, request) || response;
-            }
-        });
-    };
-};
-
-/**
- * Makes a Q-JSGI app that branches requests based on the next
- * unprocessed path component.
- * @param {Object * App} paths a mapping from path components (single
- * file or directory names) to Q-JSGI applications for subsequent
- * routing.  The mapping may be a plain JavaScript `Object` record,
- * which must own the mapping properties, or an object that has
- * `has(key)` and `get(key)` methods in its prototype chain.
- * @param {App} notFound a Q-JSGI application
- * that handles requests for which the next file name does not exist
- * in paths.
- * @returns {App}
- */
-exports.Branch = function (paths, notFound) {
-    if (!paths)
-        paths = {};
-    if (!notFound)
-        notFound = StatusApps.notFound;
-    return function (request, response) {
-        if (!/^\//.test(request.pathInfo)) {
-            return notFound(request, response);
-        }
-        var path = request.pathInfo.slice(1);
-        var parts = path.split("/");
-        var part = decodeURIComponent(parts.shift());
-        if (Object.has(paths, part)) {
-            request.scriptName = request.scriptName + part + "/";
-            request.pathInfo = path.slice(part.length);
-            return Object.get(paths, part)(request, response);
-        }
-        return notFound(request, response);
-    };
-};
-
-/**
- * Returns the response of the first application that returns a
- * non-404 response status.
- *
- * @param {Array * App} apps a cascade of applications to try
- * successively until one of them returns a non-404 status.
- * @returns {App}
- */
-exports.FirstFound = function (cascade) {
-    return function (request, response) {
-        var i = 0, ii = cascade.length;
-        function next() {
-            var response = cascade[i++](request, response);
-            if (i < ii) {
-                return Q.when(response, function (response) {
-                    if (response.status === 404) {
-                        return next();
-                    } else {
-                        return response;
-                    }
-                });
-            } else {
-                return response;
-            }
-        }
-        return next();
-    };
-};
-

data/vendor/node_modules/traceur/node_modules/q-io/http-apps/status.js

@@ -1,175 +0,0 @@
-
-var Negotiation = require("./negotiate");
-var HtmlApps = require("./html");
-
-/**
- * {Object * String} a mapping of HTTP status codes to
- * their standard descriptions.
- */
-// Every standard HTTP code mapped to the appropriate message.
-// Stolen from Rack which stole from Mongrel
-exports.statusCodes = {
-    100: 'Continue',
-    101: 'Switching Protocols',
-    102: 'Processing',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    207: 'Multi-Status',
-    300: 'Multiple Choices',
-    301: 'Moved Permanently',
-    302: 'Found',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    307: 'Temporary Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Request Entity Too Large',
-    414: 'Request-URI Too Large',
-    415: 'Unsupported Media Type',
-    416: 'Request Range Not Satisfiable',
-    417: 'Expectation Failed',
-    422: 'Unprocessable Entity',
-    423: 'Locked',
-    424: 'Failed Dependency',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported',
-    507: 'Insufficient Storage'
-};
-
-/**
- * {Object * Number} a mapping from HTTP status descriptions
- * to HTTP status codes.
- */
-exports.statusMessages = {};
-for (var code in exports.statusCodes)
-    exports.statusMessages[exports.statusCodes[code]] = +code;
-
-/**
- * Determines whether an HTTP response should have a
- * response body, based on its status code.
- * @param {Number} status
- * @returns whether the HTTP response for the given status
- * code has content.
- */
-exports.statusWithNoEntityBody = function (status) {
-    return (status >= 100 && status <= 199) ||
-        status == 204 || status == 304;
-};
-
-/**
- * @param {Number} status
- * @returns {Function(Request) :Response} a JSGI app that returns
- * a plain text response with the given status code.
- */
-exports.appForStatus = function (status) {
-    return function (request) {
-        return exports.responseForStatus(request, status, request.method + " " + request.path);
-    };
-};
-
-/**
- * @param {Number} status an HTTP status code
- * @param {String} message (optional) a message to include
- * in the response body.
- * @returns a JSGI HTTP response object with the given status
- * code and message as its body, if the status supports
- * a body.
- */
-exports.responseForStatus = function(request, status, addendum) {
-    if (exports.statusCodes[status] === undefined)
-        throw "Unknown status code";
-
-    var message = exports.statusCodes[status];
-
-    // RFC 2616, 10.2.5:
-    // The 204 response MUST NOT include a message-body, and thus is always
-    // terminated by the first empty line after the header fields.
-    // RFC 2616, 10.3.5:
-    // The 304 response MUST NOT contain a message-body, and thus is always
-    // terminated by the first empty line after the header fields.
-    if (exports.statusWithNoEntityBody(status)) {
-        return {status: status, headers: {}};
-    } else {
-        var handlers = {};
-        handlers["text/plain"] = exports.textResponseForStatus;
-        if (request.handleHtmlFragmentResponse) {
-            handlers["text/html"] = exports.htmlResponseForStatus;
-        }
-        var responseForStatus = Negotiation.negotiate(request, handlers) || exports.textResponseForStatus;
-        return responseForStatus(request, status, message, addendum);
-    }
-};
-
-exports.textResponseForStatus = function (request, status, message, addendum) {
-    var content = message + "\n";
-    if (addendum) {
-        content += addendum + "\n";
-    }
-    var contentLength = content.length;
-    return {
-        status: status,
-        statusMessage: message,
-        headers: {
-            "content-length": contentLength
-        },
-        body: [content]
-    };
-};
-
-exports.htmlResponseForStatus = function (request, status, message, addendum) {
-    return {
-        status: status,
-        statusMessage: message,
-        headers: {},
-        htmlTitle: message,
-        htmlFragment: {
-            forEach: function (write) {
-                write("<h1>" + HtmlApps.escapeHtml(message) + "</h1>\n");
-                write("<p>Status: " + status + "</p>\n");
-                if (addendum) {
-                    write("<pre>" + HtmlApps.escapeHtml(addendum) + "</pre>\n");
-                }
-            }
-        }
-    }
-};
-
-/**
- * {App} an application that returns a 400 response.
- */
-exports.badRequest = exports.appForStatus(400);
-/**
- * {App} an application that returns a 404 response.
- */
-exports.notFound = exports.appForStatus(404);
-/**
- * {App} an application that returns a 405 response.
- */
-exports.methodNotAllowed = exports.appForStatus(405);
-/**
- * {App} an application that returns a 405 response.
- */
-exports.noLanguage =
-exports.notAcceptable = exports.appForStatus(406);
-

data/vendor/node_modules/traceur/node_modules/q-io/http-cookie.js

@@ -1,75 +0,0 @@
-
-/**
- * Provides utilities for reading and writing HTTP cookies.
- * @module
- */
-
-/*whatsupdoc*/
-
-var QS = require("qs");
-
-/**
- * @param {String} cookie
- * @returns {Object}
- */
-exports.parse = function (cookie, date) {
-    date = date || new Date();
-    var parsed = {};
-    var terms = cookie.split(/[;,]/g);
-    var keyValue = terms.shift().split("=");
-    parsed.key = keyValue[0];
-    parsed.value = keyValue[1];
-    terms.forEach(function (term) {
-        var parts = term.split("=").map(function (part) {
-            return part.trim();
-        });
-        var key = parts[0], value = parts[1];
-        if (/^domain$/i.test(key)) {
-            parsed.domain = value;
-        } else if (/^path$/i.test(key)) {
-            parsed.path = value;
-        } else if (/^expires$/i.test(key)) {
-            parsed.expires = new Date(
-                +new Date() + // actual now
-                (new Date(value) - date) // server offset
-            );
-        } else if (/^max-age$/i.test(key)) {
-            parsed.expires = new Date(
-                new Date().getTime() +
-                (value * 1000)
-            );
-        } else if (/^secure$/i.test(key)) {
-            parsed.secure = true;
-        } else if (/^httponly$/i.test(key)) {
-            parsed.httpOnly = true;
-        }
-    });
-    return parsed;
-};
-
-/**
- * @param {String} key
- * @param {String} value
- * @param {Object} options (optional)
- * @returns {String} a cookie string
- */
-exports.stringify = function (key, value, options) {
-    var cookie = (
-        encodeURIComponent(key) + "=" +
-        encodeURIComponent(value)
-    );
-    if (options) {
-        if (options.domain)
-            cookie += "; Domain=" + encodeURIComponent(options.domain);
-        if (options.path)
-            cookie += "; Path=" + encodeURIComponent(options.path);
-        if (options.expires)
-            cookie += "; Expires=" + options.expires.toGMTString();
-        if (options.secure)
-            cookie += "; Secure";
-        if (options.httpOnly)
-            cookie += "; HttpOnly";
-    }
-    return cookie;
-};
-

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

@@ -1,378 +0,0 @@
-/**
- * A promise-based Q-JSGI server and client API.
- * @module
- */
-
-/*whatsupdoc*/
-
-var HTTP = require("http"); // node
-var HTTPS = require("https"); // node
-var URL = require("url2"); // node
-var Q = require("q");
-var Reader = require("./reader");
-
-/**
- * @param {respond(request Request)} respond a JSGI responder function that
- * receives a Request object as its argument.  The JSGI responder promises to
- * return an object of the form `{status, headers, body}`.  The status and
- * headers must be fully resolved, but the body may be a promise for an object
- * with a `forEach(write(chunk String))` method, albeit an array of strings.
- * The `forEach` method may promise to resolve when all chunks have been
- * written.
- * @returns a Node Server object.
- */
-exports.Server = function (respond) {
-    var self = Object.create(exports.Server.prototype);
-
-    var server = HTTP.createServer(function (_request, _response) {
-        var request = exports.ServerRequest(_request);
-        var response = exports.ServerResponse(_response);
-
-        var closed = Q.defer();
-        _request.on("end", function (error, value) {
-            if (error) {
-                closed.reject(error);
-            } else {
-                closed.resolve(value);
-            }
-        });
-
-        Q.when(request, function (request) {
-            return Q.when(respond(request, response), function (response) {
-                if (!response)
-                    return;
-
-                _response.writeHead(response.status, response.headers);
-
-                if (response.onclose || response.onClose)
-                    Q.when(closed, response.onclose || response.onClose);
-
-                return Q.when(response.body, function (body) {
-                    var length;
-                    if (
-                        Array.isArray(body) &&
-                        (length = body.length) &&
-                        body.every(function (chunk) {
-                            return typeof chunk === "string"
-                        })
-                    ) {
-                        body.forEach(function (chunk, i) {
-                            if (i < length - 1) {
-                                _response.write(chunk, response.charset);
-                            } else {
-                                _response.end(chunk, response.charset);
-                            }
-                        });
-                    } else if (body) {
-                        var end;
-                        var done = body.forEach(function (chunk) {
-                            end = Q.when(end, function () {
-                                return Q.when(chunk, function (chunk) {
-                                    _response.write(chunk, response.charset);
-                                });
-                            });
-                        });
-                        return Q.when(done, function () {
-                            return Q.when(end, function () {
-                                _response.end();
-                            });
-                        });
-                    } else {
-                        _response.end();
-                    }
-                });
-
-            })
-        })
-        .done(); // should be .fail(self.emitter("error"))
-
-    });
-
-    var stopped = Q.defer();
-    server.on("close", function (err) {
-        if (err) {
-            stopped.reject(err);
-        } else {
-            stopped.resolve();
-        }
-    });
-
-    /***
-     * Stops the server.
-     * @returns {Promise * Undefined} a promise that will
-     * resolve when the server is stopped.
-     */
-    self.stop = function () {
-        server.close();
-        listening = undefined;
-        return stopped.promise;
-    };
-
-    var listening = Q.defer();
-    server.on("listening", function (err) {
-        if (err) {
-            listening.reject(err);
-        } else {
-            listening.resolve(self);
-        }
-    });
-
-    /***
-     * Starts the server, listening on the given port
-     * @param {Number} port
-     * @returns {Promise * Undefined} a promise that will
-     * resolve when the server is ready to receive
-     * connections
-     */
-    self.listen = function (/*...args*/) {
-        if (typeof server.port !== "undefined")
-            return Q.reject(new Error("A server cannot be restarted or " +
-            "started on a new port"));
-        server.listen.apply(server, arguments);
-        return listening.promise;
-    };
-
-    self.stopped = stopped.promise;
-
-    self.node = server;
-    self.nodeServer = server; // Deprecated
-    self.address = server.address.bind(server);
-
-    return self;
-};
-
-Object.defineProperties(exports.Server, {
-
-    port: {
-        get: function () {
-            return this.node.port;
-        }
-    },
-
-    host: {
-        get: function () {
-            return this.node.host;
-        }
-    }
-
-});
-
-/**
- * A wrapper for a Node HTTP Request, as received by
- * the Q HTTP Server, suitable for use by the Q HTTP Client.
- */
-exports.ServerRequest = function (_request, ssl) {
-    var request = Object.create(_request);
-    /*** {Array} HTTP version. (JSGI) */
-    request.version = _request.httpVersion.split(".").map(Math.floor);
-    /*** {String} HTTP method, e.g., `"GET"` (JSGI) */
-    request.method = _request.method;
-    /*** {String} path, starting with `"/"` */
-    request.path = _request.url;
-    /*** {String} pathInfo, starting with `"/"`, the
-     * portion of the path that has not yet
-     * been routed (JSGI) */
-    request.pathInfo = URL.parse(_request.url).pathname;
-    /*** {String} scriptName, the portion of the path that
-     * has already been routed (JSGI) */
-    request.scriptName = "";
-    /*** {String} (JSGI) */
-    request.scheme = "http";
-
-    var address = _request.connection.address();
-    /*** {String} hostname */
-    if (_request.headers.host) {
-        request.hostname = _request.headers.host.split(":")[0];
-    } else {
-        request.hostname = address.address;
-    }
-    /*** {String} host */
-    request.host = request.hostname + ":" + address.port;
-    request.port = address.port;
-
-    var socket = _request.socket;
-    /*** {String} */
-    request.remoteHost = socket.remoteAddress;
-    /*** {Number} */
-    request.remotePort = socket.remotePort;
-
-    /*** {String} url */
-    request.url = URL.format({
-        protocol: request.scheme,
-        host: _request.headers.host,
-        port: request.port === (ssl ? 443 : 80) ? null : request.port,
-        path: request.path
-    });
-    /*** A Q IO asynchronous text reader */
-    request.body = Reader(_request);
-    /*** {Object} HTTP headers (JSGI)*/
-    request.headers = _request.headers;
-    /*** The underlying Node request */
-    request.node = _request;
-    request.nodeRequest = _request; // Deprecated
-    /*** The underlying Node TCP connection */
-    request.nodeConnection = _request.connection;
-
-    return Q.when(request.body, function (body) {
-        request.body = body;
-        return request;
-    });
-};
-
-exports.ServerResponse = function (_response, ssl) {
-    var response = Object.create(_response);
-    response.ssl = ssl;
-    response.node = _response;
-    response.nodeResponse = _response; // Deprecated
-    return response;
-};
-
-exports.normalizeRequest = function (request) {
-    if (typeof request === "string") {
-        request = {
-            url: request
-        };
-    }
-    if (request.url) {
-        var url = URL.parse(request.url);
-        request.host = url.hostname;
-        request.port = url.port;
-        request.ssl = url.protocol === "https:";
-        request.method = request.method || "GET";
-        request.path = (url.pathname || "") + (url.search || "");
-        request.headers = request.headers || {};
-        request.headers.host = url.hostname; // FIXME name consistency
-    }
-    return request;
-};
-
-exports.normalizeResponse = function (response) {
-    if (response === void 0) {
-        return;
-    }
-    if (typeof response == "string") {
-        response = [response];
-    }
-    if (response.forEach) {
-        response = {
-            status: 200,
-            headers: {},
-            body: response
-        }
-    }
-    return response;
-};
-
-/**
- * Issues an HTTP request.
- *
- * @param {Request {host, port, method, path, headers,
- * body}} request (may be a promise)
- * @returns {Promise * Response} promise for a response
- */
-exports.request = function (request) {
-    return Q.when(request, function (request) {
-
-        request = exports.normalizeRequest(request);
-
-        var deferred = Q.defer();
-        var ssl = request.ssl;
-        var http = ssl ? HTTPS : HTTP;
-
-        var headers = request.headers || {};
-
-        headers.host = headers.host || request.host;
-
-        var _request = http.request({
-            "host": request.host,
-            "port": request.port || (ssl ? 443 : 80),
-            "path": request.path || "/",
-            "method": request.method || "GET",
-            "headers": headers,
-            "agent": request.agent
-        }, function (_response) {
-            deferred.resolve(exports.ClientResponse(_response, request.charset));
-            _response.on("error", function (error) {
-                // TODO find a better way to channel
-                // this into the response
-                console.warn(error && error.stack || error);
-                deferred.reject(error);
-            });
-        });
-
-        _request.on("error", function (error) {
-            deferred.reject(error);
-        });
-
-        Q.when(request.body, function (body) {
-            var end, done;
-            if (body) {
-                done = body.forEach(function (chunk) {
-                    end = Q.when(end, function () {
-                        return Q.when(chunk, function (chunk) {
-                            _request.write(chunk, request.charset);
-                        });
-                    });
-                });
-            }
-            return Q.when(end, function () {
-                return Q.when(done, function () {
-                    _request.end();
-                });
-            });
-        }).done();
-
-        return deferred.promise;
-    });
-};
-
-/**
- * Issues a GET request to the given URL and returns
- * a promise for a `String` containing the entirety
- * of the response.
- *
- * @param {String} url
- * @returns {Promise * String} or a rejection if the
- * status code is not exactly 200.  The reason for the
- * rejection is the full response object.
- */
-exports.read = function (request, qualifier) {
-    qualifier = qualifier || function (response) {
-        return response.status === 200;
-    };
-    return Q.when(exports.request(request), function (response) {
-        if (!qualifier(response)){
-            var error = new Error("HTTP request failed with code " + response.status);
-            error.response = response;
-            throw error;
-        }
-        return Q.post(response.body, 'read', []);
-    });
-};
-
-
-/**
- * A wrapper for the Node HTTP Response as provided
- * by the Q HTTP Client API, suitable for use by the
- * Q HTTP Server API.
- */
-exports.ClientResponse = function (_response, charset) {
-    var response = Object.create(exports.ClientResponse.prototype);
-    /*** {Number} HTTP status code */
-    response.status = _response.statusCode;
-    /*** HTTP version */
-    response.version = _response.httpVersion;
-    /*** {Object} HTTP headers */
-    response.headers = _response.headers;
-    /***
-     * A Q IO asynchronous text reader.
-     */
-    response.node = _response;
-    response.nodeResponse = _response; // Deprecated
-    response.nodeConnection = _response.connection; // Deprecated
-    return Q.when(Reader(_response, charset), function (body) {
-        response.body = body;
-        return response;
-    });
-};
-