traceur-rb 0.0.1

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

@@ -0,0 +1,67 @@
+"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 merged = FS.merge([
+            Mock({
+                "a": 10,
+                "b": 20,
+                "1/2/3": "123"
+            }),
+            Mock({
+                "a": 20,
+                "c": 30
+            }),
+            Mock({
+                "a": 30,
+                "d": 40
+            }),
+        ])
+
+        return merged.then(function (merged) {
+
+            return Q.fcall(function () {
+                return merged.listTree();
+            })
+            .then(function (list) {
+                expect(list.sort()).toEqual([
+                    ".",
+                    "1",
+                    normalize("1/2"),
+                    normalize("1/2/3"),
+                    "a",
+                    "b",
+                    "c",
+                    "d",
+                ]);
+            })
+
+            // overridden by a previous tree
+            .then(function () {
+                return merged.read("a");
+            })
+            .then(function (a) {
+                expect(a).toBe("30");
+            })
+
+            // not overridden
+            .then(function () {
+                return merged.read("b");
+            })
+            .then(function (a) {
+                expect(a).toBe("20");
+            })
+
+        })
+
+    });
+
+});
+

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

@@ -0,0 +1,219 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+
+describe("move", function () {
+    it("should move", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            // initial list
+            return Q.fcall(function () {
+                return mock.listTree()
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "hello.txt"
+                ]);
+            })
+
+            // initial content
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+
+            // move!
+            .then(function () {
+                return mock.move("hello.txt", "new-hello.txt");
+            })
+
+            // list after
+            .then(function () {
+                return mock.listTree();
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "new-hello.txt"
+                ]);
+            })
+
+            // content after
+            .then(function () {
+                return mock.read("new-hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+
+        });
+    });
+
+    it("should not delete a node if the source and target are the same", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            // initial list
+            return Q.fcall(function () {
+                return mock.listTree()
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "hello.txt"
+                ]);
+            })
+
+            // initial content
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+
+            // move!
+            .then(function () {
+                return mock.move("hello.txt", "hello.txt");
+            })
+
+            // list after
+            .then(function () {
+                return mock.listTree();
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "hello.txt"
+                ]);
+            })
+
+            // content after
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+        });
+
+    });
+
+    it("should not delete a node if the source and target refer to the same node", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            return Q.fcall(function () {
+                return Q.all([
+                    mock.symbolicCopy("hello.txt", "a.txt"),
+                    mock.symbolicCopy("hello.txt", "b.txt"),
+                ]);
+            })
+
+            // initial list
+            .then(function () {
+                return mock.listTree()
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "a.txt",
+                    "b.txt",
+                    "hello.txt"
+                ]);
+            })
+
+            // initial content
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+
+            // move!
+            .then(function () {
+                return mock.move("a.txt", "b.txt");
+            })
+
+            // list after
+            .then(function () {
+                return mock.listTree();
+            })
+            .then(function (list) {
+                expect(list).toEqual([
+                    ".",
+                    "a.txt",
+                    "b.txt",
+                    "hello.txt"
+                ]);
+            })
+
+            // content after
+            .then(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\n");
+            })
+        });
+
+    });
+
+    it("should fail to move over an existing directory", function () {
+        var mock = Mock({
+            "hi.txt": "Hello, World!",
+            "hello": {}
+        });
+
+        return Q.fcall(function () {
+            return mock.isDirectory("/hello");
+        })
+        .then(function (isDirectory) {
+            expect(isDirectory).toBe(true);
+        })
+
+        .then(function () {
+            return mock.move("/hi.txt", "/hello");
+        })
+        .then(function () {
+            throw new Error("Move should not succeed.");
+        }, function (error) {
+        })
+
+    });
+
+    it("should fail to move over an existing directory of the same name", function () {
+        var mock = Mock({
+            "hello": {}
+        });
+
+        return Q.fcall(function () {
+            return mock.isDirectory("/hello");
+        })
+        .then(function (isDirectory) {
+            expect(isDirectory).toBe(true);
+        })
+
+        .then(function () {
+            return mock.move("/hello", "/hello");
+        })
+        .then(function () {
+            throw new Error("Move should not succeed.");
+        }, function (error) {
+        })
+
+    });
+
+});
+

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

@@ -0,0 +1,20 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+
+describe("toObject", function () {
+    it("should take a snapshot of a tree", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .invoke("toObject")
+        .then(function (tree) {
+
+            expect(tree["hello.txt"].toString("utf-8")).toEqual("Hello, World!\n");
+            expect(Object.keys(tree)).toEqual(["hello.txt"]);
+
+        });
+    });
+});
+

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

@@ -0,0 +1,26 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+
+describe("open range", function () {
+    it("read a partial range of a file", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            return mock.read("hello.txt", {
+                begin: 1,
+                end: 3
+            })
+            .then(function (content) {
+                expect(content).toBe("el");
+            })
+
+        });
+
+    });
+});
+

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

@@ -0,0 +1,40 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+/*global describe,it,expect */
+
+describe("read", function () {
+    it("should read a file from a mock filesystem", function () {
+
+        return FS.mock(FS.join(__dirname, "fixture"))
+        .then(function (mock) {
+
+            return Q.fcall(function () {
+                return mock.read("hello.txt");
+            })
+            .then(function (content) {
+                expect(content).toBe("Hello, World!\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({read: function () {}, close: function () {}});
+            };
+
+            return mock.read("hello.txt", "a", "utf8");
+        });
+    });
+
+});
+

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

@@ -0,0 +1,37 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+
+describe("removeDirectory", function () {
+    it("should remove a directory", function () {
+
+        return FS.mock(FS.join(__dirname))
+        .then(function (mock) {
+
+            // now you see it
+            return Q.fcall(function () {
+                return mock.isDirectory("fixture");
+            })
+            .then(function (isDirectory) {
+                expect(isDirectory).toBe(true);
+            })
+
+            .then(function () {
+                return mock.removeDirectory("fixture");
+            })
+
+            // now you don't
+            .then(function () {
+                return mock.isDirectory("fixture");
+            })
+            .then(function (isDirectory) {
+                expect(isDirectory).toBe(false);
+            })
+
+        });
+
+    });
+});
+

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

@@ -0,0 +1,39 @@
+"use strict";
+
+require("../../lib/jasmine-promise");
+var Q = require("q");
+var FS = require("../../../fs");
+var Mock = require("../../../fs-mock");
+var normalize = FS.normal;
+
+describe("removeTree", function () {
+    it("should remove a tree", function () {
+
+        var mock = Mock({
+            "a/b": {
+                "c": {
+                    "d": 66,
+                    "e": 99
+                }
+            }
+        });
+
+        return Q.fcall(function () {
+            return mock.removeTree("a/b/c");
+        })
+
+        .then(function () {
+            return mock.listTree();
+        })
+        .then(function (list) {
+            expect(list).toEqual([
+                ".",
+                "a",
+                normalize("a/b")
+            ]);
+        })
+
+    });
+
+});
+