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

traceur-rb 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (255) hide show

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/directory-list-spec.js ADDED Viewed

@@ -0,0 +1,86 @@
+require("../lib/jasmine-promise");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+describe("directory lists", function () {
+    it("should be fine in plain text", function () {
+        var fixture = FS.join(module.directory || __dirname, "fixtures");
+        var app = new Apps.Chain()
+        .use(Apps.Cap)
+        .use(Apps.ListDirectories)
+        .use(function () {
+            return Apps.FileTree(fixture);
+        })
+        .end()
+        return Http.Server(app)
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/",
+                headers: {
+                    accept: "text/plain"
+                },
+                charset: 'utf-8'
+            })
+            .then(function (content) {
+                expect(content).toEqual("01234.txt\n1234.txt\n5678.txt\n9012/\n");
+            })
+            .finally(server.stop);
+        });
+    });
+    it("should be fine in html", function () {
+        var fixture = FS.join(module.directory || __dirname, "fixtures");
+        var app = new Apps.Chain()
+        .use(Apps.Cap)
+        .use(Apps.HandleHtmlFragmentResponses)
+        .use(Apps.ListDirectories)
+        .use(function () {
+            return Apps.FileTree(fixture);
+        })
+        .end()
+        return Http.Server(app)
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/",
+                headers: {
+                    accept: "text/html"
+                },
+                charset: 'utf-8'
+            })
+            .then(function (content) {
+                expect(content).toEqual(
+                    "<!doctype html>\n" +
+                    "<html>\n" +
+                    "    <head>\n" +
+                    "        <title>Directory Index</title>\n" +
+                    "    </head>\n" +
+                    "    <body>\n" +
+                    "        <ul class=\"directory-index\">\n" +
+                    "            <li class=\"entry file\"><a href=\"01234.txt\">01234.txt</a></li>\n" +
+                    "            <li class=\"entry file\"><a href=\"1234.txt\">1234.txt</a></li>\n" +
+                    "            <li class=\"entry file\"><a href=\"5678.txt\">5678.txt</a></li>\n" +
+                    "            <li class=\"entry directory\"><a href=\"9012/\">9012/</a></li>\n" +
+                    "        </ul>\n" +
+                    "    </body>\n" +
+                    "</html>\n"
+                );
+            })
+            .finally(server.stop);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/01234.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 01234.txt

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/1234.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ 1234

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/5678.txt ADDED Viewed

File without changes

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/fixtures/9012/3456.txt ADDED Viewed

File without changes

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

@@ -0,0 +1,49 @@
+require("../lib/jasmine-promise");
+var Q = require("q");
+var Http = require("../../http");
+var Negotiate = require("../../http-apps/negotiate");
+var Content = require("../../http-apps/content");
+describe("http host negotiation", function () {
+    it("should work", function () {
+        return Http.Server(Negotiate.Host({
+            "localhost:999": function (request) {
+                throw new Error("Should not get here");
+            },
+            "127.0.0.1:999": function (request) {
+                throw new Error("Should not get here");
+            },
+            "localhost": function (request) {
+                return Content.ok("Hello, Localhost");
+            },
+            "127.0.0.1": function (request) {
+                return Content.ok("Hello, 127.0.0.1");
+            }
+        }))
+        .listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+            return Q.fcall(function () {
+                return Http.read({
+                    "url": "http://localhost:" + port,
+                    "charset": "utf-8"
+                })
+                .then(function (result) {
+                    expect(result).toEqual("Hello, Localhost");
+                });
+            })
+            .then(function () {
+                return Http.read({
+                    "url": "http://127.0.0.1:" + port,
+                    "charset": "utf-8"
+                })
+                .then(function (result) {
+                    expect(result).toEqual("Hello, 127.0.0.1");
+                });
+            })
+            .finally(server.stop);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/interpret-range-spec.js ADDED Viewed

@@ -0,0 +1,47 @@
+// http://labs.apache.org/webarch/http/draft-fielding-http/p5-range.html#range.units
+var Apps = require("../../http-apps/fs");
+var size = 10000;
+var tests = [
+    {
+        description: "The first 500 bytes (byte offsets 0-499, inclusive)",
+        input: "bytes=0-499",
+        oracle: {begin: 0, end: 500}
+    },
+    {
+        description: "The second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-999",
+        oracle: {begin: 500, end: 1000}
+    },
+    {
+        description: "The initial 500 bytes with 0 elided",
+        input: "bytes=-499",
+        oracle: {begin: 0, end: 500}
+    },
+    {
+        description: "The final 500 bytes with final elided (byte offsets 9500-9999, inclusive)",
+        input: "bytes=9500-",
+        oracle: {begin: 9500, end: 10000}
+    },
+    {
+        description: "Legal but not canonical specification of the second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-600,601-999",
+        oracle: {begin: 500, end: 1000}
+    },
+    {
+        description: "Legal but not canonical specification of the second 500 bytes (byte offsets 500-999, inclusive)",
+        input: "bytes=500-700,601-999",
+        oracle: {begin: 500, end: 1000}
+    }
+];
+describe("range interpretation", function () {
+    tests.forEach(function (test) {
+        it("should interpret " + test.input, function () {
+            expect(Apps.interpretFirstRange(test.input, size)).toEqual(test.oracle);
+        });
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/http-apps/partial-range-spec.js ADDED Viewed

@@ -0,0 +1,186 @@
+require("../lib/jasmine-promise");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
+describe("HTTP Range", function () {
+    var fixture, app, serveAndTest;
+    describe("Byte Ranges" , function () {
+        beforeEach(function () {
+            fixture = FS.join(module.directory || __dirname, "fixtures", "01234.txt");
+            app = new Apps.Chain()
+                .use(Apps.Cap)
+                .use(function () {
+                    return Apps.File(fixture);
+                })
+                .end();
+            serveAndTest = function serveAndTest(rangeExp, expectedStatus) {
+                return Http.Server(app)
+                .listen(0)
+                .then(function (server) {
+                    var port = server.node.address().port;
+                    return Http.read({
+                        "url": "http://127.0.0.1:" + port + "/",
+                        "headers": {
+                            "range": rangeExp
+                        }
+                    }, function (response) {
+                        return response.status === expectedStatus;
+                    }).finally(server.stop);
+                })
+            }
+        });
+        // A byte range operation MAY specify a single range of bytes, or a set of ranges within a single entity.
+        //    ranges-specifier = byte-ranges-specifier
+        //    byte-ranges-specifier = bytes-unit "=" byte-range-set
+        //    byte-range-set  = 1#( byte-range-spec | suffix-byte-range-spec )
+        //    byte-range-spec = first-byte-pos "-" [last-byte-pos]
+        //    first-byte-pos  = 1*DIGIT
+        //    last-byte-pos   = 1*DIGIT
+        describe("byte range spec", function () {
+            // The first-byte-pos value in a byte-range-spec gives the byte-offset of the first byte in a range. The
+            // last-byte-pos value gives the byte-offset of the last byte in the range; that is, the byte positions
+            // specified are inclusive. Byte offsets start at zero.
+            it("positions are inclusive", function () {
+               return serveAndTest("bytes=0-2", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('012');
+               });
+            });
+            it("last position is optional", function () {
+               return serveAndTest("bytes=0-", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('01234.txt\n');
+               });
+            });
+            // TODO
+            xit("non contiguous ranges", function () {
+               return serveAndTest("bytes=0-2,4-5", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('0124.');
+               });
+            });
+            // If the last-byte-pos value is present, it MUST be greater than
+            // or equal to the first-byte-pos in that byte-range-spec, or the
+            // byte- range-spec is syntactically invalid. The recipient of a
+            // byte-range- set that includes one or more syntactically invalid
+            // byte-range-spec values MUST ignore the header field that
+            // includes that byte-range- set.
+            describe("invalid syntax should be ignored", function () {
+                it("last positions must be greater than first", function () {
+                    return serveAndTest("bytes=4-3", 216)
+                    .then(function (content) {
+                        expect(false).toBe(true);
+                    }, function (error) {
+                        expect(error.response.status).toBe(416);
+                    })
+                });
+                it("if any part is invalid, all of it is invalid", function () {
+                    return serveAndTest("bytes=0-2,4-3", 216)
+                    .then(function (content) {
+                        expect(false).toBe(true);
+                    }, function (error) {
+                        expect(error.response.status).toBe(416);
+                    });
+                });
+            });
+            // If the last-byte-pos value is absent, or if the value is greater than or equal to the current length of
+            // the entity-body, last-byte-pos is taken to be equal to one less than the current length of the entity-
+            // body in bytes.
+            describe("last position should be truncated to the length of the content", function () {
+                it("single range", function () {
+                   return serveAndTest("bytes=0-10", 206)
+                   .then(function (content) {
+                       expect(content.toString('utf-8')).toEqual('01234.txt\n');
+                   });
+                });
+                // TODO
+                xit("multiple ranges", function () {
+                   return serveAndTest("bytes=0-2,1-10", 206)
+                   .then(function (content) {
+                       expect(content.toString('utf-8')).toEqual('0121234.txt\n');
+                   });
+                });
+            });
+        });
+        //By its choice of last-byte-pos, a client can limit the number of
+        //bytes retrieved without knowing the size of
+        // the entity.
+        //    suffix-byte-range-spec = "-" suffix-length
+        //    suffix-length = 1*DIGIT
+        describe("suffix byte range spec", function () {
+            it("can limit the number of bytes retrieved", function () {
+               return serveAndTest("bytes=-3", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('0123');
+               });
+            });
+            // A suffix-byte-range-spec is used to specify the suffix of the
+            // entity-body, of a length given by the suffix-length value. (That
+            // is, this form specifies the last N bytes of an entity-body.) If
+            // the entity is shorter than the specified suffix-length, the
+            // entire entity-body is used.
+            it("last position should be truncated to the length", function () {
+               return serveAndTest("bytes=-20", 206)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('01234.txt\n');
+               });
+            });
+        });
+        // If a syntactically valid byte-range-set includes at least one byte-
+        // range-spec whose first-byte-pos is less than the current length of
+        // the entity-body, or at least one suffix-byte-range-spec with a non-
+        // zero suffix-length, then the byte-range-set is satisfiable.
+        // Otherwise, the byte-range-set is unsatisfiable.  If the
+        // byte-range-set is unsatisfiable, the server SHOULD return a response
+        // with a status of 416 (Requested range not satisfiable). Otherwise,
+        // the server SHOULD return a response with a status of 206 (Partial
+        // Content) containing the satisfiable ranges of the entity-body.
+        describe("satisfiability", function () {
+            it("should return 416 if a byte range spec is unsatisfiable", function () {
+               return serveAndTest("bytes=10-11", 416)
+               .then(function (content) {
+                   expect(true).toBeTruthy();
+               }).fail(function () {
+                   expect(false).toBeTruthy();
+               });
+            });
+            it("should return 416 if a suffix byte range spec is unsatisfiable", function () {
+               return serveAndTest("bytes=1-0", 206)
+               .then(function (content) {
+                   expect(true).toBeFalsy();
+               }).fail(function (error) {
+                   expect(error.response.status).toBe(416);
+               });
+            });
+            it("should return 416 if all byte range spec are unsatisfiable", function () {
+               return serveAndTest("bytes=10-11,-0", 416)
+               .then(function (content) {
+                   expect(true).toBeTruthy();
+               }).fail(function () {
+                   expect(false).toBeTruthy();
+               });
+            });
+            // TODO
+            xit("should return 200 if at least one byte range spec is satisfiable", function () {
+               return serveAndTest("bytes=10-11,0-2", 200)
+               .then(function (content) {
+                   expect(content.toString('utf-8')).toEqual('012');
+               });
+            });
+        });
+    });
+});

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

@@ -0,0 +1,82 @@
+require("../lib/jasmine-promise");
+var Q = require("q");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+describe("http proxy", function () {
+    it("should work", function () {
+        var requestProxy;
+        var responseProxy;
+        var requestActual;
+        var responseActual;
+        var app = Apps.Chain()
+        .use(Apps.Trap, function (response) {
+            responseActual = response;
+            return response;
+        })
+        .use(Apps.Tap, function (request) {
+            requestActual = request;
+        })
+        .use(function (next) {
+            return Apps.Branch({
+                "foo": Apps.Branch({
+                    "bar": new Apps.Chain()
+                        .use(Apps.Cap)
+                        .use(function () {
+                            return Apps.Content(["Hello, World!"])
+                        })
+                        .end()
+                })
+            })
+        })
+        .end();
+        var server1 = Http.Server(app);
+        return Q.when(server1.listen(0))
+        .then(function (server1) {
+            var port = server1.node.address().port;
+            var server2 = Http.Server(
+                Apps.Trap(
+                    Apps.Tap(
+                        Apps.ProxyTree("http://127.0.0.1:" + port + "/foo/"),
+                        function (request) {
+                            requestProxy = request;
+                        }
+                    ),
+                    function (response) {
+                        responseProxy = response;
+                        return response;
+                    }
+                )
+            );
+            return [server1, server2.listen(0)];
+        })
+        .spread(function (server1, server2) {
+            var port = server2.node.address().port;
+            return Http.read({
+                url: "http://127.0.0.1:" + port + "/bar",
+                charset: "utf-8"
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!");
+                expect(requestActual).toBeTruthy();
+                expect(responseActual).toBeTruthy();
+                expect(requestProxy).toBeTruthy();
+                expect(responseProxy).toBeTruthy();
+            })
+            .finally(server1.stop)
+            .finally(server2.stop)
+        })
+    });
+});