traceur-rb 0.0.1

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

@@ -0,0 +1,65 @@
+
+var Q = require("q");
+var HTTP = require("./http");
+var URL = require("url");
+
+exports.Client = Client;
+function Client(fs) {
+    var self = Object.create(Client.prototype);
+
+    self.request = function (request) {
+        return Q.when(request, function (request) {
+            request = HTTP.normalizeRequest(request);
+            var url = URL.parse(request.url);
+            if (url.protocol !== "file:") {
+                return {
+                    status: 404,
+                    headers: {},
+                    body: ["Can't access protocol " + url.protocol]
+                };
+            } else {
+                var path = url.pathname;
+                return fs.open(path, {
+                    charset: request.charset
+                }).then(function (body) {
+                    return {
+                        status: 200,
+                        headers: {},
+                        body: body
+                    };
+                });
+            }
+        });
+    };
+
+    self.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.invoke(response.body, "read");
+        });
+    };
+
+    return self;
+}
+
+exports.request = function (request) {
+    return Q.fcall(require.async || require, "./fs")
+    .then(function (fs) {
+        return Client(fs).request(request);
+    });
+};
+
+exports.read = function (request, qualifier) {
+    return Q.fcall(require.async || require, "./fs")
+    .then(function (fs) {
+        return Client(fs).read(request);
+    });
+};
+

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

@@ -0,0 +1,152 @@
+
+/**
+ * Provides tools for making, routing, adapting, and decorating
+ * Q-JSGI web applications.
+ *
+ * Duck Types
+ * ----------
+ *
+ * A Q-JSGI _app_ is a function that accepts a request and returns a
+ * response.  The response may be promised.
+ *
+ * A Q-JSGI _request_ is an object or a promise for an object that has
+ * the following properties:
+ *
+ * * `method` is the HTTP request method as a string.
+ * * `path` is a string, guaranteed to start with `"/"`.
+ * * `headers` is an object mapping lower-case HTTP headers to
+ *   their corresponding values as strings.
+ * * `body` is a Q-JSGI content body.
+ *
+ * A Q-JSGI _response_ is an object or a promise for an object that
+ * has the following properties:
+ *
+ * * `status` is the HTTP response status code as a number.
+ * * `headers` is an object mapping lower-case HTTP headers to their
+ *   corresponding values as strings.
+ * * `body` is a Q-JSGI content body.
+ *
+ * A Q-JSGI response and request content _body_ can be as simple as an
+ * array of strings.  It can be a promise.  In general, it must be an
+ * object that has a `forEach` method.  The `forEach` method accepts a
+ * `write` function.  It goes without saying that `forEach` returns
+ * `undefined`, but it can return a promise for `undefined` that will
+ * resolve when it has made all of its `write` calls and the request
+ * or response can be closed, re-used, or kept alive..  The `forEach`
+ * function may call `write` with a `String` any number of times.  The
+ * `String` may be promised.
+ *
+ * @module
+ */
+
+require("collections/shim");
+var Q = require("q");
+var HTTP = require("./http");
+var FS = require("./fs");
+var URL = require("url2");
+var inspect = require("util").inspect;
+
+exports.Chain = require("./http-apps/chain");
+
+var RouteApps = require("./http-apps/route");
+exports.Cap = RouteApps.Cap;
+exports.Tap = RouteApps.Tap;
+exports.Trap = RouteApps.Trap;
+exports.Branch = RouteApps.Branch;
+
+var ContentApps = require("./http-apps/content");
+exports.Content = ContentApps.Content;
+exports.content = ContentApps.content;
+exports.ok = ContentApps.ok;
+exports.ContentRequest = ContentApps.ContentRequest;
+exports.Inspect = ContentApps.Inspect;
+exports.ParseQuery = ContentApps.ParseQuery;
+
+var FsApps = require("./http-apps/fs");
+exports.File = FsApps.File;
+exports.FileTree = FsApps.FileTree;
+exports.file = FsApps.file;
+exports.directory = FsApps.directory;
+exports.etag = FsApps.etag;
+
+exports.ListDirectories = FsApps.ListDirectories;
+exports.listDirectory = FsApps.listDirectory;
+exports.listDirectoryHtmlFragment = FsApps.listDirectoryHtmlFragment;
+exports.listDirectoryText = FsApps.listDirectoryText;
+exports.listDirectoryMarkdown = FsApps.listDirectoryMarkdown;
+exports.listDirectoryJson = FsApps.listDirectoryJson;
+exports.listDirectoryData = FsApps.listDirectoryData;
+exports.DirectoryIndex = FsApps.DirectoryIndex;
+
+var HtmlApps = require("./http-apps/html");
+exports.HandleHtmlFragmentResponses = HtmlApps.HandleHtmlFragmentResponses;
+exports.handleHtmlFragmentResponse = HtmlApps.handleHtmlFragmentResponse;
+exports.escapeHtml = HtmlApps.escapeHtml;
+
+var JsonApps = require("./http-apps/json");
+exports.HandleJsonResponses = JsonApps.HandleJsonResponses;
+exports.handleJsonResponse = JsonApps.handleJsonResponse;
+exports.Json = JsonApps.Json;
+exports.json = JsonApps.json;
+exports.JsonRequest = JsonApps.JsonRequest;
+
+var RedirectApps = require("./http-apps/redirect");
+exports.PermanentRedirect = RedirectApps.PermanentRedirect;
+exports.PermanentRedirectTree = RedirectApps.PermanentRedirectTree;
+exports.TemporaryRedirect = RedirectApps.TemporaryRedirect;
+exports.TemporaryRedirectTree = RedirectApps.TemporaryRedirectTree;
+exports.Redirect = RedirectApps.Redirect;
+exports.RedirectTree = RedirectApps.RedirectTree;
+exports.permanentRedirect = RedirectApps.permanentRedirect;
+exports.permanentRedirectTree = RedirectApps.permanentRedirectTree;
+exports.temporaryRedirect = RedirectApps.temporaryRedirect;
+exports.temporaryRedirectTree = RedirectApps.temporaryRedirectTree;
+exports.redirectTree = RedirectApps.redirectTree;
+exports.redirect = RedirectApps.redirect;
+exports.redirectText = RedirectApps.redirectText;
+exports.redirectHtml = RedirectApps.redirectHtml;
+exports.RedirectTrap = RedirectApps.RedirectTrap;
+exports.isRedirect = RedirectApps.isRedirect;
+
+var ProxyApps = require("./http-apps/proxy");
+exports.Proxy = ProxyApps.Proxy;
+exports.ProxyTree = ProxyApps.ProxyTree;
+
+var NegotiationApps = require("./http-apps/negotiate");
+exports.negotiate = NegotiationApps.negotiate;
+exports.Method = NegotiationApps.Method;
+exports.ContentType = NegotiationApps.ContentType;
+exports.Language = NegotiationApps.Language;
+exports.Charset = NegotiationApps.Charset;
+exports.Encoding = NegotiationApps.Encoding;
+exports.Host = NegotiationApps.Host;
+exports.Select = NegotiationApps.Select;
+
+var StatusApps = require("./http-apps/status");
+exports.statusCodes = StatusApps.statusCodes;
+exports.statusMessages = StatusApps.statusMessages;
+exports.statusWithNoEntityBody = StatusApps.statusWithNoEntityBody;
+exports.appForStatus = StatusApps.appForStatus;
+exports.responseForStatus = StatusApps.responseForStatus;
+exports.textResponseForStatus = StatusApps.textResponseForStatus;
+exports.htmlResponseForStatus = StatusApps.htmlResponseForStatus;
+exports.badRequest = StatusApps.badRequest;
+exports.notFound = StatusApps.notFound;
+exports.methodNotAllowed = StatusApps.methodNotAllowed;
+exports.noLanguage = StatusApps.noLanguage;
+exports.notAcceptable = StatusApps.notAcceptable;
+
+var DecoratorApps = require("./http-apps/decorators");
+exports.Normalize = DecoratorApps.Normalize;
+exports.Date = DecoratorApps.Date;
+exports.Error = DecoratorApps.Error;
+exports.Debug = DecoratorApps.Debug;
+exports.Log = DecoratorApps.Log;
+exports.Time = DecoratorApps.Time;
+exports.Headers = DecoratorApps.Headers;
+exports.Permanent = DecoratorApps.Permanent;
+exports.Decorators = DecoratorApps.Decorators;
+
+var CookieApps = require("./http-apps/cookie");
+exports.CookieJar = CookieApps.CookieJar;
+

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

@@ -0,0 +1,24 @@
+
+module.exports = Chain;
+function Chain(end) {
+    var self = Object.create(Chain.prototype);
+    self.end = end || function (next) {
+        return next;
+    };
+    return self;
+};
+
+Chain.prototype.use = function (App /*, ...args*/) {
+    if (!App) throw new Error("App is not defined after " + this.app);
+    var args = Array.prototype.slice.call(arguments, 1);
+    var self = this;
+    this.end = (function (End) {
+        return function Self(next) {
+            if (self.end !== Self && !next) throw new Error("App chain is broken after " + App);
+            return End(App.apply(null, [next].concat(args)));
+        };
+    })(this.end);
+    this.app = App;
+    return this;
+};
+

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

@@ -0,0 +1,93 @@
+var Q = require("q");
+var Negotiate = require("./negotiate");
+var QS = require("qs");
+var URL = require("url2");
+
+/**
+ * Makes an app that returns a response with static content
+ * from memory.
+ * @param {Body} body a Q-JSGI
+ * response body
+ * @param {String} contentType
+ * @param {Number} status
+ * @returns {App} a Q-JSGI app
+ */
+exports.Content = function (body, contentType, status) {
+    return function (request, response) {
+        return {
+            "status": status || 200,
+            "headers": {
+                "content-type": contentType || "text/plain"
+            },
+            "body": body || ""
+        };
+    };
+};
+
+/**
+ * Returns a Q-JSGI response with the given content.
+ * @param {Body} content (optional) defaults to `[""]`
+ * @param {String} contentType (optional) defaults to `"text/plain"`
+ * @param {Number} status (optional) defaults to `200`
+ * @returns {Response}
+ */
+exports.content =
+exports.ok = function (content, contentType, status) {
+    status = status || 200;
+    content = content || "";
+    if (typeof content === "string") {
+        content = [content];
+    }
+    contentType = contentType || "text/plain";
+    return {
+        "status": status,
+        "headers": {
+            "content-type": contentType
+        },
+        "body": content
+    };
+};
+
+/**
+ * Wraps an app such that it expects to receive content
+ * in the request body and passes that content as a string
+ * to as the second argument to the wrapped JSGI app.
+ *
+ * @param {Function(Request, Object):Response} app
+ * @returns {App}
+ */
+exports.ContentRequest = function (app) {
+    return function (request, response) {
+        return Q.when(request.body.read(), function (body) {
+            return app(body, request, response);
+        });
+    };
+};
+
+/**
+ * @param {Function(Request):Object}
+ * @returns {App}
+ */
+exports.Inspect = function (app) {
+    return Negotiate.Method({"GET": function (request, response) {
+        return Q.when(app(request, response), function (object) {
+            return {
+                status: 200,
+                headers: {
+                    "content-type": "text/plain"
+                },
+                body: [inspect(object)]
+            }
+        });
+    }});
+};
+
+/**
+ */
+exports.ParseQuery = function (app) {
+    return function (request, response) {
+        request.query = QS.parse(URL.parse(request.url).query || "");
+        return app(request, response);
+    };
+};
+

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

@@ -0,0 +1,154 @@
+
+var Q = require("q");
+var Cookie = require("../http-cookie");
+
+exports.CookieJar = function (app) {
+    var hostCookies = {}; // to {} of pathCookies to [] of cookies
+    return function (request) {
+
+        var hosts = allHostsContaining(request.headers.host);
+
+        var now = new Date();
+
+        var requestCookies = concat(hosts.map(function (host) {
+
+            // delete expired cookies
+            for (var host in hostCookies) {
+                var pathCookies = hostCookies[host];
+                for (var path in pathCookies) {
+                    var cookies = pathCookies[path];
+                    for (var name in cookies) {
+                        var cookie = cookies[name];
+                        if (cookie.expires && cookie.expires > now) {
+                            delete cookie[name];
+                        }
+                    }
+                }
+            }
+
+            // collect applicable cookies
+            return concat(
+                Object.keys(hostCookies)
+                .map(function (host) {
+                    if (!hostContains(host, request.headers.host))
+                        return [];
+                    var pathCookies = hostCookies[host];
+                    return concat(
+                        Object.keys(pathCookies)
+                        .map(function (path) {
+                            if (!pathContains(path, request.path))
+                                return [];
+                            var cookies = pathCookies[path];
+                            return (
+                                Object.keys(cookies)
+                                .map(function (name) {
+                                    return cookies[name];
+                                })
+                                .filter(function (cookie) {
+                                    return cookie.secure ?
+                                        request.ssl :
+                                        true;
+                                })
+                            );
+                        })
+                    )
+                })
+            );
+
+        }));
+
+        if (requestCookies.length) {
+            request.headers["cookie"] = (
+                requestCookies
+                .map(function (cookie) {
+                    return Cookie.stringify(
+                        cookie.key,
+                        cookie.value,
+                        cookie
+                    );
+                })
+                .join("; ")
+            );
+        }
+
+        return Q.when(app.apply(this, arguments), function (response) {
+            response.headers = response.headers || {};
+            if (response.headers["set-cookie"]) {
+                var requestHost = ipRe.test(request.headers.host) ?
+                    request.headers.host :
+                    "." + request.headers.host;
+                // normalize to array
+                if (!Array.isArray(response.headers["set-cookie"])) {
+                    response.headers["set-cookie"] = [response.headers["set-cookie"]];
+                }
+                response.headers["set-cookie"].forEach(function (cookie) {
+                    var date = response.headers["date"] ?
+                        new Date(response.headers["date"]) :
+                        new Date();
+                    cookie = Cookie.parse(cookie, date);
+                    // ignore illegal host
+                    if (cookie.host && !hostContains(requestHost, cookie.host))
+                        delete cookie.host;
+                    var host = requestHost || cookie.host;
+                    var path = cookie.path || "/";
+                    var pathCookies = hostCookies[host] = hostCookies[host] || {};
+                    var cookies = pathCookies[path] = pathCookies[path] || {};
+                    cookies[cookie.key] = cookie;
+                })
+                delete response.headers["set-cookie"];
+            }
+
+            return response;
+        });
+
+    };
+};
+
+var ipRe = /^\d+\.\d+\.\d+\.\d+$/;
+
+function allHostsContaining(content) {
+    if (ipRe.test(content)) {
+        return [content];
+    } if (content === "localhost") {
+        return [content];
+    } else {
+        var parts = content.split(".");
+        var hosts = [];
+        while (parts.length > 1) {
+            hosts.push("." + parts.join("."));
+            parts.shift();
+        }
+        return hosts;
+    }
+}
+
+function hostContains(container, content) {
+    if (ipRe.test(container) || ipRe.test(content)) {
+        return container === content;
+    } else if (/^\./.test(container)) {
+        return (
+            content.lastIndexOf(container) ===
+            content.length - container.length
+        ) || (
+            container.slice(1) === content
+        );
+    } else {
+        return container === content;
+    }
+};
+
+function pathContains(container, content) {
+    if (/^\/$/.test(container)) {
+        return content.indexOf(container) === 0;
+    } else {
+        return (
+            content === container ||
+            content.indexOf(container + "/") === 0
+        );
+    }
+}
+
+function concat(arrays) {
+    return [].concat.apply([], arrays);
+}
+