RubyGems - traceur-rb - Versions diffs - 0.0.1 - Mend

traceur-rb 0.0.1

Files changed (255) hide show

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

@@ -0,0 +1,58 @@
+var Q = require("q");
+// TODO negotiate text/html vs text/html+fragment (or other mime type)
+/**
+ * @param {Request} request
+ * @param {String} path
+ * @param {String} contentType
+ * @returns {Response}
+ */
+exports.HandleHtmlFragmentResponses = function (app, handleHtmlFragmentResponse) {
+    handleHtmlFragmentResponse = handleHtmlFragmentResponse || exports.handleHtmlFragmentResponse;
+    return function (request) {
+        request.handleHtmlFragmentResponse = handleHtmlFragmentResponse;
+        return Q.fcall(app, request)
+        .then(function (response) {
+            if (response.htmlFragment) {
+                return Q.fcall(handleHtmlFragmentResponse, response);
+            } else {
+                return response;
+            }
+        });
+    };
+};
+exports.handleHtmlFragmentResponse = function (response) {
+    var htmlFragment = response.htmlFragment;
+    delete response.htmlFragment;
+    response.headers["content-type"] = "text/html; charset=utf-8";
+    response.body = {
+        forEach: function (write) {
+            write("<!doctype html>\n");
+            write("<html>\n");
+            write("    <head>\n");
+            if (response.htmlTitle !== void 0) {
+                write("        <title>" + escapeHtml(response.htmlTitle) + "</title>\n");
+            }
+            write("    </head>\n");
+            write("    <body>\n");
+            htmlFragment.forEach(function (line) {
+                write("        " + line);
+            });
+            write("    </body>\n");
+            write("</html>\n");
+        }
+    };
+    return response;
+};
+exports.escapeHtml = escapeHtml;
+function escapeHtml(text) {
+    return String(text)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+}

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

@@ -0,0 +1,78 @@
+var Q = require("q");
+var Content = require("./content");
+var Status = require("./status");
+exports.HandleJsonResponses = function (app, reviver, tab) {
+    return function (request) {
+        request.handleJsonResponse = exports.handleJsonResponse;
+        return Q.fcall(app, request)
+        .then(function (response) {
+            if (response.data !== void 0) {
+                return Q.fcall(exports.handleJsonResponse, response, reviver, tab);
+            } else {
+                return response;
+            }
+        });
+    };
+};
+exports.handleJsonResponse = function (response, revivier, tab) {
+    response.headers["content-type"] = "application/json";
+    response.body = {
+        forEach: function (write) {
+            write(JSON.stringify(response.data, revivier, tab));
+        }
+    };
+    return response;
+};
+/**
+ * Wraps a Q-JSGI application such that the child application may
+ * simply return an object, which will in turn be serialized into a
+ * Q-JSGI response.
+ *
+ * @param {Function(Request):Object} app an application that accepts a
+ * request and returns a JSON serializable object.
+ * @returns {App}
+ */
+exports.Json = function (app, reviver, tabs) {
+    return function (request, response) {
+        return Q.when(app(request, response), function (object) {
+            return exports.json(object, reviver, tabs);
+        });
+    };
+};
+/**
+ * @param {Object} content data to serialize as JSON
+ * @param {Function} reviver
+ * @param {Number|String} tabs
+ * @returns {Response}
+ */
+exports.json = function (content, reviver, tabs) {
+    try {
+        var json = JSON.stringify(content, reviver, tabs);
+    } catch (exception) {
+        return Q.reject(exception);
+    }
+    return Content.ok([json]);
+};
+/**
+ * @param {Function(Request, Object):Response} app
+ * @param {App} badRequest
+ * @returns {App}
+ */
+exports.JsonRequest = function (app, badRequest) {
+    if (!badRequest)
+        badRequest = Status.badRequest;
+    return Content.ContentRequest(function (content, request, response) {
+        try {
+            var object = JSON.parse(content);
+        } catch (error) {
+            return badRequest(request, error);
+        }
+        return app(object, request, response);
+    });
+};

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

@@ -0,0 +1,120 @@
+var Q = require("q");
+var MimeParse = require("mimeparse");
+var Status = require("./status");
+exports.negotiate = negotiate;
+function negotiate(request, types, header) {
+    var keys = Object.keys(types);
+    var accept = request.headers[header || "accept"] || "*";
+    var best = MimeParse.bestMatch(keys, accept);
+    return types[best];
+}
+/// branch on HTTP method
+/**
+ * @param {Object * App} methods
+ * @param {App} notAllowed (optional)
+ * @returns {App}
+ */
+exports.Method = function (methods, methodNotAllowed) {
+    var keys = Object.keys(methods);
+    if (!methodNotAllowed)
+        methodNotAllowed = exports.methodNotAllowed;
+    return function (request, response) {
+        var method = request.method;
+        if (Object.has(keys, method)) {
+            return Object.get(methods, method)(request, response);
+        } else {
+            return methodNotAllowed(request, response);
+        }
+    };
+};
+var Negotiator = function (requestHeader, responseHeader, respond) {
+    return function (types, notAcceptable) {
+        var keys = Object.keys(types);
+        if (!notAcceptable)
+            notAcceptable = Status.notAcceptable;
+        return function (request) {
+            var accept = request.headers[requestHeader] || "*";
+            var type = MimeParse.bestMatch(keys, accept);
+            request.terms = request.terms || {};
+            request.terms[responseHeader] = type;
+            if (Object.has(keys, type)) {
+                return Q.when(types[type](request, response), function (response) {
+                    if (
+                        respond !== null &&
+                        response &&
+                        response.status === 200 &&
+                        response.headers
+                    ) {
+                        response.headers[responseHeader] = type;
+                    }
+                    return response;
+                });
+            } else {
+                return notAcceptable(request);
+            }
+        };
+    };
+};
+/// branch on HTTP content negotiation
+/**
+ * Routes based on content negotiation, between the request's `accept`
+ * header and the application's list of possible content types.
+ *
+ * @param {Object * App} types mapping content types to apps that can
+ * handle them.
+ * @param {App} notAcceptable
+ * @returns {App}
+ */
+exports.ContentType = Negotiator("accept", "content-type");
+exports.Language = Negotiator("accept-language", "language");
+exports.Charset = Negotiator("accept-charset", "charset");
+exports.Encoding = Negotiator("accept-encoding", "encoding");
+exports.Host = function (appForHost, notAcceptable) {
+    var table = Object.keys(appForHost).map(function (pattern) {
+        var parts = pattern.split(":");
+        return [
+            pattern,
+            parts[0] || "*",
+            parts[1] || "*",
+            appForHost[pattern]
+        ];
+    });
+    if (!notAcceptable) {
+        notAcceptable = Status.notAcceptable;
+    }
+    return function (request) {
+        // find first matching host for app
+        for (var index = 0; index < table.length; index++) {
+            var row = table[index]; // [hostname, port, app]
+            var pattern = row[0];
+            var hostname = row[1];
+            var port = row[2];
+            var app = row[3];
+            if (
+                (hostname === "*" || hostname === request.hostname) &&
+                (port === "*" || port === "" + request.port)
+            ) {
+                request.terms = request.terms || {};
+                request.terms.host = pattern;
+                return app(request);
+            }
+        }
+        return notAcceptable(request);
+    };
+};
+// Branch on a selector function based on the request
+exports.Select = function (select) {
+    return function (request, response) {
+        return Q.when(select(request, response), function (app) {
+            return app(request, response);
+        });
+    };
+};

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

@@ -0,0 +1,27 @@
+var HTTP = require("../http");
+var URL = require("url2");
+var Q = require("q");
+exports.Proxy = function (app) {
+    if (typeof app === "string") {
+        var location = app;
+        app = function (request) {
+            request.url = location;
+            return request;
+        };
+    }
+    return function (request, response) {
+        return Q.when(app.apply(this, arguments), function (request) {
+            return HTTP.request(request);
+        });
+    };
+};
+exports.ProxyTree = function (url) {
+    return exports.Proxy(function (request) {
+        request.url = URL.resolve(url, request.pathInfo.replace(/^\//, ""));
+        return request;
+    });
+};

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

@@ -0,0 +1,209 @@
+var Q = require("q");
+var URL = require("url2");
+var Http = require("../http");
+var Negotiation = require("./negotiate");
+var HtmlApps = require("./html");
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `301`
+ * @returns {App}
+ */
+exports.PermanentRedirect = function (location, status, tree) {
+    return function (request, response) {
+        return exports.permanentRedirect(request, location, status, tree);
+    };
+};
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `301`
+ * @returns {App}
+ */
+exports.PermanentRedirectTree = function (location, status) {
+    return function (request, response) {
+        return exports.permanentRedirect(request, location, status, true);
+    };
+};
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `307`
+ * @returns {App}
+ */
+exports.TemporaryRedirect = function (location, status, tree) {
+    return function (request, response) {
+        return exports.temporaryRedirect(request, location, status, tree);
+    };
+};
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `307`
+ * @returns {App}
+ */
+exports.TemporaryRedirectTree = function (location, status) {
+    return function (request, response) {
+        return exports.temporaryRedirect(request, location, status, true);
+    };
+};
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `307`
+ * @returns {App}
+ */
+exports.Redirect = function (location, status, tree) {
+    return function (request, response) {
+        return exports.redirect(request, location, status, tree);
+    };
+};
+/**
+ * @param {String} path
+ * @param {Number} status (optional) default is `307`
+ * @returns {App}
+ */
+exports.RedirectTree = function (location, status) {
+    return function (request, response) {
+        return exports.redirect(request, location, status, true);
+    };
+};
+exports.permanentRedirect = function (request, location, status) {
+    return exports.redirect(request, location, status || 301);
+};
+exports.permanentRedirectTree = function (request, location, status) {
+    return exports.redirect(request, location, status || 301, true);
+};
+exports.temporaryRedirect = function (request, location, status) {
+    return exports.redirect(request, location, status || 307);
+};
+exports.temporaryRedirectTree = function (request, location, status) {
+    return exports.redirect(request, location, status || 307, true);
+};
+exports.redirectTree = function (request, location, status) {
+    return exports.redirect(request, location, status, true);
+};
+/**
+ * @param {String} location
+ * @param {Number} status (optional) default is `301`
+ * @returns {Response}
+ */
+exports.redirect = function (request, location, status, tree) {
+    // request.permanent gets set by Permanent middleware
+    status = status || (request.permanent ? 301 : 307);
+    // ascertain that the location is absolute, per spec
+    location = URL.resolve(request.url, location);
+    // redirect into a subtree with the remaining unrouted
+    // portion of the path, if so configured
+    if (tree) {
+        location = URL.resolve(
+            location,
+            request.pathInfo.replace(/^\//, "")
+        );
+    }
+    var handlers = {};
+    handlers["text/plain"] = exports.redirectText;
+    if (request.handleHtmlFragmentResponse) {
+        handlers["text/html"] = exports.redirectHtml;
+    }
+    var handler = Negotiation.negotiate(request, handlers) || exports.redirectText;
+    return handler(request, location, status);
+};
+exports.redirectText = function (request, location, status) {
+    var content = (
+        (request.permanent ? "Permanent redirect\n" : "Temporary redirect\n") +
+        "See: " + location + "\n"
+    );
+    var contentLength = content.length;
+    return {
+        status: status,
+        headers: {
+            location: location,
+            "content-type": "text/plain"
+        },
+        body: [content]
+    };
+};
+exports.redirectHtml = function (request, location, status) {
+    var title = request.permanent ? "Permanent redirect" : "Temporary redirect";
+    return {
+        status: status,
+        headers: {
+            location: location,
+            "content-type": "text/html"
+        },
+        htmlTitle: title,
+        htmlFragment: {
+            forEach: function (write) {
+                write("<h1>" + HtmlApps.escapeHtml(title) + "</h1>\n");
+                write(
+                    "<p>See: <a href=\"" + HtmlApps.escapeHtml(location) + "\">" +
+                    HtmlApps.escapeHtml(location) +
+                    "</a></p>\n"
+                );
+            }
+        }
+    };
+};
+exports.RedirectTrap = function (app, maxRedirects) {
+    maxRedirects = maxRedirects || 20;
+    return function (request, response) {
+        var remaining = maxRedirects;
+        var deferred = Q.defer();
+        var self = this;
+        var args = arguments;
+        request = Http.normalizeRequest(request);
+        // try redirect loop
+        function next() {
+            Q.fcall(function () {
+                return app(request, response);
+            })
+            .then(function (response) {
+                if (exports.isRedirect(response)) {
+                    if (remaining--) {
+                        request.url = response.headers.location;
+                        next();
+                    } else {
+                        throw new Error("Maximum redirects.");
+                    }
+                } else {
+                    deferred.resolve(response);
+                }
+            })
+            .fail(deferred.reject)
+        }
+        next();
+        return deferred.promise;
+    };
+};
+exports.isRedirect = function (response) {
+    return isRedirect[response.status] || false;
+};
+var isRedirect = {
+    301: true,
+    302: true,
+    303: true,
+    307: true
+};