traceur-rb 0.0.1

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

@@ -0,0 +1,47 @@
+
+var FS = require("../../fs-boot");
+var normalize = FS.normal;
+
+var specs = [
+    {
+        "from": "foo",
+        "to": ""
+    },
+    {
+        "from": "",
+        "to": ".."
+    },
+    {
+        "from": ".",
+        "to": ".."
+    },
+    {
+        "from": "..",
+        "to": normalize("../..")
+    },
+    {
+        "from": "../foo",
+        "to": ".."
+    },
+    {
+        "from": "/foo/bar",
+        "to": normalize("/foo")
+    },
+    {
+        "from": "/foo",
+        "to": normalize("/")
+    },
+    {
+        "from": "/",
+        "to": "/"
+    }
+];
+
+describe("fs-boot directory", function () {
+    specs.forEach(function (spec) {
+        it("should parse " + JSON.stringify(spec.from), function () {
+            expect(FS.directory(spec.from)).toBe(spec.to);
+        });
+    });
+});
+

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

@@ -0,0 +1,11 @@
+
+var FS = require("../../fs");
+
+require("../lib/jasmine-promise");
+
+describe("contains", function () {
+    it("reflexive case", function () {
+        expect(FS.contains("/a/b", "/a/b")).toBe(true);
+    });
+});
+

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

@@ -0,0 +1 @@
+Hello, World!

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

@@ -0,0 +1,33 @@
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+
+describe("write and remove", function () {
+
+    it("should write and remove a file", function () {
+
+        var fixture = FS.join(__dirname, "fixture.txt");
+
+        return FS.write(fixture, "1234")
+        .then(function (result) {
+            expect(result).toBe(undefined);
+        })
+
+        .then(function () {
+            return FS.remove(fixture);
+        })
+        .then(function (result) {
+            expect(result).toBe(undefined);
+        })
+
+        .then(function () {
+            return FS.exists(fixture)
+        })
+        .then(function (exists) {
+            expect(exists).toBe(false);
+        })
+
+    });
+});
+

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

@@ -0,0 +1,92 @@
+"use strict";
+
+require("../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../fs");
+var _n = FS.normal;
+
+describe("makeTree", function () {
+    it("should make a branch of a tree", function () {
+
+        return Q.fcall(function () {
+            return FS.makeTree("a/b/c");
+        })
+
+        .then(function () {
+            return FS.listTree("a");
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                "a",
+                _n("a/b"),
+                _n("a/b/c")
+            ]);
+        })
+
+        .then(function () {
+            return FS.exists("a/b/c");
+        })
+        .then(function (exists) {
+            expect(exists).toBe(true);
+        })
+
+        .then(function () {
+            return FS.isDirectory("a/b/c");
+        })
+        .then(function (isDirectory) {
+            expect(isDirectory).toBe(true);
+        })
+
+    });
+
+    it("should make a branch of a tree even if some of it already exists", function () {
+
+        return Q.fcall(function () {
+            return FS.makeTree("a/b/c/d");
+        })
+
+        .then(function () {
+            return FS.listTree("a");
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                "a",
+                _n("a/b"),
+                _n("a/b/c"),
+                _n("a/b/c/d")
+            ]);
+        })
+        .then(function () {
+            return FS.removeTree("a");
+        })
+    });
+
+    it("should make branch from an absolute path", function () {
+
+        return Q.fcall(function () {
+            return FS.makeTree(FS.absolute("a/b/c/d"));
+        })
+
+        .then(function () {
+            return FS.listTree("a");
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                "a",
+                _n("a/b"),
+                _n("a/b/c"),
+                _n("a/b/c/d")
+            ]);
+        })
+        .then(function () {
+            return FS.removeTree("a");
+        })
+    });
+
+    it("should tolerate .", function () {
+        return Q.fcall(function () {
+            return FS.makeTree(".");
+        })
+    });
+});
+

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

@@ -0,0 +1,41 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+/*global describe,it,expect */
+
+describe("append", function () {
+
+    it("appends to a file on a mock filesystem", function () {
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+            return Q.fcall(function () {
+                return mock.append("hello.txt", "Goodbye!\n");
+            })
+            .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.append("hello.txt", "Goodbye!\n", "a", "utf8");
+        });
+    });
+
+});
+

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

@@ -0,0 +1,57 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+var normalize = FS.normal;
+
+describe("copyTree", function () {
+    it("should copy a tree", function () {
+
+        var mock = Mock({
+            "a/b": {
+                "c": {
+                    "d": 66,
+                    "e": 99
+                }
+            }
+        });
+
+        return Q.fcall(function () {
+            return mock.copyTree("a/b", "a/f");
+        })
+        .then(function () {
+            return Q.all([
+                mock.isDirectory("a/f"),
+                mock.exists("a/f/c"),
+                mock.isFile("a/f/c/d"),
+                mock.read("a/f/c/e")
+            ])
+        })
+        .then(function (existence) {
+            expect(existence.every(Boolean)).toBe(true);
+        })
+
+        .then(function () {
+            return mock.listTree();
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "a",
+                normalize("a/b"),
+                normalize("a/b/c"),
+                normalize("a/b/c/d"),
+                normalize("a/b/c/e"),
+                normalize("a/f"),
+                normalize("a/f/c"),
+                normalize("a/f/c/d"),
+                normalize("a/f/c/e")
+            ]);
+        })
+
+    });
+
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/fs/mock/fixture/hello.txt

@@ -0,0 +1 @@
+Hello, World!

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

@@ -0,0 +1,70 @@
+
+require("../../lib/jasmine-promise");
+var MockFs = require("../../../fs-mock");
+var normalize = require('../../../fs').normal;
+
+describe("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.link("a/b/c.txt", "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 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 identified as a file
+        .then(function () {
+            return mock.isFile("a/b/d.txt");
+        })
+        .then(function (isFile) {
+            expect(isFile).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/make-tree-spec.js

@@ -0,0 +1,109 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+var normalize = FS.normal;
+
+describe("makeTree", function () {
+    it("should make a branch of a tree", function () {
+
+        var mock = Mock({
+            "a": {}
+        });
+
+        return Q.fcall(function () {
+            return mock.makeTree("a/b/c");
+        })
+
+        .then(function () {
+            return mock.listTree();
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "a",
+                normalize("a/b"),
+                normalize("a/b/c")
+            ]);
+        })
+
+        .then(function () {
+            return mock.exists("a/b/c")
+        })
+        .then(function (exists) {
+            expect(exists).toBe(true);
+        })
+
+        .then(function () {
+            return mock.isDirectory("a/b/c")
+        })
+        .then(function (isDirectory) {
+            expect(isDirectory).toBe(true);
+        })
+
+    });
+
+    it("should make a branch of a tree even if some of it already exists", function () {
+
+        var mock = Mock({
+            "a/b": {}
+        });
+
+        return Q.fcall(function () {
+            return mock.makeTree("a/b/c/d");
+        })
+
+        .then(function () {
+            return mock.listTree();
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "a",
+                normalize("a/b"),
+                normalize("a/b/c"),
+                normalize("a/b/c/d")
+            ]);
+        })
+    });
+
+    it("should make an absolute tree from a subdirectory", function () {
+        var mock = Mock({
+            "a/b": {
+                "c": {
+                    "d.ext": 66
+                }
+            }
+        }, "/a/b");
+
+        return Q.fcall(function () {
+            return mock.makeTree("/a/b/c/x/y/z");
+        })
+        .then(function () {
+            return Q.all([
+                mock.isDirectory("a/b/c/x"),
+                mock.isDirectory("a/b/c/x/y"),
+                mock.isDirectory("a/b/c/x/y/z")
+            ]);
+        })
+        .then(function () {
+            return mock.listTree("/");
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                "/",
+                "/a",
+                "/a/b",
+                "/a/b/c",
+                "/a/b/c/d.ext",
+                "/a/b/c/x",
+                "/a/b/c/x/y",
+                "/a/b/c/x/y/z"
+            ]);
+        });
+    });
+
+});
+