vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/expresso/lib/bar.js

@@ -0,0 +1,4 @@
+
+exports.bar = function(msg){
+    return msg || 'bar';
+};

data/server/node_modules/connect-form/support/expresso/lib/foo.js

@@ -0,0 +1,16 @@
+
+exports.foo = function(msg){
+    if (msg) {
+        return msg;
+    } else {
+        return generateFoo();
+    }
+};
+
+function generateFoo() {
+    return 'foo';
+}
+
+function Foo(msg){
+    this.msg = msg || 'foo';
+}

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

@@ -0,0 +1,9 @@
+{ "name": "expresso",
+  "version": "0.4.0",
+  "description": "TDD framework, light-weight, fast, CI-friendly",
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "bin": { "expresso": "./bin/expresso" },
+  "scripts": {
+    "install": "make install-jscov"	
+  }
+}

data/server/node_modules/connect-form/support/expresso/seed.yml

@@ -0,0 +1,6 @@
+---
+  name: Expresso
+  description: TDD framework by the creator of JSpec
+  build: make install
+  version: 0.4.0
+  

data/server/node_modules/connect-form/support/expresso/test/assert.test.js

@@ -0,0 +1,64 @@
+module.exports = {
+    'assert.eql()': function(assert){
+        assert.equal(assert.deepEqual, assert.eql);
+    },
+    
+    'assert.includes()': function(assert){
+        assert.includes('some random string', 'random');
+        assert.includes('some random string', 'dom');
+        assert.throws(function(){
+           assert.include('some random string', 'foobar'); 
+        });
+    },
+    
+    'assert.isNull()': function(assert){
+        assert.isNull(null);
+        assert.throws(function(){
+            assert.isNull(undefined);
+        });
+        assert.throws(function(){
+            assert.isNull(false);
+        });
+    },
+    
+    'assert.isUndefined()': function(assert){
+        assert.isUndefined(undefined);
+        assert.throws(function(){
+            assert.isUndefined(null);
+        });
+        assert.throws(function(){
+            assert.isUndefined(false);
+        });
+    },
+    
+    'assert.isNotNull()': function(assert){
+        assert.isNotNull(false);
+        assert.isNotNull(undefined);
+        assert.throws(function(){
+            assert.isNotNull(null);
+        });
+    },
+    
+    'assert.isNotUndefined()': function(assert){
+        assert.isNotUndefined(false);
+        assert.isNotUndefined(null);
+        assert.throws(function(){
+            assert.isNotUndefined(undefined);
+        });
+    },
+    
+    'assert.match()': function(assert){
+        assert.match('foobar', /foo(bar)?/);
+        assert.throws(function(){
+            assert.match('something', /rawr/);
+        });
+    },
+    
+    'assert.length()': function(assert){
+        assert.length(4, 'test');
+        assert.length(4, [1,2,3,4]);
+        assert.throws(function(){
+            assert.length(4, [1,2,3])
+        });
+    }
+};

data/server/node_modules/connect-form/support/expresso/test/bar.test.js

@@ -0,0 +1,12 @@
+
+/**
+ * Module dependencies.
+ */
+
+var bar = require('bar');
+
+module.exports = {
+    'bar()': function(assert){
+        assert.equal('bar', bar.bar());
+    }
+};

data/server/node_modules/connect-form/support/expresso/test/foo.test.js

@@ -0,0 +1,13 @@
+
+/**
+ * Module dependencies.
+ */
+
+var foo = require('foo');
+
+module.exports = {
+    'foo()': function(assert){
+        assert.equal('foo', foo.foo());
+        assert.equal('foo', foo.foo());
+    }
+};

data/server/node_modules/connect-form/support/expresso/test/http.test.js

@@ -0,0 +1,61 @@
+
+/**
+ * Module dependencies.
+ */
+
+var http = require('http');
+
+var server = http.createServer(function(req, res){
+    if (req.method === 'GET') {
+        var body = JSON.stringify({ name: 'tj' });
+        res.writeHead(200, {
+            'Content-Type': 'application/json; charset=utf8',
+            'Content-Length': body.length
+        });
+        res.end(body);
+    } else {
+        var body = '';
+        req.setEncoding('utf8');
+        req.addListener('data', function(chunk){ body += chunk });
+        req.addListener('end', function(){
+            res.writeHead(200, {});
+            res.end(req.url + ' ' + body);
+        });
+    }
+});
+
+module.exports = {
+    'test assert.response()': function(assert, beforeExit){
+        assert.response(server, {
+            url: '/',
+            method: 'GET'
+        },{
+            body: '{"name":"tj"}',
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json; charset=utf8'
+            }
+        });
+        
+        assert.response(server, {
+            url: '/foo',
+            method: 'POST',
+            data: 'bar baz'
+        },{
+            body: '/foo bar baz',
+            status: 200
+        });
+        
+        var called;
+        assert.response(server, {
+            url: '/foo'
+        }, function(res){
+            called = true;
+            assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
+        });
+        
+        beforeExit(function(){
+            assert.ok(called);
+        });
+    }
+};

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

@@ -0,0 +1,148 @@
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('connect'),
+    form = require('./../index');
+
+// Test server
+
+var server = connect.createServer(
+    form(),
+    function(req, res, next){
+        if (req.form) {
+            req.form.complete(function(err, fields, files){
+                res.writeHead(200, {});
+                if (err) res.write(JSON.stringify(err.message));
+                res.write(JSON.stringify(fields));
+                res.write(JSON.stringify(files));
+                res.end();
+            });
+        } else {
+            next();
+        }
+    }
+);
+
+// Tests
+
+exports['test single multipart field'] = function(assert){
+    var headers = {
+        'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundaryMfJEpQcCbybb6A8U'
+    };
+
+    var body = [
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data; name="name"',
+        '',
+        'foo',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U--\r\n'
+    ].join('\r\n');
+
+    assert.response(server,
+        { url: '/' },
+        { body: 'Cannot GET /' });
+    
+    assert.response(server,
+        { url: '/', method: 'POST', headers: headers, data: body },
+        { body: '{"name":"foo"}{}' });
+};
+
+exports['test several multipart fields'] = function(assert){
+    var headers = {
+        'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundaryMfJEpQcCbybb6A8U'
+    };
+
+    var body = [
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data; name="name"',
+        '',
+        'foo',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data: name="comments"',
+        '',
+        'foo bar baz',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U--\r\n'
+    ].join('\r\n');
+
+    assert.response(server,
+        { url: '/', method: 'POST', headers: headers, data: body },
+        { body: '{"name":"foo","comments":"foo bar baz"}{}' });
+};
+
+exports['test malformed multipart'] = function(assert){
+    var headers = {
+        'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundaryMfJEpQcCbybb6A8U'
+    };
+
+    var body = [
+        '--WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data; name="name"',
+        '',
+        'foo',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U--\r\n'
+    ].join('\r\n');
+
+    assert.response(server,
+        { url: '/', method: 'POST', headers: headers, data: body },
+        { body: '"parser error, 2 of 134 bytes parsed"{}{}' });
+};
+
+exports['test multipart files'] = function(assert){
+    var headers = {
+        'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundaryMfJEpQcCbybb6A8U'
+    };
+
+    var body = [
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data; name="name"',
+        '',
+        'foo',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U',
+        'Content-Disposition: form-data: name="text"; filename="foo.txt"',
+        '',
+        'foo\nbar\nbaz\n',
+        '------WebKitFormBoundaryMfJEpQcCbybb6A8U--\r\n'
+    ].join('\r\n');
+
+    assert.response(server,
+        { url: '/', method: 'POST', headers: headers, data: body },
+        function(res){
+            assert.ok(res.body.indexOf('{"name":"foo"}') >= 0, 'Test field');
+            assert.ok(res.body.indexOf('{"path":"/tmp') >= 0, 'Test file path');
+        });
+};
+
+exports['test urlencoded'] = function(assert){
+    var headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    
+    var body = 'thanks=felix&for=the&cool=lib';
+    
+    assert.response(server,
+        { url: '/', method: 'POST', data: body, headers: headers },
+        { body: '{"thanks":"felix","for":"the","cool":"lib"}{}' });
+};
+
+exports['test bodyDecoder'] = function(assert){
+    var server = connect.createServer(
+        connect.bodyDecoder(),
+        form(),
+        function(req, res){
+            res.writeHead(200, {});
+            res.end(JSON.stringify(req.body));
+        }
+    );
+
+    var headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+
+    var body = 'foo=bar';
+    
+    assert.response(server,
+        { url: '/', method: 'POST', data: body, headers: headers },
+        { body: '{"foo":"bar"}' });
+};

data/server/node_modules/cradle/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 cloudhead
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/server/node_modules/cradle/Makefile

@@ -0,0 +1,10 @@
+default: test
+
+#
+# Run all tests
+#
+test: 
+	node test/scripts/prepare-db.js
+	vows test/*-test.js
+
+.PHONY: test

data/server/node_modules/cradle/README.md

@@ -0,0 +1,377 @@
+cradle
+======
+
+A high-level, caching, CouchDB client for Node.js
+
+introduction
+------------
+
+Cradle is an asynchronous javascript client for [CouchDB](http://couchdb.apache.org).
+It is somewhat higher-level than most other CouchDB clients, requiring a little less knowledge of CouchDB's REST API.
+Cradle also has built-in write-through caching, giving you an extra level of speed, and making document _updates_ and _deletion_ easier.
+Cradle was built from the love of CouchDB and Node.js, and tries to make the most out of this wonderful marriage of technologies.
+
+philosophy
+----------
+
+The key concept here is the common ground shared by CouchDB and Node.js, that is, _javascript_. The other important aspect of this marriage is the asynchronous behaviors of both these technologies. Cradle tries to make use of these symmetries, whenever it can.
+Cradle's API, although closely knit with CouchDB's, isn't overly so. Whenever the API can be abstracted in a friendlier, simpler way, that's the route it takes. So even though a large part of the `Cradle <--> CouchDB` mappings are one to one, some Cradle functions, such as `save()`, can perform more than one operation, depending on how they are used.
+
+synopsis
+--------
+
+``` js
+  var cradle = require('cradle');
+  var db = new(cradle.Connection)().database('starwars');
+
+  db.get('vader', function (err, doc) {
+      doc.name; // 'Darth Vader'
+      assert.equal(doc.force, 'dark');
+  });
+
+  db.save('skywalker', {
+      force: 'light',
+      name: 'Luke Skywalker'
+  }, function (err, res) {
+      if (err) {
+          // Handle error
+      } else {
+          // Handle success
+      }
+  });
+```
+
+installation
+------------
+
+``` bash
+  $ npm install cradle
+```
+
+API
+---
+
+Cradle's API builds right on top of Node's asynch API. Every asynch method takes a callback as its last argument. The return value is an `event.EventEmitter`, so listeners can also be optionally added.
+
+### Opening a connection ###
+
+``` js
+  new(cradle.Connection)('http://living-room.couch', 5984, {
+      cache: true,
+      raw: false
+  });
+```
+
+_Defaults to `127.0.0.1:5984`_
+
+Note that you can also use `cradle.setup` to set a global configuration:
+
+``` js
+  cradle.setup({
+    host: 'living-room.couch',
+    cache: true, 
+    raw: false
+  });
+
+  var c = new(cradle.Connection),
+     cc = new(cradle.Connection)('173.45.66.92');
+```
+
+### creating a database ###
+
+``` js
+  var db = c.database('starwars');
+  db.create();
+```
+
+#### checking for database existence ####
+
+You can check if a database exists with the `exists()` method.
+
+``` js
+  db.exists(function (err, exists) {
+    if (err) {
+      console.log('error', err);
+    } else if (exists) {
+      console.log('the force is with you.');
+    } else {
+      console.log('database does not exists.');
+      db.create();
+      /* populate design documents */
+    }
+  });
+```
+
+### destroy a database ###
+
+``` js
+  db.destroy(cb);
+```
+
+### fetching a document _(GET)_ ###
+
+``` js
+  db.get('vader', function (err, doc) {
+      sys.puts(doc);
+  });
+```
+
+> If you want to get a specific revision for that document, you can pass it as the 2nd parameter to `get()`.
+
+Cradle is also able to fetch multiple documents if you have a list of ids, just pass an array to `get`:
+
+``` js
+  db.get(['luke', 'vader'], function (err, doc) { ... });
+```
+
+### Querying a view ###
+
+``` 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.");
+      });
+  });
+```
+
+#### Querying a row with a specific key ####
+Lets suppose that you have a design document that you've created:
+
+``` js
+  db.save('_design/user', {
+    views: {
+      byUsername: {
+        map: 'function (doc) { if (doc.resource === 'User') { emit(doc.username, doc) } }'
+      }
+    }
+  });
+```
+
+In CouchDB you could query this view directly by making an HTTP request to:
+
+```
+  /_design/User/_view/byUsername/?key="luke"
+```
+
+In `cradle` you can make this same query by using the `.view()` database function: 
+
+``` js
+  db.view('user/byUsername', { key: 'luke' }, function (err, doc) {
+      console.dir(doc);
+  });
+```
+
+### creating/updating documents ###
+
+In general, document creation is done with the `save()` method, while updating is done with `merge()`.
+
+#### creating with an id _(PUT)_ ####
+
+``` js
+  db.save('vader', {
+      name: 'darth', force: 'dark'
+  }, function (err, res) {
+      // Handle response
+  });
+```
+
+#### creating without an id _(POST)_ ####
+
+``` js
+  db.save({
+      force: 'dark', name: 'Darth'
+  }, function (err, res) {
+      // Handle response
+  });
+```
+
+#### updating an existing document with the revision ####
+
+``` js
+  db.save('luke', '1-94B6F82', {
+      force: 'dark', name: 'Luke'
+  }, function (err, res) {
+      // Handle response
+  });
+```
+
+Note that when saving a document this way, CouchDB overwrites the existing document with the new one. If you want to update only certain fields of the document, you have to fetch it first (with `get`), make your changes, then resave the modified document with the above method.
+
+If you only want to update one or more attributes, and leave the others untouched, you can use the `merge()` method:
+
+``` js
+  db.merge('luke', {jedi: true}, function (err, res) {
+      // Luke is now a jedi,
+      // but remains on the dark side of the force.
+  });
+```
+
+Note that we didn't pass a `_rev`, this only works because we previously saved a full version of 'luke', and the `cache` option is enabled.
+
+#### bulk insertion ####
+
+If you want to insert more than one document at a time, for performance reasons, you can pass an array to `save()`:
+
+``` js
+  db.save([
+      { name: 'Yoda' },
+      { name: 'Han Solo' },
+      { name: 'Leia' }
+  ], function (err, res) {
+      // Handle response
+  });
+```
+
+#### creating views ####
+
+Here we create a design document named 'characters', with two views: 'all' and 'darkside'.
+
+``` js
+  db.save('_design/characters', {
+      all: {
+          map: function (doc) {
+              if (doc.name) emit(doc.name, doc);
+          }
+      },
+      darkside: {
+          map: function (doc) {
+              if (doc.name && doc.force == 'dark') {
+                  emit(null, doc);
+              }
+          }
+      }
+  });
+```
+
+These views can later be queried with `db.view('characters/all')`, for example.
+
+Here we create a temporary view. WARNING: do not use this in production as it is
+extremely slow (use it to test views).
+
+``` js
+  db.temporaryView({
+      map: function (doc) {
+        if (doc.color) emit(doc._id, doc);
+      }
+    }, function (err, res) {
+      if (err) console.log(err);
+      console.log(res);
+  });
+```
+
+### creating validation ###
+
+when saving a design document, cradle guesses you want to create a view, mention views explicitly to work around this.
+
+``` js
+  db.save('_design/laws', {
+    views: {},
+    validate_doc_update: 
+      function (newDoc, oldDoc, usrCtx) {
+        if(! /^(light|dark|neutral)$/(newDoc.force))
+          throw { error: "invalid value", reason:"force must be dark, light, or neutral" }
+      }
+    }
+  });
+```
+
+### removing documents _(DELETE)_ ###
+
+To remove a document, you call the `remove()` method, passing the latest document revision.
+
+``` js
+  db.remove('luke', '1-94B6F82', function (err, res) {
+      // Handle response
+  });
+```
+
+
+If `remove` is called without a revision, and the document was recently fetched from the database, it will attempt to use the cached document's revision, providing caching is enabled.
+
+Connecting with authentication and SSL
+--------------------------------------
+
+``` js
+  var connection = new(cradle.Connection)('https://couch.io', 443, {
+      auth: { username: 'john', password: 'fha82l' }
+  });
+```
+
+or
+
+``` js
+  var connection = new(cradle.Connection)('couch.io', 443, {
+      secure: true,
+      auth: { username: 'john', password: 'fha82l' }
+  });
+```
+
+Changes API
+-----------
+
+For a one-time `_changes` query, simply call `db.changes` with a callback:
+
+``` js
+  db.changes(function (list) {
+      list.forEach(function (change) { console.log(change) });
+  });
+```
+
+Or if you want to see changes since a specific sequence number:
+
+``` js
+  db.changes({ since: 42 }, function (list) {
+      ...
+  });
+```
+
+The callback will receive the list of changes as an *Array*. If you want to include
+the affected documents, simply pass `include_docs: true` in the options.
+
+### Streaming #
+
+You can also *stream* changes, by calling `db.changes` without the callback:
+
+``` js
+  db.changes({ since: 42 }).on('response', function (res) {
+      res.on('data', function (change) {
+          console.log(change);
+      });
+      res.on('end', function () { ... });
+  });
+```
+
+In this case, it returns an `EventEmitter`, which behaves very similarly to node's `Stream` API.
+
+
+Other API methods
+-----------------
+
+### CouchDB Server level ###
+
+``` js
+  new(cradle.Connection)().*
+```
+
+- `databases()`: Get list of databases
+- `config()`: Get server config
+- `info()`: Get server information
+- `stats()`: Statistics overview
+- `activeTasks()`: Get list of currently active tasks
+- `uuids(count)`: Get _count_ list of UUIDs
+- `replicate(options)`: Replicate a database.
+
+### database level ###
+
+``` js
+  new(cradle.Connection)().database('starwars').*
+```
+
+- `info()`: Database information
+- `all()`: Get all documents
+- `allBySeq()`: Get all documents by sequence
+- `compact()`: Compact database
+- `viewCleanup()`: Cleanup old view data
+- `replicate(target, options)`: Replicate this database to `target`.
+