traceur-rb 0.0.1

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

@@ -0,0 +1,110 @@
+/*global __dirname*/
+require("../lib/jasmine-promise");
+var Http = require("../../http");
+var Apps = require("../../http-apps");
+var FS = require("../../fs");
+var Mock = require("../../fs-mock");
+
+describe("FileTree followInsecureSymbolicLinks", function () {
+    var testApp;
+    function makeApp(followInsecureSymbolicLinks) {
+        var fixture = FS.join(module.directory || __dirname, "fixtures");
+        return FS.mock(fixture)
+        .then(function (mockFS) {
+            return FS.merge([ mockFS, Mock({ "6789/0123.txt": "0123\n" })]);
+        })
+        .then(function (mockFS) {
+            return mockFS.symbolicCopy("6789", FS.join("9012","linkedDir"), "directory").thenResolve(mockFS);
+        })
+        .then(function (mockFS) {
+            return mockFS.symbolicCopy( FS.join("6789","0123.txt"), FS.join("9012","linkedFile.txt"), "file").thenResolve(mockFS);
+        })
+        .then(function (mockFS) {
+            return new Apps.Chain()
+            .use(Apps.ListDirectories)
+            .use(function () {
+                return Apps.FileTree(FS.join("/","9012"), {fs: mockFS, followInsecureSymbolicLinks: followInsecureSymbolicLinks});
+            })
+            .end()
+        }).then(function (app) {
+            return Http.Server(app).listen(0)
+        });
+    };
+
+    describe("if false", function () {
+        beforeEach(function () {
+            testApp = makeApp(false)
+        });
+        it("should not follow symbolic links to directories", function () {
+            return testApp.then(function (server) {
+                var port = server.address().port;
+                return Http.read({
+                    url: "http://127.0.0.1:" + port + "/linkedDir/",
+                    headers: {
+                        accept: "text/plain"
+                    },
+                    charset: 'utf-8'
+                })
+                .then(null, function (error) {
+                    expect(error.response.status).toEqual(404);
+                })
+                .finally(server.stop);
+            });
+        });
+        it("should not follow symbolic links to files", function () {
+            return testApp.then(function (server) {
+                var port = server.address().port;
+                return Http.read({
+                    url: "http://127.0.0.1:" + port + "/linkedFile.txt",
+                    headers: {
+                        accept: "text/plain"
+                    },
+                    charset: 'utf-8'
+                })
+                .then(null, function (error) {
+                    expect(error.response.status).toEqual(404);
+                })
+                .finally(server.stop);
+            });
+        });
+    });
+
+    describe("if true", function () {
+        beforeEach(function () {
+            testApp = makeApp(true)
+        });
+        it("should follow symbolic links to directories", function () {
+            return testApp.then(function (server) {
+                var port = server.address().port;
+                return Http.read({
+                    url: "http://127.0.0.1:" + port + "/linkedDir/",
+                    headers: {
+                        accept: "text/plain"
+                    },
+                    charset: 'utf-8'
+                })
+                .then(function (content) {
+                    expect(content).toEqual("0123.txt\n");
+                })
+                .finally(server.stop);
+            });
+        });
+        it("should follow symbolic links to files", function () {
+            return testApp.then(function (server) {
+                var port = server.address().port;
+                return Http.read({
+                    url: "http://127.0.0.1:" + port + "/linkedFile.txt",
+                    headers: {
+                        accept: "text/plain"
+                    },
+                    charset: 'utf-8'
+                })
+                .then(function (content) {
+                    expect(content).toEqual("0123\n");
+                })
+                .finally(server.stop);
+            });
+        });
+    });
+
+});

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

@@ -0,0 +1,96 @@
+require("../lib/jasmine-promise");
+var Q = require("q");
+var HTTPS = require("https");
+var http = require('../../http');
+
+describe("https agent", function () {
+
+    it("should allow use self-signed certificate", function () {
+        var options = {
+            passphrase: 'q-io-https',
+            key: '-----BEGIN RSA PRIVATE KEY-----\n' +
+'Proc-Type: 4,ENCRYPTED\n' +
+'DEK-Info: DES-EDE3-CBC,6ACDE0E22CA24B54\n' +
+'\n' +
+'MHs2noP3Vm8SyHkZ/KaPv2tkwEQx3CZVFmaoTUakJsj/QT2itDWoEzRZaffmqJ5z\n' +
+'tCYyXFhwfJinJVwkkOGU5Hv2n8hYNcsRucFC5Y+BUQKEuAtalq3YGoIWWggDPzqb\n' +
+'xGEI46PZS+kt8wGcMau1ArSwv2GuY3P8yjV97uus8Mc+U7XazkAgtlLX95wu9cGL\n' +
+'HrMUCll0SdCwwiQ+yOh/KPvLTOImq8l4h1EUi1EbLREvobpVvwWgwKPixKFSLg/3\n' +
+'KM9WK8P7nuLoJlTTgwXjwOZRWGCaq/m8UkmeMGN3+OBjRnVOdwksvFJSRuHyy24F\n' +
+'9DQHo3Lh+MRrlTq5byYFAYuom4yszxeTm6LS9iXlJNB2mrf1LHPvPlR86oXz8EoI\n' +
+'/sgfYLOUUMtF5779dmeyUFeekW8w09uFt3BfcxWbh+AVraIHkH3iXHwvD5lrx2re\n' +
+'MXP1PHZnzbhEkV01bRL0+keQuS3gd+q723iQnY6NqXPtnaQxBLt6Z0NLBAh6NbR5\n' +
+'CsPRyDnNCYz2/i/3lxe2vGeVAGLgu5U2r8MvKXGMn6off+94jmLGWgWcnqlt/bfg\n' +
+'Ob9hiZEjSAX+NOvnvhcT/J4NYnVoZPqodM+zvgSDMP1CGQ84k4Ubsnvv70wYvFbY\n' +
+'CNqS/TpnK5uDE9vbwFyJhgOTXF+8PZJE3cRfOo9INIo39b9TTE7jPbgSF+k5V3Dd\n' +
+'4t55Xt9GaJAHr3xVViNtOKssbXtnQ73P3dg4pTZkA4E0i0kYZhmR45qXL9989Pbm\n' +
+'lNlirMIj8P4ysX2/MxT2KYcG6IBSHnAzx5raY0xSFUOeAB5q9GheqA==\n' +
+'-----END RSA PRIVATE KEY-----\n',
+            cert: '-----BEGIN CERTIFICATE-----\n' +
+'MIICsDCCAhmgAwIBAgIJANjH3x23QvNtMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV\n' +
+'BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX\n' +
+'aWRnaXRzIFB0eSBMdGQwHhcNMTMwOTEyMDEyMjUzWhcNMjMwOTEwMDEyMjUzWjBF\n' +
+'MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50\n' +
+'ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n' +
+'gQDDPt+Ouup0iECslVxoA9mspIDVtgjph9bAuYmB84K3nz/CTA2E8mJhfDCFUk+v\n' +
+'ipKvD+bnVgR8asql8AutHzaiCr6yOxUfs9gRgJ37TQGmTFpKx5/OegV2t7khq8Uc\n' +
+'Wp7SChZuQ2CZrDjNeZl6K7CFtcbU6yV4tYKsNyNQslSyvwIDAQABo4GnMIGkMB0G\n' +
+'A1UdDgQWBBTn1FqVoBznKu+Vtl5Bspq4PGwxEjB1BgNVHSMEbjBsgBTn1FqVoBzn\n' +
+'Ku+Vtl5Bspq4PGwxEqFJpEcwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUt\n' +
+'U3RhdGUxITAfBgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZIIJANjH3x23\n' +
+'QvNtMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAMw8bTEPx+rlIxTMR\n' +
+'rvZriPeMzlh45vhRyy7JO1C+RnzSVBWUyL/Ca7QbrFcq4nGai2xFnqEEiPKWrP8b\n' +
+'ve1oBz9V18gv6T4oiqOpFmoh2c/IVNr2qE01GdGIos/wb1cYEFRsMLPplbv4PROR\n' +
+'89Yb8/2e/5CzxW4LAMNRqD5GwKE=\n' +
+'-----END CERTIFICATE-----\n'
+        };
+
+        var server = HTTPS.createServer(options, function (req, res) {
+            res.writeHead(200, {
+                'Content-Type': 'text/plain',
+                'Content-Length': 2
+            });
+            res.end('ok');
+        });
+
+        server.listen(0);
+
+        var port = server.address().port;
+
+        var allow = http.request({
+            "host": "localhost",
+            "port": port,
+            "ssl": true,
+            "agent": new HTTPS.Agent({
+                rejectUnauthorized: false
+            })
+        })
+        .then(function (response) {
+            expect(Q.isPromise(response.body)).toBe(false);
+            return response.body.read()
+            .then(function (body) {
+                expect(body.toString("utf-8")).toBe("ok");
+            });
+        });
+
+        var reject = http.request({
+            host: "localhost",
+            port: port,
+            ssl: true,
+            agent: new HTTPS.Agent({
+                rejectUnauthorized: true
+            })
+        }).then(function (response) {
+            // should not be here
+            expect(response).toBeUndefined();
+        }).fail(function(err) {
+            expect(Q.isPromise(err)).toBe(false);
+            expect(err).toEqual(jasmine.any(Error));
+            expect(err.message).toBe('DEPTH_ZERO_SELF_SIGNED_CERT');
+        });
+
+        return Q.all([allow, reject]).finally(function () {
+            server.close();
+        });
+    });
+});

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

@@ -0,0 +1,96 @@
+
+require("../lib/jasmine-promise");
+var Q = require("q");
+var HTTP = require("../../http");
+
+describe("http server and client", function () {
+
+    it("should work as both server and client", function () {
+        var response = {
+            "status": 200,
+            "headers": {
+                "content-type": "text/plain"
+            },
+            "body": [
+                "Hello, World!"
+            ]
+        };
+
+        var server = HTTP.Server(function () {
+            return response;
+        });
+
+        return server.listen(0)
+        .then(function (server) {
+            var port = server.address().port;
+
+            var request = {
+                "host": "localhost",
+                "port": port,
+                "headers": {
+                    "host": "localhost"
+                }
+            };
+
+            return HTTP.request(request)
+            .then(function (response) {
+                expect(Q.isPromise(response.body)).toBe(false);
+                var acc = [];
+                return response.body.read()
+                .then(function (body) {
+                    expect(body.toString("utf-8")).toBe("Hello, World!");
+                });
+            })
+        })
+        .finally(server.stop)
+    });
+
+    it("should defer a response", function () {
+        var response = {
+            "status": 200,
+            "headers": {
+                "content-type": "text/plain; charset=utf-8"
+            },
+            "body": {
+                "forEach": function (write) {
+                    var deferred = Q.defer();
+                    write("Hello, World!");
+                    setTimeout(function () {
+                        deferred.resolve();
+                    }, 100);
+                    return deferred.promise;
+                }
+            }
+        };
+
+        var server = HTTP.Server(function () {
+            return response;
+        });
+
+        return server.listen(0).then(function (server) {
+            var port = server.node.address().port;
+
+            var request = {
+                "host": "localhost",
+                "port": port,
+                "headers": {
+                    "host": "localhost"
+                },
+                "charset": "utf-8"
+            };
+
+            return HTTP.request(request)
+            .then(function (response) {
+                var acc = [];
+                return response.body.read()
+                .then(function (body) {
+                    expect(body).toBe("Hello, World!");
+                });
+            })
+        })
+        .finally(server.stop)
+    });
+
+
+});
+

data/vendor/node_modules/traceur/node_modules/q-io/spec/lib/jasmine-promise.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var Q = require("q");
+
+/**
+ * Modifies the way that individual specs are run to easily test async
+ * code with promises.
+ *
+ * A spec may return a promise. If it does, then the spec passes if and
+ * only if that promise is fulfilled within a very short period of time.
+ * If it is rejected, or if it isn't fulfilled quickly, the spec fails.
+ *
+ * In this way, we can use promise chaining to structure our asynchronous
+ * tests. Expectations all down the chain of promises are all checked and
+ * guaranteed to be run and resolved or the test fails.
+ *
+ * This is a big win over the runs() and watches() code that jasmine
+ * supports out of the box.
+ */
+jasmine.Block.prototype.execute = function (onComplete) {
+    var spec = this.spec;
+    try {
+        var result = this.func.call(spec, onComplete);
+
+        // It seems Jasmine likes to return the suite if you pass it anything.
+        // So make sure it's a promise first.
+        if (result && typeof result.then === "function") {
+            Q.timeout(result, 500).then(function () {
+                onComplete();
+            }, function (error) {
+                spec.fail(error);
+                onComplete();
+            });
+        } else if (this.func.length === 0) {
+            onComplete();
+        }
+    } catch (error) {
+        spec.fail(error);
+        onComplete();
+    }
+};
+

data/vendor/node_modules/traceur/node_modules/q-io/writer.js

@@ -0,0 +1,111 @@
+
+var Q = require("q");
+
+/**
+ * Wraps a Node writable stream, providing an API similar to
+ * Narwhal's synchronous `io` streams, except returning and
+ * accepting promises for long-latency operations.
+ *
+ * @param stream any Node writable stream
+ * @returns {Promise * Writer} a promise for the
+ * text writer.
+ */
+module.exports = Writer;
+
+var version = process.versions.node.split('.');
+var supportsFinish = version[0] >= 0 && version[1] >= 10;
+
+function Writer(_stream, charset) {
+    var self = Object.create(Writer.prototype);
+
+    if (charset && _stream.setEncoding) // TODO complain about inconsistency
+        _stream.setEncoding(charset);
+
+    var drained = Q.defer();
+
+    _stream.on("error", function (reason) {
+        drained.reject(reason);
+        drained = Q.defer();
+    });
+
+    _stream.on("drain", function () {
+        drained.resolve();
+        drained = Q.defer();
+    });
+
+    /***
+     * Writes content to the stream.
+     * @param {String} content
+     * @returns {Promise * Undefined} a promise that will
+     * be resolved when the buffer is empty, meaning
+     * that all of the content has been sent.
+     */
+    self.write = function (content) {
+        if (!_stream.writeable && !_stream.writable)
+            return Q.reject(new Error("Can't write to non-writable (possibly closed) stream"));
+        if (typeof content !== "string") {
+            content = new Buffer(content);
+        }
+        if (!_stream.write(content)) {
+            return drained.promise;
+        } else {
+            return Q.resolve();
+        }
+    };
+
+    /***
+     * Waits for all data to flush on the stream.
+     *
+     * @returns {Promise * Undefined} a promise that will
+     * be resolved when the buffer is empty
+     */
+    self.flush = function () {
+        return drained.promise;
+    };
+
+    /***
+     * Closes the stream, waiting for the internal buffer
+     * to flush.
+     *
+     * @returns {Promise * Undefined} a promise that will
+     * be resolved when the stream has finished writing,
+     * flushing, and closed.
+     */
+    self.close = function () {
+        var finished;
+
+        if (supportsFinish) { // new Streams, listen for `finish` event
+            finished = Q.defer();
+            _stream.on("finish", function () {
+                finished.resolve();
+            });
+            _stream.on("error", function (reason) {
+                finished.reject(reason);
+            });
+        }
+
+        _stream.end();
+        drained.resolve(); // we will get no further drain events
+        if (finished) { // closing not explicitly observable
+            return finished.promise;
+        } else {
+            return Q(); // just resolve for old Streams
+        }
+    };
+
+    /***
+     * Terminates writing on a stream, closing before
+     * the internal buffer drains.
+     *
+     * @returns {Promise * Undefined} a promise that will
+     * be resolved when the stream has finished closing.
+     */
+    self.destroy = function () {
+        _stream.destroy();
+        drained.resolve(); // we will get no further drain events
+        return Q.resolve(); // destruction not explicitly observable
+    };
+
+    return Q(self); // todo returns the begin.promise
+}
+