vulcan 0.6.1 → 0.7.0

data/server/node_modules/cradle/node_modules/request/vendor/cookie/jar.js

@@ -0,0 +1,72 @@
+/*!
+* Tobi - CookieJar
+* Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+* MIT Licensed
+*/
+
+/**
+* Module dependencies.
+*/
+
+var url = require('url');
+
+/**
+* Initialize a new `CookieJar`.
+*
+* @api private
+*/
+
+var CookieJar = exports = module.exports = function CookieJar() {
+  this.cookies = [];
+};
+
+/**
+* Add the given `cookie` to the jar.
+*
+* @param {Cookie} cookie
+* @api private
+*/
+
+CookieJar.prototype.add = function(cookie){
+  this.cookies = this.cookies.filter(function(c){
+    // Avoid duplication (same path, same name)
+    return !(c.name == cookie.name && c.path == cookie.path);
+  });
+  this.cookies.push(cookie);
+};
+
+/**
+* Get cookies for the given `req`.
+*
+* @param {IncomingRequest} req
+* @return {Array}
+* @api private
+*/
+
+CookieJar.prototype.get = function(req){
+  var path = url.parse(req.url).pathname
+    , now = new Date
+    , specificity = {};
+  return this.cookies.filter(function(cookie){
+    if (0 == path.indexOf(cookie.path) && now < cookie.expires
+      && cookie.path.length > (specificity[cookie.name] || 0))
+      return specificity[cookie.name] = cookie.path.length;
+  });
+};
+
+/**
+* Return Cookie string for the given `req`.
+*
+* @param {IncomingRequest} req
+* @return {String}
+* @api private
+*/
+
+CookieJar.prototype.cookieString = function(req){
+  var cookies = this.get(req);
+  if (cookies.length) {
+    return cookies.map(function(cookie){
+      return cookie.name + '=' + cookie.value;
+    }).join('; ');
+  }
+};

data/server/node_modules/cradle/node_modules/vargs/package.json

@@ -1,12 +1,35 @@
 {
-  "name"          : "vargs",
-  "description"   : "practical variable argument handling",
-  "url"           : "http://github.com/cloudhead/vargs",
-  "keywords"      : ["argument", "arguments"],
-  "author"        : "Alexis Sellier <self@cloudhead.net>",
-  "contributors"  : [],
-  "version"       : "0.1.0",
-  "main"          : "./lib/vargs",
-  "directories"   : { "lib": "./lib" },
-  "engines"       : { "node": ">=0.1.93" }
+  "name": "vargs",
+  "description": "practical variable argument handling",
+  "url": "http://github.com/cloudhead/vargs",
+  "keywords": [
+    "argument",
+    "arguments"
+  ],
+  "author": {
+    "name": "Alexis Sellier",
+    "email": "self@cloudhead.net"
+  },
+  "contributors": [],
+  "version": "0.1.0",
+  "main": "./lib/vargs",
+  "directories": {
+    "lib": "./lib"
+  },
+  "engines": {
+    "node": ">=0.1.93"
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "vargs@0.1.0",
+  "dependencies": {},
+  "devDependencies": {},
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "vargs@0.1.0"
 }

data/server/node_modules/cradle/package.json

@@ -1,14 +1,52 @@
 {
-  "name"            : "cradle",
-  "description"     : "the high-level, caching, CouchDB library",
-  "url"             : "http://cloudhead.io/cradle",
-  "keywords"        : ["couchdb", "database", "couch"],
-  "author"          : "Alexis Sellier <self@cloudhead.net>",
-  "contributors"    : [],
-  "dependencies"    : { "vargs": ">=0.1.0" },
-  "devDependencies" : { "async": "0.1.x", "request": "2.2.x", "vows": "0.6.x" },
-  "version"         : "0.5.8",
-  "main"            : "./lib/cradle",
-  "directories"     : { "test": "./test" },
-  "engines"         : { "node": ">=0.3.6" }
+  "name": "cradle",
+  "version": "0.6.3",
+  "description": "the high-level, caching, CouchDB library",
+  "url": "http://cloudhead.io/cradle",
+  "keywords": [
+    "couchdb",
+    "database",
+    "couch"
+  ],
+  "author": {
+    "name": "Alexis Sellier",
+    "email": "self@cloudhead.net"
+  },
+  "contributors": [
+    {
+      "name": "Charlie Robbins",
+      "email": "charlie@nodejitsu.com"
+    },
+    {
+      "name": "Maciej Malecki",
+      "email": "maciej@nodejitsu.com"
+    }
+  ],
+  "main": "./lib/cradle",
+  "dependencies": {
+    "follow": "0.7.x",
+    "request": "2.x.x",
+    "vargs": "0.1.0"
+  },
+  "devDependencies": {
+    "async": "~0.1.x",
+    "vows": "0.6.x"
+  },
+  "scripts": {
+    "test": "node test/helpers/seed.js && vows --spec"
+  },
+  "engines": {
+    "node": ">=0.6.0"
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "cradle@0.6.3",
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "cradle@0.6.x"
 }

data/server/node_modules/cradle/test/cache-test.js

@@ -5,17 +5,15 @@ var path = require('path'),
 
 var cradle = require('../lib/cradle');
 
-vows.describe('cradle/Cache').addBatch({
+vows.describe('cradle/cache').addBatch({
     'A cradle.Connection instance with a *cacheSize* specified': {
         topic: new(cradle.Connection)({ cache: true, cacheSize: 16 }),
-
         'should set the database cache size appropriately': function (topic) {
             assert.equal (topic.database('random').cache.size, 16);
         }
     },
     'A cradle.Cache instance with a *cacheSize* of `8`': {
         topic: new(cradle.Cache)({ cache: true, cacheSize: 8 }),
-
         'should be able to store 8 keys': function (topic) {
             for (var i = 0; i < 8; i++) { topic.save(i.toString(), {}) }
             assert.lengthOf (Object.keys(topic.store), 8);
@@ -76,7 +74,6 @@ vows.describe('cradle/Cache').addBatch({
     },
     'A cradle.Cache instance with a *cacheSize* of *1024*': {
         topic: new(cradle.Cache)({ cache: true, cacheSize: 1024 }),
-
         'setting 4096 keys': {
             topic: function (cache) {
                 var that = this;

data/server/node_modules/cradle/test/connection-test.js

@@ -0,0 +1,179 @@
+var path = require('path'),
+    assert = require('assert'),
+    events = require('events'),
+    http = require('http'),
+    fs = require('fs'),
+    vows = require('vows');
+
+function status(code) {
+    return function (e, res) {
+        assert.ok(res || e);
+        assert.equal((res || e).headers.status || (res || e).status, code);
+    };
+}
+
+var cradle = require('../lib/cradle');
+
+vows.describe('cradle/connection').addBatch({
+    "Default connection settings": {
+        topic: function () {
+            cradle.setup({
+                host: "http://cloudhead.io",
+                port: 4242,
+                milk: 'white'
+            });
+            return new(cradle.Connection);
+        },
+        "should be carried on to new Connections": function (c) {
+            assert.equal(c.host, "cloudhead.io");
+            assert.equal(c.protocol, "http");
+            assert.equal(c.port, 4242);
+            assert.equal(c.options.milk, 'white');
+            assert.equal(c.options.cache, true);
+        },
+        "with just a {} passed to a new Connection object": {
+            topic: function () { return new(cradle.Connection)({milk: 'green'}) },
+            "should override the defaults": function (c) {
+                assert.equal(c.options.milk, 'green');
+                assert.equal(c.port, 4242);
+            }
+        },
+        "with a host and port passed to Connection": {
+            topic: function () { return new(cradle.Connection)("255.255.0.0", 9696) },
+            "should override the defaults": function (c) {
+                assert.equal(c.host, '255.255.0.0');
+                assert.equal(c.port, 9696);
+            }
+        },
+        "with a host, port and options passed to Connection": {
+            topic: function () { return new(cradle.Connection)("4.4.4.4", 911, {raw: true}) },
+            "should override the defaults": function (c) {
+                assert.equal(c.host, '4.4.4.4');
+                assert.equal(c.port, 911);
+                assert.equal(c.options.raw, true);
+            }
+        },
+        "with a host and port and protocol passed to Connection": {
+            topic: function () { return new(cradle.Connection)("http://4.4.4.4", 911, {raw: true, secure: true}) },
+            "should override the defaults": function (c) {
+                assert.equal(c.host, '4.4.4.4');
+                assert.equal(c.port, 911);
+                assert.equal(c.options.raw, true);
+                assert.equal(c.options.secure, true);
+            }
+        },
+        "with a host and port passed as an object to Connection": {
+            topic: function () { return new(cradle.Connection)({ host: "https://4.4.4.4", port: 911, raw: true }) },
+            "should override the defaults": function (c) {
+                assert.equal(c.options.secure, true);
+                assert.equal(c.host, '4.4.4.4');
+                assert.equal(c.port, 911);
+                assert.equal(c.options.raw, true);
+            }
+        },
+        "with a the 'https' protocol": {
+            topic: function () { return new(cradle.Connection)("https://couch.io", 5984) },
+            "should set 'secure' to `true`": function (c) {
+                assert.equal(c.protocol, 'https');
+                assert.equal(c.options.secure, true);
+                assert.equal(c.host, 'couch.io');
+                assert.equal(c.port, 5984);
+            }
+        },
+        "with the port as part of the URL": {
+            topic: function () { return new(cradle.Connection)("https://couch.io:418") },
+            "should read the port from the URL": function (c) {
+                assert.equal(c.protocol, 'https');
+                assert.equal(c.options.secure, true);
+                assert.equal(c.host, 'couch.io');
+                assert.equal(c.port, 418);
+            }
+        }
+    }
+}).addBatch({
+    "Connection": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false});
+        },
+        "getting server info": {
+            topic: function (c) { c.info(this.callback) },
+
+            "returns a 200": status(200),
+            "returns the version number": function (info) {
+                assert.ok(info);
+                assert.match(info.version, /\d+\.\d+\.\d+/);
+            }
+        },
+        "uuids()": {
+            "with count": {
+                topic: function (c) { c.uuids(42, this.callback) },
+
+                "returns a 200": status(200),
+                "returns an array of UUIDs": function (uuids) {
+                    assert.isArray(uuids);
+                    assert.lengthOf(uuids, 42);
+                }
+            },
+            "without count": {
+                topic: function (c) { c.uuids(this.callback) },
+
+                "returns a 200": status(200),
+                "returns an array of UUIDs": function (uuids) {
+                    assert.isArray(uuids);
+                    assert.lengthOf(uuids, 1);
+                }
+            }
+        },
+        "getting the list of databases": {
+            topic: function (c) {
+                c.databases(this.callback);
+            },
+            "should contain the 'rabbits' and 'pigs' databases": function (dbs) {
+                assert.isArray(dbs);
+                assert.include(dbs, 'rabbits');
+                assert.include(dbs, 'pigs');
+            }
+        },
+    }
+}).addBatch({
+    "Connection": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false});
+        },
+        "create()": {
+            "with no / in the name": {
+                topic: function (c) {
+                    c.database('badgers').create(this.callback);
+                },
+                "returns a 201": status(201),
+                "creates a database": {
+                    topic: function (res, c) { c.database('badgers').exists(this.callback) },
+                    "it exists": function (res) { assert.ok(res) }
+                }
+            },
+            "with a / in the name": {
+                topic: function (c) {
+                    c.database('madeup/ewoks').create(this.callback);
+                },
+                "returns a 201": status(201),
+                "creates a database": {
+                    topic: function (res, c) { c.database('madeup/ewoks').exists(this.callback) },
+                    "it exists": function (res) { assert.ok(res) }
+                }
+                
+            }
+        },
+        "destroy()": {
+            topic: function (c) {
+                c.database('rabbits').destroy(this.callback);
+            },
+            "returns a 200": status(200),
+            "destroys a database": {
+                topic: function (res, c) {
+                    c.database('rabbits').exists(this.callback);
+                },
+                "it doesn't exist anymore": function (res) { assert.ok(! res) }
+            }
+        }
+    }
+}).export(module);

data/server/node_modules/cradle/test/database-attachment-test.js

@@ -0,0 +1,344 @@
+var path = require('path'),
+    assert = require('assert'),
+    events = require('events'),
+    http = require('http'),
+    fs = require('fs'),
+    vows = require('vows');
+
+function status(code) {
+    return function (e, res, body) {
+        assert.ok(res || e);
+        assert.equal((res || e).headers.status || (res || e).statusCode, code);
+    };
+}
+
+function mixin(target) {
+    var objs = Array.prototype.slice.call(arguments, 1);
+    objs.forEach(function (o) {
+        for (var attr in o) { target[attr] = o[attr] }
+    });
+    return target;
+}
+
+var cradle = require('../lib/cradle');
+
+vows.describe('cradle/database/attachments').addBatch({
+    "Database with cache": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, { cache: true }).database('pigs');
+        },
+        "saveAttachment()": {
+            "updates the cache": {
+                topic: function (db) {
+                    var that = this;
+                    db.save({ _id: 'attachment-cacher' }, function (e, res) {
+                        db.saveAttachment({
+                            id: res.id, 
+                            rev: res.rev
+                        }, {
+                            name: 'cached/foo.txt', 
+                            'Content-Type': 'text/plain', 
+                            body: 'Foo!'
+                        }, function () {
+                            that.callback(null, db.cache.get(res.id));
+                        });
+                    });
+                },
+                "with the revision": function (cached) {
+                    assert.match(cached._rev, /^2-/);
+                },
+                "with the _attachments": function (cached) {
+                    assert.ok(cached._attachments);
+                    assert.ok(cached._attachments['cached/foo.txt']);
+                    assert.equal(cached._attachments['cached/foo.txt'].stub, true);
+                },
+                "and is valid enough to re-save": {
+                    topic: function (cached, db) {
+                        var that = this
+                        db.save(mixin({ foo: 'bar' }, cached), function (e,res) {
+                            db.cache.purge(cached._id);
+                            db.get(cached._id, that.callback);
+                        });
+                    },
+                    "has the attachment": function (res) {
+                        var att = res._attachments['cached/foo.txt'];
+                        assert.equal(att.stub, true);
+                        assert.equal(att.content_type, 'text/plain');
+                        assert.equal(att.length, 4);
+                        assert.equal(att.revpos, 2);
+                    },
+                    "and actually updated the rev": function (res) {
+                        assert.match(res._rev, /^3-/);
+                    }
+                }
+            },
+            "pulls the revision from the cache if not given": {
+                topic: function (db) {
+                    var callback = this.callback;
+                    db.save({ _id: 'attachment-saving-pulls-rev-from-cache' }, function (e, res) {
+                        db.saveAttachment(res.id, {
+                            name: 'foo.txt', 
+                            contentType: 'text/plain', 
+                            body: 'Foo!'
+                        }, callback);
+                    });
+                },
+                "and saves successfully": status(201)
+            }
+        }
+    }
+}).addBatch({
+    "Database with no cache": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "putting an attachment": {
+            "to an existing document": {
+                "with given data": {
+                    topic: function (db) {
+                        var that = this;
+                        db.save({_id: 'complete-attachment'}, function (e, res) {
+                            db.saveAttachment({
+                                id: res.id, 
+                                rev: res.rev
+                            }, {
+                                name: 'foo.txt', 
+                                'content-type': 'text/plain', 
+                                body: 'Foo!'
+                            }, that.callback);
+                        });
+                    },
+                    "returns a 201": status(201),
+                    "returns the revision": function (res) {
+                        assert.ok(res.rev);
+                        assert.match(res.rev, /^2/);
+                    },
+                },
+                "when piping": {
+                    topic: function (db) {
+                        var callback = this.callback, filestream;
+                        db.save({ _id: 'piped-attachment' }, function (e, res) {
+                            var stream = db.saveAttachment({
+                                id: res.id, 
+                                rev: res.rev
+                            }, {
+                                name: 'foo.txt', 
+                                contentType: 'text/plain'
+                            }, callback);
+                            
+                            fs.createReadStream(__dirname + "/../README.md").pipe(stream);
+                        });
+                    },
+                    "returns a 201": status(201),
+                    "returns the revision": function (res) {
+                        assert.ok(res.rev);
+                        assert.match(res.rev, /^2/);
+                    }
+                },
+                "with incorrect revision": {
+                    topic: function (db) {
+                        var callback = this.callback, oldRev;
+                        db.save({ _id: 'attachment-incorrect-revision' }, function (e, res) {
+                            oldRev = res.rev;
+                            db.save({_id: 'attachment-incorrect-revision', _rev:res.rev}, function (e, res) {
+                                db.saveAttachment({
+                                    id: res.id, 
+                                    rev: oldRev
+                                }, {
+                                    name: 'foo.txt', 
+                                    contentType: 'text/plain', 
+                                    body: 'Foo!'
+                                }, callback);
+                            });
+                        });
+                    },
+                    "returns a 409": status(409)
+                }
+            },
+            "to a non-existing document": {
+                topic: function (db) {
+                    db.saveAttachment('standalone-attachment', {
+                        name: 'foo.txt', 
+                        contentType: 'text/plain', 
+                        body: 'Foo!'
+                    }, this.callback);
+                },
+                "returns a 201": status(201),
+                "returns the revision": function (res) {
+                    assert.ok(res.rev);
+                    assert.match(res.rev, /^1-/);
+                }
+            }
+        },
+        "getting an attachment": {
+            "when it exists": {
+                topic: function (db) {
+                    var that = this, doc = {
+                        _id: 'attachment-getter', 
+                        _attachments: { 
+                            "foo.txt": {
+                                content_type: "text/plain", 
+                                data: "aGVsbG8gd29ybGQ="
+                            }
+                        }
+                    };
+                    
+                    db.save(doc, function (e, res) {
+                        db.getAttachment('attachment-getter', 'foo.txt', that.callback);
+                    });
+                },
+                "returns a 200": status(200),
+                "returns the right mime-type in the header": function (err, res, body) {
+                    assert.equal(res.headers['content-type'], 'text/plain');
+                },
+                "returns the attachment in the body": function (err, res, body) {
+                    assert.equal(body, "hello world");
+                }
+            },
+            "when not found": {
+                topic: function (db) {
+                    var that = this;
+                    db.save({ _id: 'attachment-not-found' }, function (e, res) {
+                        db.getAttachment('attachment-not-found', 'foo.txt', that.callback);
+                    });
+                },
+                "returns a 404": status(404)
+            }
+        }
+    }
+}).addBatch({
+    "Database with no cache": {
+        topic: function () {
+           return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "saving an attachment with ETag": {
+            topic: function (db) {
+                var id = 'attachment-incorrect-revision',
+                    that = this;
+                
+                db.head('attachment-incorrect-revision', function (err, _doc) {
+                  db.saveAttachment({
+                      id: id, 
+                      rev: _doc.etag,
+                    }, {
+                       name: 'etag-foo.txt',
+                       contentType: 'text/plain',
+                       body: 'FOOO!!' 
+                    }, that.callback);
+                });
+            },
+            "returns a 201": status(201),
+            "returns the revision": function (res) {
+                assert.ok(res.rev);
+                assert.match(res.rev, /^3/);
+            }
+        }
+    }
+}).addBatch({
+    "Database with no cache": {
+        topic: function () {
+           return new(cradle.Connection)('127.0.0.1', 5984, {cache: false}).database('pigs');
+        },
+        "getting an attachment with .pipe()": {
+            "when it exists": {
+                topic: function (db) {
+                    var stream = db.getAttachment('piped-attachment', 'foo.txt', this.callback);
+                    stream.pipe(fs.createWriteStream(path.join(__dirname, 'fixtures', 'README.md')));
+                },
+                "returns a 200": status(200),
+                "returns the right mime-type in the header": function (err, res, body) {
+                    assert.equal(res.headers['content-type'], 'text/plain');
+                },
+                "should write the correct attachment to disk": function (err, res, body) {
+                    assert.isNull(err);
+                    
+                    assert.equal(
+                        fs.readFileSync(path.join(__dirname, '..', 'README.md'), 'utf8'),
+                        fs.readFileSync(path.join(__dirname, 'fixtures', 'README.md'), 'utf8')
+                    );
+                }
+            },
+            "when not found": {
+                topic: function (db) {
+                    var stream = db.getAttachment('attachment-not-found', 'foo.txt');
+                    stream.pipe(fs.createWriteStream(path.join(__dirname, 'fixtures', 'not-found.txt')));
+                    
+                    stream.on('end', this.callback);
+                },
+                "should write the error to disk": function () {
+                    var result = JSON.parse(
+                        fs.readFileSync(path.join(__dirname, 'fixtures', 'not-found.txt'), 'utf8')
+                    );
+                    
+                    assert.equal(result.reason, 'Document is missing attachment');
+                }
+            }
+        }
+    }
+}).addBatch({
+    "Database with no cache": {
+        topic: function () {
+           return new(cradle.Connection)('127.0.0.1', 5984, { cache: false }).database('pigs');
+        },
+        "removeAttachment()": {
+            "when it exists": {
+                topic: function (db) {
+                    var that = this;
+                    db.get('attachment-getter', function (err, doc) {
+                        db.removeAttachment(doc, 'foo.txt', that.callback);
+                    });
+                },
+                "should remove the attachment": function (err, res) {
+                    assert.isNull(err);
+                    assert.ok(res.ok);
+                }
+            },
+            "when the document doesnt exist": {
+                topic: function (db) {
+                    db.removeAttachment({
+                        id: 'YUNOEXIST',
+                        rev: '2-6bb732ce2ecc7ac85567b444b10590b4'
+                    }, 'foo.txt', this.callback.bind(this, null));
+                },
+                "should respond with the correct error": function (_, err) {
+                    assert.isObject(err);
+                    assert.equal(err.headers.status, 500);
+                    assert.equal(err.error, '{not_found,missing}');
+                }
+            }
+        }
+    }
+}).addBatch({
+    "Database with cache": {
+        topic: function () {
+            return new(cradle.Connection)('127.0.0.1', 5984, { cache: true }).database('pigs');
+        },
+        "removeAttachment()": {
+            "when it exists": {
+                topic: function (db) {
+                    var that = this;
+                    db.get('attachment-cacher', function (err, doc) {
+                        db.removeAttachment(doc._id, 'cached/foo.txt', that.callback);
+                    });
+                },
+                "should remove the attachment": function (err, res) {
+                    assert.isNull(err);
+                    assert.ok(res.ok);
+                }
+            },
+            "when the document doesnt exist": {
+                topic: function (db) {
+                    db.removeAttachment({
+                        id: 'YUNOEXIST',
+                        rev: '2-6bb732ce2ecc7ac85567b444b10590b4'
+                    }, 'foo.txt', this.callback.bind(this, null));
+                },
+                "should respond with the correct error": function (_, err) {
+                    assert.isObject(err);
+                    assert.equal(err.headers.status, 500);
+                    assert.equal(err.error, '{not_found,missing}');
+                }
+            }
+        }
+    }
+}).export(module);