vulcan 0.0.1 → 0.0.2

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

@@ -0,0 +1,102 @@
+var Response = require('./response').Response;
+//
+// Each database object has its own cache store.
+// The cache.* methods are all wrappers around
+// `cache.query`, which transparently checks if
+// caching is enabled, before performing any action.
+//
+this.Cache = function (options) {
+    var that = this;
+
+    this.store   = {};
+    this.options = options;
+    this.size = options.cacheSize || 0;
+    this.keys = 0;
+};
+
+this.Cache.prototype = {
+    // API
+    get:   function (id)      { return this.query('get',   id) },
+    save:  function (id, doc) { return this.query('save',  id, doc) },
+    purge: function (id)      { return this.query('purge', id) },
+    has:   function (id)      { return this.query('has',   id) },
+
+    _get: function (id) {
+        var entry;
+
+        if (id in this.store) {
+            entry = this.store[id];
+            entry.atime = Date.now();
+
+            if (this.options.raw) {
+                return entry.document;
+            } else {
+                // If the document is already wrapped in a `Response`,
+                // just return it. Else, wrap it first. We clone the documents
+                // before returning them, to protect them from modification.
+                if (entry.document.toJSON) {
+                    return clone(entry.document);
+                } else {
+                    return new(Response)(clone(entry.document));
+                }
+            }
+        }
+    },
+    _has: function (id) {
+        return id in this.store;
+    },
+    _save: function (id, doc) {
+        if (! this._has(id)) {
+            this.keys ++;
+            this.prune();
+        }
+
+        return this.store[id] = {
+            atime:    Date.now(),
+            document: doc
+        };
+    },
+    _purge: function (id) {
+        if (id) {
+            delete(this.store[id]);
+            this.keys --;
+        } else {
+            this.store = {};
+        }
+    },
+    query: function (op, id, doc) {
+        if (this.options.cache) {
+            return this['_' + op](id, doc);
+        } else {
+            return false;
+        }
+    },
+    prune: function () {
+        var that = this;
+        if (this.size && this.keys > this.size) {
+            process.nextTick(function () {
+                var store  = that.store,
+                    keys   = Object.keys(store),
+                    pruned = Math.ceil(that.size / 8);
+
+                keys.sort(function (a, b) {
+                    return store[a].atime > store[b].atime ? 1 : -1;
+                });
+
+                for (var i = 0; i < pruned; i++) {
+                    delete(store[keys[i]]);
+                }
+                that.keys -= pruned;
+            });
+        }
+    }
+};
+
+function clone(obj) {
+    return Object.keys(obj).reduce(function (clone, k) {
+        if (! obj.__lookupGetter__(k)) {
+            clone[k] = obj[k];
+        }
+        return clone;
+    }, {});
+}

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

@@ -0,0 +1,127 @@
+//
+// HTTP response wrapper
+//
+//      It allows us to call array-like methods on documents
+//      with a 'row' attribute.
+//
+this.Response = function Response(json, response) {
+    var obj, headers;
+
+    // If there's rows, this is the result
+    // of a view function.
+    // We want to return this as an Array.
+    if (json.rows) {
+        obj           = json.rows.slice(0);
+        obj.__proto__ = new(Array);
+        if (json && typeof json === 'object') {
+            Object.keys(json).forEach(function (k) {
+                Object.defineProperty(obj.__proto__, k, {
+                    value:      json[k],
+                    enumerable: false
+                });
+            });
+        }
+    } else if (json.results) {
+        obj = json.results.slice(0);
+        obj.__proto__ = new(Array);
+        obj.last_seq  = json.last_seq;
+    } else if (json.uuids) {
+        obj           = json.uuids;
+        obj.__proto__ = new(Array);
+    } else if (Array.isArray(json)) {
+        obj           = json.slice(0);
+        obj.__proto__ = new(Array);
+    } else {
+        obj           = {};
+        obj.__proto__ = new(Object);
+        if (json && typeof json === 'object') {
+            Object.keys(json).forEach(function (k) {
+                obj[k] = json[k];
+            });
+        }
+    }
+
+    // If the response was originally a document,
+    // give access to it via the 'json' getter.
+    if (!Array.isArray(json) && !obj.json) {
+        Object.defineProperty(obj, 'json', {
+            value: json,
+            enumerable: false
+        });
+    }
+
+    if (response) {
+        headers = { status: response.statusCode };
+        Object.keys(response.headers).forEach(function (k) {
+            headers[k] = response.headers[k];
+        });
+
+        // Set the 'headers' special field, with the response's status code.
+        exports.extend(obj, 'headers' in obj ? { _headers: headers }
+                                             : {  headers: headers });
+    }
+
+    // Alias '_rev' and '_id'
+    if (obj.id && obj.rev) {
+        exports.extend(obj, { _id:  obj.id, _rev: obj.rev });
+    } else if (obj._id && obj._rev) {
+        exports.extend(obj, { id:  obj._id, rev: obj._rev });
+    }
+
+    if (Array.isArray(obj) && json.rows) {
+        exports.extend(obj, exports.collectionPrototype);
+    }
+    exports.extend(obj, exports.basePrototype);
+
+    // Set the constructor to be this function
+    Object.defineProperty(obj, 'constructor', {
+        value: arguments.callee
+    });
+
+    return obj;
+};
+
+this.basePrototype = {
+    toJSON: function () {
+        return this;
+    },
+    toString: function () {
+        return JSON.stringify(this);
+    }
+};
+
+this.collectionPrototype = {
+    forEach: function (f) {
+        for (var i = 0, value; i < this.length; i++) {
+            value = this[i].doc || this[i].json || this[i].value || this[i];
+            if (f.length === 1) {
+                f.call(this[i], value);
+            } else {
+                f.call(this[i], this[i].key, value, this[i].id);
+            }
+        }
+    },
+    map: function (f) {
+        var ary = [];
+        if (f.length === 1) {
+            this.forEach(function (a) { ary.push(f.call(this, a)) });
+        } else {
+            this.forEach(function () { ary.push(f.apply(this, arguments)) });
+        }
+        return ary;
+    },
+    toArray: function () {
+        return this.map(function (k, v) { return v });
+    }
+};
+
+this.extend = function (obj, properties) {
+    var descriptor = Object.keys(properties).reduce(function (hash, k) {
+        hash[k] = {
+            value: properties[k],
+            enumerable: false
+        };
+        return hash;
+    }, {});
+    return Object.defineProperties(obj, descriptor);
+};

data/server/node_modules/cradle/node_modules/vargs/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2010 Alexis Sellier
+
+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/node_modules/vargs/README.md

@@ -0,0 +1,34 @@
+
+vargs
+=====
+
+> variable argument handling for functions taking a callback
+
+rationale
+----------
+
+JavaScript has very poor argument handling. *vargs* tries to make it simpler.
+
+synopsis
+--------
+
+    var Args = require("vargs").Constructor;
+  
+    function (/* [arg1, arg2, ...][,callback] */) {
+        var args = new(Args)(arguments);
+        
+        args.first;    // first argument
+        args.last;     // last argument before callback
+        args.callback; // callback argument, or an empty function
+        args.all;      // all arguments except callback
+        args.length;   // number of arguments, not including callback
+        
+        args.callbackGiven(); // returns true or false
+        args.at(-1);          // last argument, including callback
+        args.array;           // all arguments, including callback
+    }
+
+example
+-------
+
+For a real-world example of *vargs*, check <http://github.com/cloudhead/cradle>

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

@@ -0,0 +1,70 @@
+//
+// vargs.js
+//
+//   variable argument handling for functions taking a callback
+//
+// usage:
+//   
+//   var Args = new("vargs").Constructor;
+//
+//   function (/* [arg1, arg2, ...][,callback] */) {
+//       var args = new(Args)(arguments);
+//       
+//       args.first;    // first argument
+//       args.last;     // last argument before callback
+//       args.callback; // callback argument, or an empty function
+//       args.all;      // all arguments except callback
+//       args.length;   // number of arguments, not including callback
+//       
+//       args.callbackGiven() // returns true or false
+//       args.at(-1)          // last argument, including callback
+//       args.array           // all arguments, including callback
+//   }
+//
+exports.Constructor = function Vargs(arguments) {
+    this.array = Array.prototype.slice.call(arguments);
+    this.__defineGetter__('length', function () {
+        if (this.callbackGiven()) {
+            return this.array.length - 1;
+        } else {
+            return this.array.length;
+        }
+    });
+    this.__defineGetter__('all', function () {
+        if (this.callbackGiven()) {
+            return this.array.slice(0, -1);
+        } else {
+            return this.array;
+        }
+    });
+    this.__defineGetter__('last', function () {
+        if (typeof(this.at(-1)) === 'function') {
+            return this.at(-2);
+        } else {
+            return this.at(-1);
+        }
+    });
+    this.__defineGetter__('first', function () {
+        return this.array[0];
+    });
+    this.callback = this.callbackGiven() ? this.at(-1)
+                                         : function () {};
+};
+
+exports.Constructor.prototype = {
+    callbackGiven: function () {
+        return typeof(this.at(-1)) === 'function';
+    },
+    at: function (n) {
+        if (n < 0) {
+            return this.array[this.array.length + n];
+        } else {
+            return this.array[n];
+        }
+    }
+};
+
+exports.Constructor.last = function (args) {
+    return args[args.length - 1];
+};
+

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

@@ -0,0 +1,12 @@
+{
+  "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" }
+}

data/server/node_modules/cradle/node_modules/vows/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/node_modules/vows/Makefile

@@ -0,0 +1,7 @@
+#
+# Run all tests
+#
+test: 
+	@@bin/vows test/*
+
+.PHONY: test install

data/server/node_modules/cradle/node_modules/vows/README.md

@@ -0,0 +1,39 @@
+Vows
+====
+
+> Asynchronous BDD & continuous integration for node.js
+
+#### <http://vowsjs.org> #
+
+introduction
+------------
+There are two reasons why we might want asynchronous testing. The first, and obvious reason is that node.js is asynchronous, and therefore our tests need to be. The second reason is to make test suites which target I/O libraries run much faster.
+
+_Vows_ is an experiment in making this possible, while adding a minimum of overhead.
+
+synopsis
+--------
+
+    var vows = require('vows'),
+        assert = require('assert');
+
+    vows.describe('Deep Thought').addBatch({
+        'An instance of DeepThought': {
+            topic: new DeepThought,
+
+            'should know the answer to the ultimate question of life': function (deepThought) {
+                assert.equal (deepThought.question('what is the answer to the universe?'), 42);
+            }
+        }
+    });
+
+installation
+------------
+
+    $ npm install vows
+
+documentation
+-------------
+
+Head over to <http://vowsjs.org>
+

data/server/node_modules/cradle/node_modules/vows/bin/vows

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+
+var path   = require('path'),
+    fs     = require('fs'),
+    util   = require('util'),
+    events = require('events');
+
+//
+// Attempt to load Coffee-Script. If it's not available, continue on our
+// merry way, if it is available, set it up so we can include `*.coffee`
+// scripts and start searching for them.
+//
+var fileExt, specFileExt;
+
+try {
+    var coffee = require('coffee-script');
+    if (require.extensions) {
+        require.extensions['.coffee'] = function (module, filename) {
+            var content = coffee.compile(fs.readFileSync(filename, 'utf8'));
+            return module._compile(content, filename);
+        };
+    } else {
+        require.registerExtension('.coffee', function (content) { return coffee.compile(content) });
+    }
+    fileExt     = /\.(js|coffee)$/;
+    specFileExt = /[.-](test|spec)\.(js|coffee)$/;
+} catch (_) {
+    fileExt     = /\.js$/;
+    specFileExt = /[.-](test|spec)\.js$/;
+}
+
+var inspect = require('eyes').inspector({
+    stream: null,
+    styles: { string: 'grey', regexp: 'grey' }
+});
+
+var vows = require('../lib/vows');
+var cutils = require('../lib/vows/console');
+var stylize = require('../lib/vows/console').stylize;
+var _reporter = require('../lib/vows/reporters/dot-matrix'), reporter = {
+    name: _reporter.name
+};
+var _coverage;
+
+var help = [
+    "usage: vows [FILE, ...] [options]",
+    "",
+    "options:",
+    "  -v, --verbose     Enable verbose output",
+    "  -w, --watch       Watch mode",
+    "  -s, --silent      Don't report",
+    "  -i, --isolate     Run each test in it's own vows process",
+    "  -m  PATTERN       Only run tests matching the PATTERN string",
+    "  -r  PATTERN       Only run tests matching the PATTERN regexp",
+    "  --json            Use JSON reporter",
+    "  --spec            Use Spec reporter",
+    "  --dot-matrix      Use Dot-Matrix reporter",
+    "  --xunit           Use xUnit reporter",
+    "  --cover-plain     Print plain coverage map if detected",
+    "  --cover-html      Write coverage map to \"coverage.html\"",
+    "  --cover-json      Write unified coverage map to \"coverage.json\"",
+    //"  --no-color        Don't use terminal colors",
+    "  --version         Show version",
+    "  -h, --help        You're staring at it"
+].join('\n');
+
+var options = {
+    reporter: reporter,
+    matcher: /.*/,
+    watch: false,
+    coverage: false,
+    isolate: false
+};
+
+var files = [];
+
+// Get rid of process runner
+// ('node' in most cases)
+var arg, args = [], argv = process.argv.slice(2);
+
+// Current directory index,
+// and path of test folder.
+var root, testFolder;
+
+//
+// Parse command-line parameters
+//
+while (arg = argv.shift()) {
+    if (arg === __filename) { continue }
+
+    if (arg[0] !== '-') {
+        args.push(arg);
+    } else {
+        arg = arg.match(/^--?(.+)/)[1];
+
+        if (arg[0] === 'r') {
+            options.matcher = new(RegExp)(argv.shift());
+        } else if (arg[0] === 'm') {
+            options.matcher = (function (str) { // Create an escaped RegExp
+                var specials = '. * + ? | ( ) [ ] { } \\ ^ ? ! = : $'.split(' ').join('|\\'),
+                    regex    = new(RegExp)('(\\' + specials + ')', 'g');
+                return new(RegExp)(str.replace(regex, '\\$1'));
+            })(argv.shift());
+        } else if (arg in options) {
+            options[arg] = true;
+        } else {
+            switch (arg) {
+                case 'json':
+                    _reporter = require('../lib/vows/reporters/json');
+                    break;
+                case 'spec':
+                    _reporter = require('../lib/vows/reporters/spec');
+                    break;
+                case 'dot-matrix':
+                    _reporter = require('../lib/vows/reporters/dot-matrix');
+                    break;
+                case 'silent':
+                case 's':
+                    _reporter = require('../lib/vows/reporters/silent');
+                    break;
+                case 'xunit':
+                    _reporter = require('../lib/vows/reporters/xunit');
+                    break;
+                case 'cover-plain':
+                    options.coverage = true;
+                    _coverage = require('../lib/vows/coverage/report-plain');
+                    break;
+                case 'cover-html':
+                    options.coverage = true;
+                    _coverage = require('../lib/vows/coverage/report-html');
+                    break;
+                case 'cover-json':
+                    options.coverage = true;
+                    _coverage = require('../lib/vows/coverage/report-json');
+                    break;
+                case 'verbose':
+                case 'v':
+                    options.verbose = true;
+                    break;
+                case 'watch':
+                case 'w':
+                    options.watch = true;
+                    break;
+                case 'supress-stdout':
+                    options.supressStdout = true;
+                    break;
+                case 'isolate':
+                case 'i':
+                    options.isolate = true;
+                    break;
+                case 'no-color':
+                    options.nocolor = true;
+                    break;
+                case 'no-error':
+                    options.error = false;
+                    break;
+                case 'version':
+                    console.log('vows ' + vows.version);
+                    process.exit(0);
+                case 'help':
+                case 'h':
+                    console.log(help);
+                    process.exit(0);
+                    break;
+            }
+        }
+    }
+}
+
+if (options.supressStdout) {
+  _reporter.setStream && _reporter.setStream(process.stdout);
+  process.stdout = fs.createWriteStream('/dev/null');
+}
+
+if (options.watch) {
+    options.reporter = reporter = require('../lib/vows/reporters/watch');
+}
+
+msg('bin', 'argv', args);
+msg('bin', 'options', { reporter: options.reporter.name, matcher: options.matcher });
+
+if (args.length === 0 || options.watch) {
+    msg('bin', 'discovering', 'folder structure');
+    root = fs.readdirSync('.');
+
+    if (root.indexOf('test') !== -1) {
+        testFolder = 'test';
+    } else if (root.indexOf('spec') !== -1) {
+        testFolder = 'spec';
+    } else {
+        abort("runner", "couldn't find test folder");
+    }
+    msg('bin', 'discovered', "./" + testFolder);
+
+    if (args.length === 0) {
+        args = paths(testFolder).filter(function (f) {
+            return new(RegExp)('-' + testFolder + '.(js|coffee)$').test(f);
+        });
+
+        if (options.watch) {
+            args = args.concat(paths('lib'),
+                               paths('src'));
+        }
+    }
+}
+
+if (! options.watch) {
+    reporter.report = function (data, filename) {
+        switch (data[0]) {
+            case 'subject':
+            case 'vow':
+            case 'context':
+            case 'error':
+                _reporter.report(data, filename);
+                break;
+            case 'end':
+                (options.verbose || _reporter.name === 'json') &&
+                _reporter.report(data);
+                break;
+            case 'finish':
+                options.verbose ?
+                    _reporter.print('\n')
+                    :
+                    _reporter.print(' ');
+                break;
+        }
+    };
+    reporter.reset = function () { _reporter.reset && _reporter.reset() };
+    reporter.print = _reporter.print;
+
+    files = args.map(function (a) {
+        return (!a.match(/^\//))
+            ? path.join(process.cwd(), a.replace(fileExt, ''))
+            : a.replace(fileExt, '');
+    });
+
+    runSuites(importSuites(files), function (results) {
+        var status = results.errored ? 2 : (results.broken ? 1 : 0);
+
+        !options.verbose && _reporter.print('\n');
+        msg('runner', 'finish');
+        _reporter.report(['finish', results], {
+            write: function (str) {
+                util.print(str.replace(/^\n\n/, '\n'));
+            }
+        });
+        try {
+            if (options.coverage === true && _$jscoverage !== undefined) {
+                _coverage.report(_$jscoverage);
+            }
+        } catch (err) {
+            // ignore the undefined jscoverage
+        }
+        if (process.stdout.write('')) { // Check if stdout is drained
+            process.exit(status);
+        } else {
+            process.stdout.on('drain', function () {
+                process.exit(status);
+            });
+        }
+    });
+} else {
+    //
+    // Watch mode
+    //
+    (function () {
+        var pendulum = [
+            '.   ', '..  ', '... ', ' ...',
+            '  ..', '   .', '   .', '  ..',
+            '... ', '..  ', '.   '
+        ];
+        var strobe = ['.', ' '];
+        var status,
+            cue,
+            current = 0,
+            running = 0,
+            lastRun,
+            colors = ['32m', '33m', '31m'],
+            timer = setInterval(tick, 100);
+
+        process.on('uncaughtException', cleanup);
+        process.on('exit', cleanup);
+        process.on('SIGINT', function () {
+            process.exit(0);
+        });
+        process.on('SIGQUIT', function () {
+            changed();
+        });
+
+        cursorHide();
+
+        // Run every 100ms
+        function tick() {
+            if (running && (cue !== strobe)) {
+                cue = strobe, current = 0;
+            } else if (!running && (cue !== pendulum)) {
+                cue = pendulum, current = 0;
+            }
+
+            eraseLine();
+            lastRun && !running && esc(colors[status.errored ? 2 : (status.broken ? 1 : 0)]);
+            print(cue[current]);
+
+            if (current == cue.length - 1) { current = -1 }
+
+            current ++;
+            esc('39m');
+            cursorRestore();
+        }
+
+        //
+        // Utility functions
+        //
+        function print(str)      { util.print(str) }
+        function esc(str)        { print("\x1b[" + str) }
+        function eraseLine()     { esc("0K") }
+        function cursorRestore() { esc("0G") }
+        function cursorHide()    { esc("?25l") }
+        function cursorShow()    { esc("?25h") }
+        function cleanup()       { eraseLine(), cursorShow(), clearInterval(timer), print('\n') }
+
+        //
+        // Called when a file has been modified.
+        // Run the matching tests and change the status.
+        //
+        function changed(file) {
+            status = { honored: 0, broken: 0, errored: 0, pending: 0 };
+
+            msg('watcher', 'detected change in', file);
+
+            file = (specFileExt.test(file) ? path.join(testFolder, file)
+                                           : path.join(testFolder, file + '-' + testFolder));
+
+            try {
+                fs.statSync(file);
+            } catch (e) {
+                msg('watcher', 'no equivalence found, running all tests.');
+                file = null;
+            }
+
+            var files = (specFileExt.test(file) ? [file] : paths(testFolder)).map(function (p) {
+                return path.join(process.cwd(), p);
+            }).map(function (p) {
+                var cache = require.main.moduleCache || require.cache;
+                if (cache[p]) { delete(cache[p]) }
+                return p;
+            }).map(function (p) {
+                return p.replace(fileExt, '');
+            });
+
+            running ++;
+
+            runSuites(importSuites(files), function (results) {
+                delete(results.time);
+                print(cutils.result(results).join('') + '\n\n');
+                lastRun = new(Date);
+                status = results;
+                running --;
+            });
+        }
+
+        msg('watcher', 'watching', args);
+
+        //
+        // Watch all relevant files,
+        // and call `changed()` on change.
+        //
+        args.forEach(function (p) {
+            fs.watchFile(p, function (current, previous) {
+                if (new(Date)(current.mtime).valueOf() ===
+                    new(Date)(previous.mtime).valueOf()) { return }
+                else {
+                    changed(p);
+                }
+            });
+        });
+    })();
+}
+
+function runSuites(suites, callback) {
+    var results = {
+        honored: 0,
+        broken:  0,
+        errored: 0,
+        pending: 0,
+        total:   0,
+        time:    0
+    };
+    reporter.reset();
+
+    (function run(suites, callback) {
+        var suite = suites.shift();
+        if (suite) {
+            msg('runner', "running", suite.subject + ' ', options.watch ? false : true);
+            suite.run(options, function (result) {
+                Object.keys(result).forEach(function (k) {
+                    results[k] += result[k];
+                });
+                run(suites, callback);
+            });
+        } else {
+            callback(results);
+        }
+    })(suites, callback);
+}
+
+function importSuites(files) {
+    msg(options.watcher ? 'watcher' : 'runner', 'loading', files);
+
+    var spawn = require('child_process').spawn;
+
+    function cwdname(f) {
+        return f.replace(process.cwd() + '/', '') + '.js';
+    }
+
+    function wrapSpawn(f) {
+        f = cwdname(f);
+        return function (options, callback) {
+            var args = [process.argv[1], '--json', '--supress-stdout', f],
+                p = spawn(process.argv[0], args),
+                result;
+
+            p.on('exit', function (code) {
+                callback(
+                    !result ?
+                         {errored: 1, total: 1}
+                         :
+                         result
+                );
+            });
+
+            var buffer = [];
+            p.stdout.on('data', function (data) {
+                data = data.toString().split(/\n/g);
+                if (data.length == 1) {
+                    buffer.push(data[0]);
+                } else {
+                    data[0] = buffer.concat(data[0]).join('');
+                    buffer = [data.pop()];
+
+                    data.forEach(function (data) {
+                        if (data) {
+                            data = JSON.parse(data);
+                            if (data && data[0] === 'finish') {
+                                result = data[1];
+                            } else {
+                                reporter.report(data);
+                            }
+                        }
+                    });
+                }
+            });
+
+            p.stderr.pipe(process.stderr);
+        }
+    }
+
+    return files.reduce(options.isolate ? function (suites, f) {
+        return suites.concat({
+            run: wrapSpawn(f)
+        });
+    } : function (suites, f) {
+        var obj = require(f);
+        return suites.concat(Object.keys(obj).map(function (s) {
+            obj[s]._filename = cwdname(f);
+            return obj[s];
+        }));
+    }, [])
+}
+
+//
+// Recursively traverse a hierarchy, returning
+// a list of all relevant .js files.
+//
+function paths(dir) {
+    var paths = [];
+
+    try { fs.statSync(dir) }
+    catch (e) { return [] }
+
+    (function traverse(dir, stack) {
+        stack.push(dir);
+        fs.readdirSync(stack.join('/')).forEach(function (file) {
+            var path = stack.concat([file]).join('/'),
+                stat = fs.statSync(path);
+
+            if (file[0] == '.' || file === 'vendor') {
+                return;
+            } else if (stat.isFile() && fileExt.test(file)) {
+                paths.push(path);
+            } else if (stat.isDirectory()) {
+                traverse(file, stack);
+            }
+        });
+        stack.pop();
+    })(dir || '.', []);
+
+    return paths;
+}
+
+function msg(cmd, subject, str, p) {
+    if (options.verbose) {
+        util[p ? 'print' : 'puts']( stylize('vows ', 'green')
+              + stylize(cmd, 'bold')
+              + ' ' + subject + ' '
+              + (str ? (typeof(str) === 'string' ? str : inspect(str)) : '')
+              );
+    }
+}
+
+function abort(cmd, str) {
+    console.log(stylize('vows ', 'red') + stylize(cmd, 'bold') + ' ' + str);
+    console.log(stylize('vows ', 'red') + stylize(cmd, 'bold') + ' exiting');
+    process.exit(-1);
+}