traceur-rb 0.0.1

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/root-spec.js

@@ -0,0 +1,32 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+var Root = require("../../../fs-root");
+
+describe("root", function () {
+    it("should make a filesystem from a subtree of a mock filesystem", function () {
+
+        var mock = Mock({
+            "a/b/1": 10,
+            "a/b/2": 20,
+            "a/b/3": 30
+        });
+
+        var chroot = Root(mock, "a/b");
+
+        return chroot.invoke("listTree")
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "1",
+                "2",
+                "3"
+            ]);
+        });
+
+    });
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/stat-spec.js

@@ -0,0 +1,26 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+/*global describe,it,expect */
+
+describe("stat", function () {
+    it("should return a Stats object", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+            return mock.stat("hello.txt");
+        })
+        .then(function (stat) {
+            expect(stat.node).toBeDefined();
+            expect(stat.size).toBeDefined();
+            expect(stat.size).toBeGreaterThan(0);
+            expect(stat.isDirectory()).toBe(false);
+            expect(stat.isFile()).toBe(true);
+        });
+    });
+
+
+
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/symbolic-link-spec.js

@@ -0,0 +1,86 @@
+
+require("../../lib/jasmine-promise");
+var MockFs = require("../../../fs-mock");
+var normalize = require('../../../fs').normal;
+
+describe("symbolic link", function () {
+    it("should", function () {
+        var mock = MockFs();
+
+        // make some content
+        return mock.makeTree("a/b")
+        .then(function () {
+            return mock.write("a/b/c.txt", "Hello, World!")
+        })
+
+        // verify content
+        .then(function () {
+            return mock.read("a/b/c.txt")
+        })
+        .then(function (content) {
+            expect(content).toBe("Hello, World!");
+        })
+
+        // link it
+        .then(function () {
+            return mock.symbolicCopy("/a/b/c.txt", "a/b/d.txt", "file")
+        })
+
+        // should have a link
+        .then(function () {
+            return mock.readLink("a/b/d.txt")
+        })
+        .then(function (link) {
+            expect(link).toBe("c.txt");
+        })
+
+        // should have a canonical path
+        .then(function () {
+            return mock.canonical("a/b/d.txt")
+        })
+        .then(function (canonical) {
+            expect(canonical).toBe("/a/b/c.txt");
+        })
+
+        // should be listed
+        .then(function () {
+            return mock.listTree()
+        })
+        .then(function (content) {
+            expect(content).toEqual([
+                ".",
+                "a",
+                normalize("a/b"),
+                normalize("a/b/c.txt"),
+                normalize("a/b/d.txt")
+            ])
+        })
+
+        // should be non-destructive
+        .then(function () {
+            return mock.read("a/b/c.txt")
+        })
+        .then(function (content) {
+            expect(content).toBe("Hello, World!");
+        })
+
+        // should be identified as a file
+        .then(function () {
+            return mock.isSymbolicLink("a/b/d.txt");
+        })
+        .then(function (isSymbolicLink) {
+            expect(isSymbolicLink).toBe(true);
+        })
+
+        // should have the same content
+        .then(function () {
+            return mock.read("a/b/d.txt");
+        })
+        .then(function (content) {
+            expect(content).toBe("Hello, World!");
+        });
+
+    });
+});
+
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/working-directory-spec.js

@@ -0,0 +1,31 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var Mock = require("../../../fs-mock");
+
+describe("mock working directory", function () {
+    it("should perform actions relative to the given working directory", function () {
+
+        var mock = Mock({
+            "a/b": {
+                "c": {
+                    "d": 66,
+                    "e": 99
+                }
+            }
+        }, "a/b/c");
+
+        return mock.listTree()
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "d",
+                "e"
+            ]);
+        })
+
+    });
+
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/write-spec.js

@@ -0,0 +1,73 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+/*global describe,it,expect */
+
+describe("write", function () {
+    it("should write a file to a mock filesystem", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            return Q.fcall(function () {
+                return mock.write("hello.txt", "Goodbye!\n");
+            })
+            .then(function () {
+                return mock.isFile("hello.txt");
+            })
+            .then(function (isFile) {
+                expect(isFile).toBe(true);
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content.toString("utf-8")).toBe("Goodbye!\n");
+            })
+        });
+    });
+
+    it("takes a flags argument", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+            return Q.fcall(function () {
+                return mock.write("hello.txt", "Goodbye!\n", "a");
+            })
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (contents) {
+                expect(contents).toBe("Hello, World!\nGoodbye!\n");
+            });
+        });
+    });
+
+    it("takes an options object with flags", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+            return Q.fcall(function () {
+                return mock.write("hello.txt", "Goodbye!\n", { flags: "a" });
+            })
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (contents) {
+                expect(contents).toBe("Hello, World!\nGoodbye!\n");
+            });
+        });
+    });
+
+    it("calls open correctly", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+            mock.open = function (path, options) {
+                expect(path).toBe("hello.txt");
+                expect(options.flags).toBe("a");
+                expect(options.charset).toBe("utf8");
+                return Q.resolve({write: function () {}, close: function () {}});
+            };
+
+            return mock.write("hello.txt", "Goodbye!\n", "a", "utf8");
+        });
+    });
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/range-spec.js

@@ -0,0 +1,23 @@
+"use strict";
+
+require("../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../fs");
+
+describe("open range", function () {
+    it("read a partial range of a file", function () {
+
+        var name = FS.join(module.directory || __dirname, "range-spec.txt");
+
+        return FS.open(name, {
+            begin: 1,
+            end: 3
+        })
+        .invoke("read")
+        .then(function (content) {
+            expect(content).toBe("23");
+        })
+
+    });
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/range-spec.txt

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

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/read-spec.js

@@ -0,0 +1,22 @@
+
+require("../lib/jasmine-promise");
+var FS = require("../../fs");
+
+describe("read", function () {
+
+    it("should read in utf-8", function () {
+        return FS.read(FS.join(__dirname, "fixtures/hello.txt"))
+        .then(function (text) {
+            expect(text).toBe("Hello, World!\n");
+        });
+    });
+
+    it("should read in bytewise", function () {
+        return FS.read(FS.join(__dirname, "fixtures/hello.txt"), "b")
+        .then(function (bytes) {
+            expect(bytes instanceof Buffer).toBe(true);
+        });
+    });
+
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/relative-spec.js

@@ -0,0 +1,25 @@
+
+var FS = require("../../fs");
+
+describe("relativeFromDirectory", function () {
+
+    it("should find the relative path from a directory", function () {
+
+        expect(FS.relativeFromDirectory("/a/b", "/a/b")).toBe("");
+        expect(FS.relativeFromDirectory("/a/b/", "/a/b")).toBe("");
+        expect(FS.relativeFromDirectory("/a/b", "/a/b/")).toBe("");
+        expect(FS.relativeFromDirectory("/a/b/", "/a/b/")).toBe("");
+
+        expect(FS.relativeFromDirectory("/a/b", "/a/b/c")).toBe("c");
+        expect(FS.relativeFromDirectory("/a/b/", "/a/b/c")).toBe("c");
+        expect(FS.relativeFromDirectory("/a/b", "/a/b/c/")).toBe("c");
+        expect(FS.relativeFromDirectory("/a/b/", "/a/b/c/")).toBe("c");
+
+        expect(FS.relativeFromDirectory("/a/b", "/a")).toBe("..");
+        expect(FS.relativeFromDirectory("/a/b/", "/a")).toBe("..");
+        expect(FS.relativeFromDirectory("/a/b", "/a/")).toBe("..");
+        expect(FS.relativeFromDirectory("/a/b/", "/a/")).toBe("..");
+
+    });
+
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/reroot-spec.js

@@ -0,0 +1,45 @@
+var FS = require("../../fs");
+
+require("../lib/jasmine-promise");
+
+describe("reroot", function () {
+
+    it("should still have makeDirectory()", function() {
+        return FS.reroot("/")
+        .then(function(fs) {
+            expect(fs.makeTree instanceof Function).toBe(true);
+            expect(fs.makeDirectory instanceof Function).toBe(true);
+        });
+    });
+
+    it("should have a makeDirectory() that creates within the attenuated root", function() {
+        var tmpdir = FS.join(__dirname, 'tmp');
+        return FS.removeTree(tmpdir)
+        .then(null, function () {
+            // ignore fail
+        }).then(function() {
+            return FS.makeTree(tmpdir)
+        }).then(function () {
+            return FS.isDirectory(tmpdir);
+        }).then(function (isDirectory) {
+            if (!isDirectory)
+                throw new Error("Failed to create tmpdir");
+        }).then(function() {
+            return FS.reroot(tmpdir);
+        }).then(function(fs) {
+            return fs.makeDirectory('/foo');
+        }).then(function() {
+            var outerFooDir = FS.join(tmpdir, 'foo');
+            return FS.isDirectory(outerFooDir);
+        }).then(function(isDirectory) {
+            if (!isDirectory)
+                throw new Error("Directory not created");
+        })
+        .finally(function () {
+            return FS.removeTree(tmpdir)
+            .then(null, function () {
+                // ignore fail
+            })
+        })
+    });
+});

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/write-spec.js

@@ -0,0 +1,38 @@
+
+require("../lib/jasmine-promise");
+var FS = require("../../fs");
+
+describe("write", function () {
+    it("should write in utf-8", function () {
+        var path = FS.join(__dirname, "fixtures/so-it-is-written.txt");
+        var content = "Hello, World!\n";
+        return FS.write(path, content)
+        .then(function (result) {
+            expect(result).toBe(undefined);
+            return FS.read(path)
+        })
+        .then(function (readContent) {
+            expect(readContent).toEqual(content);
+        })
+        .finally(function () {
+            return FS.remove(path);
+        });
+    });
+
+    it("should write bytewise", function () {
+        var path = FS.join(__dirname, "fixtures/so-it-is-written.txt");
+        var content = "Good bye, cruel World!\n";
+        return FS.write(path, new Buffer(content, "utf-8"))
+        .then(function (result) {
+            expect(result).toBe(undefined);
+            return FS.read(path)
+        })
+        .then(function (readContent) {
+            expect(readContent).toEqual(content);
+        })
+        .finally(function () {
+            return FS.remove(path);
+        });
+    });
+});
+

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

@@ -0,0 +1,52 @@
+
+require("../lib/jasmine-promise");
+var Q = require("q");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+
+describe("http cookies", function () {
+
+    var hosts = ["localhost", "127.0.0.1"];
+
+    hosts.forEach(function (host) {
+        it("should work on host" + host, function () {
+
+            var server = Http.Server(function (request) {
+                return {
+                    status: 200,
+                    headers: {
+                        "set-cookie": "a=10; MaxAge=1"
+                    },
+                    body: [request.headers.cookie || ""]
+                };
+            });
+
+            var request = Apps.Normalize(Apps.CookieJar(Http.request));
+
+            return server.listen(0)
+            .then(function (server) {
+                var address = server.node.address();
+                return request("http://" + host + ":" + address.port)
+                .get("body")
+                .invoke("read")
+                .invoke("toString", "utf-8")
+                .then(function (content) {
+                    expect(content).toEqual(""); // no cookie first time
+                })
+                .then(function () {
+                    return request("http://" + host + ":" + address.port)
+                    .get("body")
+                    .invoke("read")
+                    .invoke("toString", "utf-8")
+                })
+                .then(function (content) {
+                    expect(content).toEqual("a=10"); // cookie set second time
+                })
+            })
+            .timeout(1000)
+            .finally(server.stop)
+        });
+    });
+
+});
+