vulcan 0.6.1 → 0.7.0

data/server/node_modules/connect-form/node_modules/formidable/lib/incoming_form.js

@@ -247,6 +247,7 @@ IncomingForm.prototype._parseContentLength = function() {
   if (this.headers['content-length']) {
     this.bytesReceived = 0;
     this.bytesExpected = parseInt(this.headers['content-length'], 10);
+    this.emit('progress', this.bytesReceived, this.bytesExpected);
   }
 };
 
@@ -359,7 +360,10 @@ IncomingForm.prototype._uploadPath = function(filename) {
   }
 
   if (this.keepExtensions) {
-    name += path.extname(filename);
+    var ext = path.extname(filename);
+    ext     = ext.replace(/(\.[a-z0-9]+).*/, '$1')
+
+    name += ext;
   }
 
   return path.join(this.uploadDir, name);

data/server/node_modules/connect-form/node_modules/formidable/package.json

@@ -1,19 +1,33 @@
 {
   "name": "formidable",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "dependencies": {},
   "devDependencies": {
     "gently": "0.8.0",
-    "far": "0.0.7",
-    "fast-or-slow": "0.0.5",
     "findit": "0.1.1",
-    "hashish": "0.0.4"
+    "hashish": "0.0.4",
+    "urun": "0.0.4",
+    "utest": "0.0.3"
   },
   "directories": {
     "lib": "./lib"
   },
   "main": "./lib/index",
+  "scripts": {
+    "test": "make test"
+  },
   "engines": {
     "node": "*"
-  }
-}
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "formidable@1.0.9",
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "formidable@>= 0.9.3"
+}

data/server/node_modules/connect-form/node_modules/formidable/test/common.js

@@ -3,17 +3,16 @@ var path = require('path');
 
 var root = path.join(__dirname, '../');
 exports.dir = {
-  root: root,
-  lib: root + '/lib',
-  fixture: root + '/test/fixture',
-  tmp: root + '/test/tmp',
+  root    : root,
+  lib     : root + '/lib',
+  fixture : root + '/test/fixture',
+  tmp     : root + '/test/tmp',
 };
 
 exports.port = 13532;
 
 exports.formidable = require('..');
-exports.fastOrSlow = require('fast-or-slow');
-exports.assert = require('assert');
+exports.assert     = require('assert');
 
 exports.require = function(lib) {
   return require(exports.dir.lib + '/' + lib);

data/server/node_modules/connect-form/node_modules/formidable/test/fixture/file/funkyfilename.txt

@@ -0,0 +1 @@
+I am a text file with a funky name!

data/server/node_modules/connect-form/node_modules/formidable/test/fixture/js/special-chars-in-filename.js

@@ -1,4 +1,4 @@
-var properFilename = '/ \\ ? % * | " < > . ☃ ; \' @ # $ ^ & ( ) - _ = + { } [ ] ` ~.txt';
+var properFilename = 'funkyfilename.txt';
 
 function expect(filename) {
   return [

data/server/node_modules/connect-form/node_modules/formidable/test/{slow → integration}/test-fixtures.js

@@ -7,47 +7,52 @@ var net = require('net');
 var assert = require('assert');
 
 var common = require('../common');
-var test = common.fastOrSlow.slow();
 var formidable = common.formidable;
 
-var server;
-test.before(function(done) {
-  if (server) return done();
+var server = http.createServer();
+server.listen(common.port, findFixtures);
 
-  server = http.createServer();
-  server.listen(common.port, done);
-});
+function findFixtures() {
+  var fixtures = [];
+  findit
+    .sync(common.dir.fixture + '/js')
+    .forEach(function(jsPath) {
+      if (!/\.js$/.test(jsPath)) return;
 
-findit
-  .sync(common.dir.fixture + '/js')
-  .forEach(function(jsPath) {
-    if (!/\.js$/.test(jsPath)) return;
-
-    var group = path.basename(jsPath, '.js');
-    hashish.forEach(require(jsPath), function(fixture, name) {
-      addTest(group + '/' + name, fixture);
+      var group = path.basename(jsPath, '.js');
+      hashish.forEach(require(jsPath), function(fixture, name) {
+        fixtures.push({
+          name    : group + '/' + name,
+          fixture : fixture,
+        });
+      });
     });
-  });
 
-function addTest(name, fixture) {
-  test('fixture: ' + name, function(done) {
-    console.error(this.name);
-    uploadFixture(name, function(err, parts) {
-      if (err) return done(err);
-
-      fixture.forEach(function(expectedPart, i) {
-        var parsedPart = parts[i];
-        assert.equal(parsedPart.type, expectedPart.type);
-        assert.equal(parsedPart.name, expectedPart.name);
-
-        if (parsedPart.type === 'file') {
-          var filename = parsedPart.value.name;
-          assert.equal(filename, expectedPart.filename);
-        }
-      });
+  testNext(fixtures);
+}
 
-      done();
+function testNext(fixtures) {
+  var fixture = fixtures.shift();
+  if (!fixture) return server.close();
+
+  var name    = fixture.name;
+  var fixture = fixture.fixture;
+
+  uploadFixture(name, function(err, parts) {
+    if (err) throw err;
+
+    fixture.forEach(function(expectedPart, i) {
+      var parsedPart = parts[i];
+      assert.equal(parsedPart.type, expectedPart.type);
+      assert.equal(parsedPart.name, expectedPart.name);
+
+      if (parsedPart.type === 'file') {
+        var filename = parsedPart.value.name;
+        assert.equal(filename, expectedPart.filename);
+      }
     });
+
+    testNext(fixtures);
   });
 };
 

data/server/node_modules/connect-form/node_modules/formidable/test/legacy/simple/test-incoming-form.js

@@ -372,15 +372,26 @@ test(function parseContentLength() {
 
   form.headers = {};
   form._parseContentLength();
+  assert.strictEqual(form.bytesReceived, null);
   assert.strictEqual(form.bytesExpected, null);
 
   form.headers['content-length'] = '8';
+  gently.expect(form, 'emit', function(event, bytesReceived, bytesExpected) {
+    assert.equal(event, 'progress');
+    assert.equal(bytesReceived, 0);
+    assert.equal(bytesExpected, 8);
+  });
   form._parseContentLength();
   assert.strictEqual(form.bytesReceived, 0);
   assert.strictEqual(form.bytesExpected, 8);
 
   // JS can be evil, lets make sure we are not
   form.headers['content-length'] = '08';
+  gently.expect(form, 'emit', function(event, bytesReceived, bytesExpected) {
+    assert.equal(event, 'progress');
+    assert.equal(bytesReceived, 0);
+    assert.equal(bytesExpected, 8);
+  });
   form._parseContentLength();
   assert.strictEqual(form.bytesExpected, 8);
 });

data/server/node_modules/connect-form/node_modules/formidable/test/run.js

@@ -1,7 +1,2 @@
 #!/usr/bin/env node
-var far = require('far').create();
-
-far.add(__dirname);
-far.include(/test-.*\.js$/);
-
-far.execute();
+require('urun')(__dirname)

data/server/node_modules/connect-form/node_modules/formidable/test/unit/test-incoming-form.js

@@ -0,0 +1,63 @@
+var common       = require('../common');
+var test         = require('utest');
+var assert       = common.assert;
+var IncomingForm = common.require('incoming_form').IncomingForm;
+var path         = require('path');
+
+var from;
+test('IncomingForm', {
+  before: function() {
+    form = new IncomingForm();
+  },
+
+  '#_fileName with regular characters': function() {
+    var filename = 'foo.txt';
+    assert.equal(form._fileName(makeHeader(filename)), 'foo.txt');
+  },
+
+  '#_fileName with unescaped quote': function() {
+    var filename = 'my".txt';
+    assert.equal(form._fileName(makeHeader(filename)), 'my".txt');
+  },
+
+  '#_fileName with escaped quote': function() {
+    var filename = 'my%22.txt';
+    assert.equal(form._fileName(makeHeader(filename)), 'my".txt');
+  },
+
+  '#_fileName with bad quote and additional sub-header': function() {
+    var filename = 'my".txt';
+    var header = makeHeader(filename) + '; foo="bar"';
+    assert.equal(form._fileName(header), filename);
+  },
+
+  '#_fileName with semicolon': function() {
+    var filename = 'my;.txt';
+    assert.equal(form._fileName(makeHeader(filename)), 'my;.txt');
+  },
+
+  '#_fileName with utf8 character': function() {
+    var filename = 'my☃.txt';
+    assert.equal(form._fileName(makeHeader(filename)), 'my☃.txt');
+  },
+
+  '#_uploadPath strips harmful characters from extension when keepExtensions': function() {
+    form.keepExtensions = true;
+
+    var ext = path.extname(form._uploadPath('fine.jpg?foo=bar'));
+    assert.equal(ext, '.jpg');
+
+    var ext = path.extname(form._uploadPath('fine?foo=bar'));
+    assert.equal(ext, '');
+
+    var ext = path.extname(form._uploadPath('super.cr2+dsad'));
+    assert.equal(ext, '.cr2');
+
+    var ext = path.extname(form._uploadPath('super.bar'));
+    assert.equal(ext, '.bar');
+  },
+});
+
+function makeHeader(filename) {
+  return 'Content-Disposition: form-data; name="upload"; filename="' + filename + '"';
+}

data/server/node_modules/connect-form/package.json

@@ -1,9 +1,31 @@
 {
   "name": "connect-form",
   "description": "urlencoded / multipart form parsing middleware for Connect",
-  "version": "0.2.1",
-  "author": "TJ Holowaychuk <tj@vision-media.ca>",
-  "dependencies": { "formidable": ">= 0.9.3" },
+  "version": "0.2.0",
+  "author": {
+    "name": "TJ Holowaychuk",
+    "email": "tj@vision-media.ca"
+  },
+  "dependencies": {
+    "formidable": ">= 0.9.3"
+  },
   "main": "./index.js",
-  "engines": { "node": ">= 0.1.98" }
-}
+  "engines": {
+    "node": ">= 0.1.98"
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "connect-form@0.2.0",
+  "devDependencies": {},
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "dist": {
+    "shasum": "bb11f2830116945b27bf4aaa840f7d3d11521b76"
+  },
+  "_from": "connect-form@0.2.0"
+}

data/server/node_modules/cradle/README.md

@@ -112,7 +112,7 @@ You can check if a database exists with the `exists()` method.
 
 ``` js
   db.get('vader', function (err, doc) {
-      sys.puts(doc);
+      console.log(doc);
   });
 ```
 
@@ -129,8 +129,7 @@ Cradle is also able to fetch multiple documents if you have a list of ids, just
 ``` js
   db.view('characters/all', function (err, res) {
       res.forEach(function (row) {
-          sys.puts(row.name + " is on the " +
-                   row.force + " side of the force.");
+          console.log("%s is on the %s side of the force.", row.name, row.force);
       });
   });
 ```
@@ -331,18 +330,17 @@ the affected documents, simply pass `include_docs: true` in the options.
 
 ### Streaming #
 
-You can also *stream* changes, by calling `db.changes` without the callback:
+You can also *stream* changes, by calling `db.changes` without the callback. This API uses the **excellent** [follow][0] library from [IrisCouch][1]:
 
 ``` js
-  db.changes({ since: 42 }).on('response', function (res) {
-      res.on('data', function (change) {
-          console.log(change);
-      });
-      res.on('end', function () { ... });
+  var feed = db.changes({ since: 42 });
+  
+  feed.on('change', function (change) {
+      console.log(change);
   });
 ```
 
-In this case, it returns an `EventEmitter`, which behaves very similarly to node's `Stream` API.
+In this case, it returns an instance of `follow.Feed`, which behaves very similarly to node's `EventEmitter` API. For full documentation on the options available to you when monitoring CouchDB with `.changes()` see the [follow documentation][0].
 
 
 Other API methods
@@ -375,3 +373,5 @@ Other API methods
 - `viewCleanup()`: Cleanup old view data
 - `replicate(target, options)`: Replicate this database to `target`.
 
+[0]: https://github.com/iriscouch/follow
+[1]: http://iriscouch.com

data/server/node_modules/cradle/lib/cradle.js

@@ -1,19 +1,18 @@
-var path = require('path'),
-    http = require("http"),
-   https = require("https"),
-  events = require('events'),
-      fs = require("fs"),
-     url = require('url'),
-  buffer = require('buffer');
-
-var querystring = require('querystring');
-var Args = require('vargs').Constructor;
+var events = require('events'),
+    fs = require('fs'),
+    path = require('path'),
+    url = require('url'),
+    http = require('http'),
+    https = require('https'),
+    querystring = require('querystring'),
+    request = require('request');
 
 var cradle = exports;
 
 cradle.extend   = require('./cradle/response').extend;
 cradle.Response = require('./cradle/response').Response;
 cradle.Cache    = require('./cradle/cache').Cache;
+cradle.Database = require('./cradle/database').Database;
 
 cradle.host = '127.0.0.1';
 cradle.port = 5984;
@@ -29,7 +28,7 @@ cradle.options = {
 cradle.setup = function (settings) {
     this.host = settings.host;
     this.auth = settings.auth;
-    this.port = parseInt(settings.port);
+    this.port = parseInt(settings.port, 10);
     cradle.merge(this.options, settings);
 
     return this;
@@ -39,7 +38,12 @@ var protocolPattern = /^(https?):\/\//;
 
 cradle.Connection = function Connection(/* variable args */) {
     var args = Array.prototype.slice.call(arguments),
-        host, port, remote, auth, options = {};
+        options = {},
+        remote,
+        match,
+        host, 
+        port, 
+        auth;
 
     args.forEach(function (a) {
         if (typeof(a) === 'number' || (typeof(a) === 'string' && /^\d{2,5}$/.test(a))) {
@@ -51,6 +55,11 @@ cradle.Connection = function Connection(/* variable args */) {
             auth = options.auth;
         } else {
             host = a;
+            
+            if (match = host.match(/^(.+)\:(\d{2,5})$/)) {
+                host = match[1];
+                port = parseInt(match[2]);
+            }
         }
     });
 
@@ -76,8 +85,8 @@ cradle.Connection = function Connection(/* variable args */) {
         console.log('Warning: "ssl" option is deprecated. Use "secure" instead.');
     }
 
-    this.socket = (this.options.secure) ? https : http;
-    this.agent = new (this.socket.Agent)({
+    this.transport = (this.options.secure) ? https : http;
+    this.agent = new (this.transport.Agent)({
         host: this.host,
         port: this.port
     });
@@ -93,85 +102,41 @@ cradle.Connection = function Connection(/* variable args */) {
 //      JSON serialization and does not presuppose it is sending or receiving JSON
 //      content
 //
-cradle.Connection.prototype.rawRequest = function (method, path, options, data, headers) {
-    var promise = new(events.EventEmitter), request, that = this;
+// OLDAPI: function (method, path, options, data, headers)
+// 
+cradle.Connection.prototype.rawRequest = function (options, callback) {
+    var promise = new(events.EventEmitter), 
+        self = this;
 
     // HTTP Headers
-    headers = headers || {};
+    options.headers = options.headers || {};
 
     // Set HTTP Basic Auth
     if (this.auth) {
-        headers['Authorization'] = "Basic " + new Buffer(this.auth.username + ':' + this.auth.password).toString('base64');
+        options.headers['Authorization'] = "Basic " + new Buffer(this.auth.username + ':' + this.auth.password).toString('base64');
     }
 
     // Set client-wide headers
-    for (var h in this.options.headers) {
-        headers[h] = this.options.headers[h];
-    }
-
-    path = (path || '/').replace(/https?:\/\//, '').replace(/\/{2,}/g, '/');
-    if (path.charAt(0) !== '/') { path = '/' + path }
-
-    if (options && Object.keys(options).length) {
-        for (var k in options) {
-            if (typeof(options[k]) === 'boolean') {
-                options[k] = String(options[k]);
+    Object.keys(this.options.headers).forEach(function (header) {
+        options.headers[header] = self.options.headers[header];
+    });
+            
+    if (options.query && Object.keys(options.query).length) {
+        for (var k in options.query) {
+            if (typeof(options.query[k]) === 'boolean') {
+                options.query[k] = String(options.query[k]);
             }
         }
-        path += '?' + querystring.stringify(options);
+        options.path += '?' + querystring.stringify(options.query);
     }
 
-    //
-    // ** Remark (indexzero): ** Keep-alive is causing unexpected hangups in tests
-    // removing it temporarily as we move forward towards a `request` based implementation. 
-    //
-    // if (headers['Connection'] === undefined) {
-    //     // Keep the connection alive but set timeout to close the socket after 5 seconds of inactivity
-    //     headers['Connection'] = 'keep-alive';
-    //     if (this.connectionTimeout !== undefined) {
-    //       clearTimeout(this.connectionTimeout);
-    //     }
-    //     this.connectionTimeout = setTimeout(function () {
-    //       that.close();
-    //     }, 5000);
-    // }
-    
-    request = this.socket.request({
-        agent:   this.agent,
-        host:    this.host,
-        port:    this.port,
-        method:  method.toUpperCase(),
-        path:    path,
-        headers: headers
-    });
-
-    if (data && data.on) { headers['Transfer-Encoding'] = 'chunked' }
-
-    request.on('response', function (res) {
-        promise.emit('response', res);
-        res.on('data', function (chunk) { promise.emit('data', chunk) });
-        res.on('end',  function () { promise.emit('end') });
-    });
-    request.on('error', function (err) {
-        promise.emit('error', err);
-        promise.emit('end');
-    });
-
+    options.headers['Connection'] = options.headers['Connection'] || 'keep-alive';
+    options.agent = this.agent;
+    options.uri = this._url(options.path);
+    delete options.path;
 
-    if (data) {
-        if (data.on) {
-            data.on('data', function (chunk) { request.write(chunk) });
-            data.on('end', function () { request.end() });
-        } else {
-            request.write(data, 'utf8');
-            request.end();
-        }
-    } else {
-        request.end();
-    }
-
-    return promise;
-}
+    return request(options, callback || function () { });
+};
 
 //
 // Connection.close()
@@ -190,74 +155,50 @@ cradle.Connection.prototype.close = function () {
 //      This is the entry point for all requests to CouchDB, at this point,
 //      the database name has been embed in the url, by one of the wrappers.
 //
-cradle.Connection.prototype.request = function (method, path, /* [options], [data], [headers] */ callback) {
-    var request, that = this, args = Array.prototype.slice.call(arguments, 2);
-
-    if (typeof(callback = args.pop()) !== 'function') {
-        args.push(callback);
-        callback = function () {};
-    }
-
-    var options = args.shift() || {},
-        data    = args.shift() || null,
-        headers = cradle.merge({ host: this.host }, args.shift() || {});
+cradle.Connection.prototype.request = function (options, callback) {
+    var headers = cradle.merge({ host: this.host }, options.headers || {}),
+        self = this;
 
+    // HTTP Headers
+    options.headers = options.headers || {};
+    
     //
     // Handle POST/PUT data. We also convert functions to strings,
     // so they can be used in _design documents.
     //
-    if (data) {
-        data = JSON.stringify(data, function (k, val) {
+    if (options.body) {
+        options.body = JSON.stringify(options.body, function (k, val) {
             if (typeof(val) === 'function') {
                 return val.toString();
             } else { return val }
         });
-        headers["Content-Length"] = Buffer.byteLength(data);
-        headers["Content-Type"]   = "application/json";
-    }
-
-    if (typeof headers["Content-Length"] === 'undefined') {
-        headers["Content-Length"] = 0;
+        options.headers["Content-Length"] = Buffer.byteLength(options.body);
+        options.headers["Content-Type"]   = "application/json";
     }
 
-    request = this.rawRequest(method, path, options, data, headers);
-
-    //
-    // Initialize the request, send the body, and finally,
-    // dispatch the request.
-    //
-    request.on('response', function (res) {
-        var body = [];
-
-        res.setEncoding('utf8');
-        res.on('data', function (chunk) {
-            chunk && body.push(chunk);
-        }).on('end', function () {
-            var json, response;
-
-            if (method === 'HEAD') {
-                callback(null, res.headers, res.statusCode);
-            } else {
-                try { json = JSON.parse(body.join('')) }
-                catch (e) { return callback(e) }
-
-
-                if (json.error) {
-                    cradle.extend(json, { headers: res.headers });
-                    json.headers.status = res.statusCode;
-                    callback(json);
-                } else {
-                    // If the `raw` option was set, we return the parsed
-                    // body as-is. If not, we wrap it in a `Response` object.
-                    callback(null, that.options.raw ? json : new(cradle.Response)(json, res));
-                }
-            }
-        }).on('error', function (err) {
-            return callback(err);
-        });
-    });
-    request.on('error', function (err) {
-        return callback(err);
+    return this.rawRequest(options, function (err, res, body) {
+        if (err) {
+          return callback(err);
+        }
+        else if (options.method === 'HEAD') {
+          return callback(null, res.headers, res.statusCode);
+        }
+        else if (body && body.error) {
+          cradle.extend(body, { headers: res.headers });
+          body.headers.status = res.statusCode;
+          return callback(body);
+        }
+      
+        try { body = JSON.parse(body) }
+        catch (err) { }
+      
+        if (body && body.error) {
+            cradle.extend(body, { headers: res.headers });
+            body.headers.status = res.statusCode;
+            return callback(body);
+        }
+      
+        callback(null, self.options.raw ? body : new cradle.Response(body, res));
     });
 };
 
@@ -268,406 +209,59 @@ cradle.Connection.prototype.request = function (method, path, /* [options], [dat
 //      closing around the `name` argument.
 //
 cradle.Connection.prototype.database = function (name) {
-    var that = this, connection = this;
-
-    return {
-        name: encodeURIComponent(name),
-        //
-        // The database document cache.
-        //
-        cache: new(cradle.Cache)(that.options),
-
-        // A wrapper around `Connection.request`,
-        // which prepends the database name.
-        query: function (method, path /* [options], [data], [headers], [callback] */) {
-            var args = Array.prototype.slice.call(arguments, 2);
-            that.request.apply(that, [method, [name, path].join('/')].concat(args));
-        },
-        exists: function (callback) {
-            this.query('HEAD', '', function (err, res, status) {
-                if (err) {
-                    callback(err);
-                } else {
-                    if (status === 404) {
-                        callback(null, false);
-                    } else {
-                        callback(null, true);
-                    }
-                }
-            });
-        },
-
-        // Fetch either a single document from the database, or cache,
-        // or multiple documents from the database.
-        // If it's a single doc from the db, attempt to save it to the cache.
-        get: function (id, rev) {
-            var that = this, options = null,
-                args = new(Args)(arguments);
-
-            if (Array.isArray(id)) { // Bulk GET
-                this.query('POST', '/_all_docs', { include_docs: true }, { keys: id },
-                           function (err, res) { args.callback(err, res) });
-            } else {
-                if (rev && args.length === 2) {
-                    if      (typeof(rev) === 'string') { options = { rev: rev } }
-                    else if (typeof(rev) === 'object') { options = rev }
-                } else if (this.cache.has(id)) {
-                    return args.callback(null, this.cache.get(id));
-                }
-                this.query('GET', cradle.escape(id), options, function (err, res) {
-                    if (! err) that.cache.save(res.id, res.json);
-                    args.callback(err, res);
-                });
-            }
-        },
-
-        save: function (/* [id], [rev], doc | [doc, ...] */) {
-            var args = new(Args)(arguments),
-                array = args.all.slice(0), doc, id, rev;
-
-            if (Array.isArray(args.first)) {
-                doc = args.first;
-            } else {
-                doc = array.pop(),
-                id  = array.shift(),
-                rev = array.shift();
-            }
-            this._save(id, rev, doc, args.callback);
-        },
-       _save: function (id, rev, doc, callback) {
-            var options = connection.options;
-            var document = {}, that = this;
-
-            // Bulk Insert
-            if (Array.isArray(doc)) {
-                document.docs = doc;
-                if (options.allOrNothing) { document.all_or_nothing = true }
-                this.query('POST', '/_bulk_docs', {}, document, callback);
-            } else {
-                // PUT a single document, with an id (Create or Update)
-                if (id) {
-                    // Design document
-                    if (/^_design\/(\w|%|\-)+$/.test(id) && !('views' in doc)) {
-                        document.language = "javascript";
-                        document.views    =  doc;
-                    } else {
-                        document = doc;
-                    }
-                    // Try to set the '_rev' attribute of the document.
-                    // If it wasn't passed, attempt to retrieve it from the cache.
-                    rev && (document._rev = rev);
-
-                    if (document._rev) {
-                        this.put(id, document, callback);
-                    } else if (this.cache.has(id)) {
-                        document._rev = this.cache.get(id)._rev;
-                        this.put(id, document, callback);
-                    } else {
-                        // Attempt to create a new document. If it fails,
-                        // because an existing document with that _id exists (409),
-                        // perform a HEAD, to get the _rev, and try to re-save.
-                        this.put(id, document, function (e, res) {
-                            if (e && e.headers && e.headers.status === 409) { // Conflict
-                                that.head(id, function (e, headers, res) {
-                                    if (res === 404 || !headers['etag']) {
-                                        return callback({ reason: 'not_found' });
-                                    }
-
-                                    document._rev = headers['etag'].slice(1, -1);
-                                    that.put(id, document, callback);
-                                });
-                            } else { callback(e, res) }
-                        });
-                    }
-                // POST a single document, without an id (Create)
-                } else {
-                    this.post(doc, callback);
-                }
-            }
-        },
-
-        merge: function (/* [id], doc */) {
-            var args     = Array.prototype.slice.call(arguments),
-                callback = args.pop(),
-                doc      = args.pop(),
-                id       = args.pop() || doc._id;
-
-            this._merge(id, doc, callback);
-        },
-       _merge: function (id, doc, callback) {
-            var that = this;
-            this.get(id, function (e, res) {
-                if (e) { return callback(e) }
-                doc = cradle.merge({}, res.json || res, doc);
-                that.save(id, res._rev, doc, callback);
-            });
-        },
-
-        //
-        // PUT a document, and write through cache
-        //
-        put: function (id, doc, callback) {
-            var cache = this.cache;
-            if (typeof(id) !== 'string') { throw new(TypeError)("id must be a string") }
-            this.query('PUT', cradle.escape(id), null, doc, function (e, res) {
-                if (! e) { cache.save(id, cradle.merge({}, doc, { _id: id, _rev: res.rev })) }
-                callback && callback(e, res);
-            });
-        },
-
-        //
-        // POST a document, and write through cache
-        //
-        post: function (doc, callback) {
-            var cache = this.cache;
-            this.query('POST', '/', null, doc, function (e, res) {
-                if (! e) { cache.save(res.id, cradle.merge({}, doc, { _id: res.id, _rev: res.rev })) }
-                callback && callback(e, res);
-            });
-        },
-
-        //
-        // Perform a HEAD request
-        //
-        head: function (id, callback) {
-            this.query('HEAD', cradle.escape(id), null, callback);
-        },
-
-        insert: function () {
-            throw new(Error)("`insert` is deprecated, use `save` instead");
-        },
-
-        replicate: function (target, options, callback) {
-            if (typeof(options) === 'function') { callback = options, options = {} }
-            that.replicate(cradle.merge({ source: name, target: target }, options), callback);
-        },
-
-        // Destroys a database with 'DELETE'
-        // we raise an exception if arguments were supplied,
-        // as we don't want users to confuse this function with `remove`.
-        destroy: function (callback) {
-            if (arguments.length > 1) {
-                throw new(Error)("destroy() doesn't take any additional arguments");
-            } else {
-                this.query('DELETE', '/', callback);
-            }
-        },
-
-        // Delete a document
-        // if the _rev wasn't supplied, we attempt to retrieve it from the
-        // cache. If the deletion was successful, we purge the cache.
-        remove: function (id, rev) {
-            var that = this, doc, args = new(Args)(arguments);
-
-            if (typeof(rev) !== 'string') {
-                if (doc = this.cache.get(id)) { rev = doc._rev }
-                else                          { throw new(Error)("rev needs to be supplied") }
-            }
-            this.query('DELETE', cradle.escape(id), {rev: rev}, function (err, res) {
-                if (! err) { that.cache.purge(id) }
-                args.callback(err, res);
-            });
-        },
-        create: function (callback) {
-            this.query('PUT', '/', callback);
-        },
-        info: function (callback) {
-            this.query('GET', '/', callback);
-        },
-        all: function (options, callback) {
-            if (arguments.length === 1) { callback = options, options = {} }
-            this.query('GET', '/_all_docs', options, callback);
-        },
-        compact: function (design) {
-            var headers = {};
-            headers['Content-Type'] = "application/json";
-            this.query('POST', '/_compact' + (typeof(design) === 'string' ? '/' + querystring.escape(design) : ''),
-                       {}, {}, headers, Args.last(arguments));
-        },
-        viewCleanup: function (callback) {
-            var headers = {};
-            headers['Content-Type'] = "application/json";
-            this.query('POST', '/_view_cleanup', {}, {}, headers, callback);
-        },
-        allBySeq: function (options) {
-            options = typeof(options) === 'object' ? options : {};
-            this.query('GET', '/_all_docs_by_seq', options, Args.last(arguments));
-        },
-
-        // Query a view, passing any options to the query string.
-        // Some query string parameters' values have to be JSON-encoded.
-        view: function (path, options) {
-            var args = new(Args)(arguments);
-
-            path = path.split('/');
-            path = ['_design', path[0], '_view', path[1]].map(querystring.escape).join('/');
-
-            if (typeof(options) === 'object') {
-                ['key', 'startkey', 'endkey'].forEach(function (k) {
-                    if (k in options) { options[k] = JSON.stringify(options[k]) }
-                });
-            }
-
-            if (options && options.keys) {
-                this.query('POST', path, {}, options, args.callback);
-            } else {
-                this.query('GET', path, options, args.callback);
-            }
-        },
-
-        // Query a list, passing any options to the query string.
-        // Some query string parameters' values have to be JSON-encoded.
-        list: function (path, options) {
-            var args = new(Args)(arguments);
-            path = path.split('/');
-
-            if (typeof(options) === 'object') {
-                ['key', 'startkey', 'endkey'].forEach(function (k) {
-                    if (k in options) { options[k] = JSON.stringify(options[k]) }
-                });
-            }
-            this.query('GET', ['_design', path[0], '_list', path[1], path[2]].map(querystring.escape).join('/'), options, args.callback);
-        },
-
-        update: function (path, id, options) {
-            var args = new(Args)(arguments);
-            path = path.split('/');
-
-            if (id) {
-              this.query('PUT', ['_design', path[0], '_update', path[1], id].map(querystring.escape).join('/'), options, args.callback);
-            } else {
-              this.query('POST', ['_design', path[0], '_update', path[1]].map(querystring.escape).join('/'), options, args.callback);
-            }
-        },
-
-        push: function (doc) {},
-
-        changes: function (options, callback) {
-            var promise = new(events.EventEmitter);
-
-            if (typeof(options) === 'function') { callback = options, options = {}; }
-
-            if (callback) {
-                this.query('GET', '_changes', options, callback);
-            } else {
-                options           = options           || {};
-                options.feed      = options.feed      || 'continuous';
-                options.heartbeat = options.heartbeat || 1000;
-
-                that.rawRequest('GET', [name, '_changes'].join('/'), options).on('response', function (res) {
-                    var response = new(events.EventEmitter), buffer = [];
-                    res.setEncoding('utf8');
-
-                    response.statusCode = res.statusCode;
-                    response.headers    = res.headers;
-
-                    promise.emit('response', response);
-
-                    res.on('data', function (chunk) {
-                        var end;
-                        if (~(end = chunk.indexOf('\n'))) {
-                            buffer.push(chunk.substr(0, ++end));
-                            buffer.length && response.emit('data', JSON.parse(buffer.join('')));
-                            buffer = [chunk.substr(end)];
-                        } else {
-                            buffer.push(chunk);
-                        }
-                    }).on('end', function () {
-                        response.emit('end');
-                    }).on('error', function (err) {
-                        reponse.emit('error', err);
-                    })
-                }).on('error', function (err) {
-                    promise.emit('error', err);
-                });
-                
-                return promise;
-            }
-        },
-
-        saveAttachment: function (/* id, [rev], attachmentName, contentType, dataOrStream */) {
-            var doc, pathname, headers = {}, response, body = [], resHeaders, error, db = this;
-
-            var args = new(Args)(arguments), params = args.all;
-
-            if (typeof(args.first) === 'object') { throw new(TypeError)("first argument must be a document id") }
-
-            var id = params.shift(),
-                dataOrStream = params.pop(),
-                contentType  = params.pop(),
-                attachmentName = params.pop(),
-                rev = params.pop();
-
-            if (!rev && db.cache.has(id)) {
-                doc = { rev: db.cache.get(id)._rev };
-            } else if (rev) {
-                doc = { rev: rev };
-            } else {
-                doc = {};
-            }
-
-            pathname = '/' + [name, id, attachmentName].map(querystring.escape).join('/');
-            headers['Content-Type'] = contentType;
-
-            that.rawRequest('PUT', pathname, doc, dataOrStream, headers)
-                .on('response', function (res) { resHeaders = { status: res.statusCode } })
-                .on('data', function (chunk) { body.push(chunk) })
-                .on('end', function () {
-                    response = JSON.parse(body.join(''));
-                    response.headers = resHeaders;
-
-                    if (response.headers.status == 201) {
-                        if (db.cache.has(id)) {
-                            cached = db.cache.store[id].document;
-                            cached._rev = response.rev;
-                            cached._attachments = cached._attachments || {};
-                            cached._attachments[attachmentName] = { stub: true };
-                        }
-                        args.callback(null, response);
-                    } else {
-                        args.callback(response);
-                    }
-                });
-        },
-
-        getAttachment: function (docId, attachmentName) {
-            var pathname, req;
-            pathname = '/' + [name, docId, attachmentName].map(querystring.escape).join('/');
-            return that.rawRequest('GET', pathname);
-        },
-
-        temporaryView: function (doc, callback) {
-            this.query('POST', '_temp_view', null, doc, callback);
-        }
-    }
+  return new cradle.Database(name, this)
 };
 
 //
 // Wrapper functions for the server API
 //
-cradle.Connection.prototype.databases = function (c) {
-    this.request('GET', '/_all_dbs', c);
+cradle.Connection.prototype.databases = function (callback) {
+    this.request({ path: '/_all_dbs' }, callback);
 };
-cradle.Connection.prototype.config = function (c) {
-    this.request('GET', '/_config', c);
+cradle.Connection.prototype.config = function (callback) {
+    this.request({ path: '/_config' }, callback);
 };
-cradle.Connection.prototype.info = function (c) {
-    this.request('GET', '/', c);
+cradle.Connection.prototype.info = function (callback) {
+    this.request({ path: '/' }, callback);
 };
-cradle.Connection.prototype.stats = function (c) {
-    this.request('GET', '/_stats', c);
+cradle.Connection.prototype.stats = function (callback) {
+    this.request({ path: '/_stats' }, callback);
 };
-cradle.Connection.prototype.activeTasks = function (c) {
-    this.request('GET', '/_active_tasks', c);
+cradle.Connection.prototype.activeTasks = function (callback) {
+    this.request({ path: '/_active_tasks' }, callback);
 };
 cradle.Connection.prototype.uuids = function (count, callback) {
-    if (typeof(count) === 'function') { callback = count, count = null }
-    this.request('GET', '/_uuids', count ? {count: count} : {}, callback);
+    if (typeof(count) === 'function') { 
+        callback = count; 
+        count = null;
+    }
+    
+    this.request({ 
+        method: 'GET', 
+        path: '/_uuids', 
+        query: count ? { count: count } : {}
+    }, callback);
 };
 cradle.Connection.prototype.replicate = function (options, callback) {
-    this.request('POST', '/_replicate', null, options, callback);
+    this.request({
+        method: 'POST', 
+        path: '/_replicate', 
+        query: options
+    }, callback);
 };
 
+cradle.Connection.prototype._url = function (path) {
+    var url = (this.protocol || 'http') + '://' + this.host;
+
+    if (this.port !== 443 && this.port !== 80) {
+      url += ':' + this.port;
+    }
+    
+    url += path[0] === '/' ? path : ('/' + path);
+
+    return url;
+}
+
 cradle.escape = function (id) {
     return ['_design', '_changes', '_temp_view'].indexOf(id.split('/')[0]) === -1
         ? querystring.escape(id)
@@ -684,4 +278,4 @@ cradle.merge = function (target) {
         });
     });
     return target;
-}
+};