traceur-rb 0.0.1

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

@@ -0,0 +1,125 @@
+
+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

@@ -0,0 +1,175 @@
+
+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

@@ -0,0 +1,75 @@
+
+/**
+ * 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

@@ -0,0 +1,378 @@
+/**
+ * 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;
+    });
+};
+