vulcan 0.0.1 → 0.0.2

data/server/node_modules/cradle/node_modules/vows/lib/assert/error.js

@@ -0,0 +1,27 @@
+var stylize = require('../vows/console').stylize;
+var inspect = require('../vows/console').inspect;
+
+require('assert').AssertionError.prototype.toString = function () {
+    var that = this,
+        source = this.stack.match(/([a-zA-Z0-9._-]+\.js)(:\d+):\d+/);
+
+    function parse(str) {
+        return str.replace(/{actual}/g,   inspect(that.actual)).
+                   replace(/{operator}/g, stylize(that.operator, 'bold')).
+                   replace(/{expected}/g, (that.expected instanceof Function)
+                                          ? that.expected.name
+                                          : inspect(that.expected));
+    }
+
+    if (this.message) {
+        return stylize(parse(this.message), 'yellow') +
+               stylize(' // ' + source[1] + source[2], 'grey');
+    } else {
+        return stylize([
+            this.expected,
+            this.operator,
+            this.actual
+        ].join(' '), 'yellow');
+    }
+};
+

data/server/node_modules/cradle/node_modules/vows/lib/assert/macros.js

@@ -0,0 +1,215 @@
+var assert = require('assert'),
+    utils = require('./utils');
+
+var messages = {
+    'equal'       : "expected {expected},\n\tgot\t {actual} ({operator})",
+    'notEqual'    : "didn't expect {actual} ({operator})"
+};
+messages['strictEqual']    = messages['deepEqual']    = messages['equal'];
+messages['notStrictEqual'] = messages['notDeepEqual'] = messages['notEqual'];
+
+for (var key in messages) {
+    assert[key] = (function (key, callback) {
+        return function (actual, expected, message) {
+            callback(actual, expected, message || messages[key]);
+        };
+    })(key, assert[key]);
+}
+
+assert.ok = (function (callback) {
+    return function (actual, message) {
+        callback(actual, message ||  "expected expression to evaluate to {expected}, but was {actual}");
+    };
+})(assert.ok);
+
+assert.match = function (actual, expected, message) {
+    if (! expected.test(actual)) {
+        assert.fail(actual, expected, message || "expected {actual} to match {expected}", "match", assert.match);
+    }
+};
+assert.matches = assert.match;
+
+assert.isTrue = function (actual, message) {
+    if (actual !== true) {
+        assert.fail(actual, true, message || "expected {expected}, got {actual}", "===", assert.isTrue);
+    }
+};
+assert.isFalse = function (actual, message) {
+    if (actual !== false) {
+        assert.fail(actual, false, message || "expected {expected}, got {actual}", "===", assert.isFalse);
+    }
+};
+assert.isZero = function (actual, message) {
+    if (actual !== 0) {
+        assert.fail(actual, 0, message || "expected {expected}, got {actual}", "===", assert.isZero);
+    }
+};
+assert.isNotZero = function (actual, message) {
+    if (actual === 0) {
+        assert.fail(actual, 0, message || "expected non-zero value, got {actual}", "===", assert.isNotZero);
+    }
+};
+
+assert.greater = function (actual, expected, message) {
+    if (actual <= expected) {
+        assert.fail(actual, expected, message || "expected {actual} to be greater than {expected}", ">", assert.greater);
+    }
+};
+assert.lesser = function (actual, expected, message) {
+    if (actual >= expected) {
+        assert.fail(actual, expected, message || "expected {actual} to be lesser than {expected}", "<", assert.lesser);
+    }
+};
+
+assert.inDelta = function (actual, expected, delta, message) {
+    var lower = expected - delta;
+    var upper = expected + delta;
+    if (actual < lower || actual > upper) {
+        assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta.toString() + "* of {expected}", null, assert.inDelta);
+    }
+};
+
+//
+// Inclusion
+//
+assert.include = function (actual, expected, message) {
+    if ((function (obj) {
+        if (isArray(obj) || isString(obj)) {
+            return obj.indexOf(expected) === -1;
+        } else if (isObject(actual)) {
+            return ! obj.hasOwnProperty(expected);
+        }
+        return false;
+    })(actual)) {
+        assert.fail(actual, expected, message || "expected {actual} to include {expected}", "include", assert.include);
+    }
+};
+assert.includes = assert.include;
+
+assert.deepInclude = function (actual, expected, message) {
+    if (!isArray(actual)) {
+        return assert.include(actual, expected, message);
+    }
+    if (!actual.some(function (item) { return utils.deepEqual(item, expected) })) {
+        assert.fail(actual, expected, message || "expected {actual} to include {expected}", "include", assert.deepInclude);
+    }
+};
+assert.deepIncludes = assert.deepInclude;
+
+//
+// Length
+//
+assert.isEmpty = function (actual, message) {
+    if ((isObject(actual) && Object.keys(actual).length > 0) || actual.length > 0) {
+        assert.fail(actual, 0, message || "expected {actual} to be empty", "length", assert.isEmpty);
+    }
+};
+assert.isNotEmpty = function (actual, message) {
+    if ((isObject(actual) && Object.keys(actual).length === 0) || actual.length === 0) {
+        assert.fail(actual, 0, message || "expected {actual} to be not empty", "length", assert.isNotEmpty);
+    }
+};
+
+assert.length = function (actual, expected, message) {
+    if (actual.length !== expected) {
+        assert.fail(actual, expected, message || "expected {actual} to have {expected} element(s)", "length", assert.length);
+    }
+};
+
+//
+// Type
+//
+assert.isArray = function (actual, message) {
+    assertTypeOf(actual, 'array', message || "expected {actual} to be an Array", assert.isArray);
+};
+assert.isObject = function (actual, message) {
+    assertTypeOf(actual, 'object', message || "expected {actual} to be an Object", assert.isObject);
+};
+assert.isNumber = function (actual, message) {
+    if (isNaN(actual)) {
+        assert.fail(actual, 'number', message || "expected {actual} to be of type {expected}", "isNaN", assert.isNumber);
+    } else {
+        assertTypeOf(actual, 'number', message || "expected {actual} to be a Number", assert.isNumber);
+    }
+};
+assert.isBoolean = function (actual, message) {
+    if (actual !== true && actual !== false) {
+        assert.fail(actual, 'boolean', message || "expected {actual} to be a Boolean", "===", assert.isBoolean);
+    }
+};
+assert.isNaN = function (actual, message) {
+    if (actual === actual) {
+        assert.fail(actual, 'NaN', message || "expected {actual} to be NaN", "===", assert.isNaN);
+    }
+};
+assert.isNull = function (actual, message) {
+    if (actual !== null) {
+        assert.fail(actual, null, message || "expected {expected}, got {actual}", "===", assert.isNull);
+    }
+};
+assert.isNotNull = function (actual, message) {
+    if (actual === null) {
+        assert.fail(actual, null, message || "expected non-null value, got {actual}", "===", assert.isNotNull);
+    }
+};
+assert.isUndefined = function (actual, message) {
+    if (actual !== undefined) {
+        assert.fail(actual, undefined, message || "expected {actual} to be {expected}", "===", assert.isUndefined);
+    }
+};
+assert.isDefined = function (actual, message) {
+    if(actual === undefined) {
+        assert.fail(actual, 0, message || "expected {actual} to be defined", "===", assert.isDefined);
+    }
+};
+assert.isString = function (actual, message) {
+    assertTypeOf(actual, 'string', message || "expected {actual} to be a String", assert.isString);
+};
+assert.isFunction = function (actual, message) {
+    assertTypeOf(actual, 'function', message || "expected {actual} to be a Function", assert.isFunction);
+};
+assert.typeOf = function (actual, expected, message) {
+    assertTypeOf(actual, expected, message, assert.typeOf);
+};
+assert.instanceOf = function (actual, expected, message) {
+    if (! (actual instanceof expected)) {
+        assert.fail(actual, expected, message || "expected {actual} to be an instance of {expected}", "instanceof", assert.instanceOf);
+    }
+};
+
+//
+// Utility functions
+//
+
+function assertTypeOf(actual, expected, message, caller) {
+    if (typeOf(actual) !== expected) {
+        assert.fail(actual, expected, message || "expected {actual} to be of type {expected}", "typeOf", caller);
+    }
+};
+
+function isArray (obj) {
+    return Array.isArray(obj);
+}
+
+function isString (obj) {
+    return typeof(obj) === 'string' || obj instanceof String;
+}
+
+function isObject (obj) {
+    return typeof(obj) === 'object' && obj && !isArray(obj);
+}
+
+// A better `typeof`
+function typeOf(value) {
+    var s = typeof(value),
+        types = [Object, Array, String, RegExp, Number, Function, Boolean, Date];
+
+    if (s === 'object' || s === 'function') {
+        if (value) {
+            types.forEach(function (t) {
+                if (value instanceof t) { s = t.name.toLowerCase() }
+            });
+        } else { s = 'null' }
+    }
+    return s;
+}

data/server/node_modules/cradle/node_modules/vows/lib/assert/utils.js

@@ -0,0 +1,77 @@
+
+// Taken from node/lib/assert.js
+exports.deepEqual = function (actual, expected) {
+  if (actual === expected) {
+    return true;
+
+  } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+    return true;
+
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+  } else if (typeof actual != 'object' && typeof expected != 'object') {
+    return actual == expected;
+
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+// Taken from node/lib/assert.js
+exports.notDeepEqual = function (actual, expected, message) {
+  if (exports.deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+  }
+}
+
+// Taken from node/lib/assert.js
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+// Taken from node/lib/assert.js
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+// Taken from node/lib/assert.js
+function objEquiv(a, b) {
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+    return false;
+  if (a.prototype !== b.prototype) return false;
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false;
+    }
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return exports.deepEqual(a, b);
+  }
+  try {
+    var ka = Object.keys(a),
+        kb = Object.keys(b),
+        key, i;
+  } catch (e) {
+    return false;
+  }
+  if (ka.length != kb.length)
+    return false;
+  ka.sort();
+  kb.sort();
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!exports.deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+

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

@@ -0,0 +1,193 @@
+//
+// Vows.js - asynchronous event-based BDD for node.js
+//
+//   usage:
+//
+//       var vows = require('vows');
+//
+//       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);
+//               }
+//           }
+//       }).run();
+//
+var sys = require('sys'),
+    path = require('path'),
+    events = require('events'),
+    vows = exports;
+
+// Options
+vows.options = {
+    Emitter: events.EventEmitter,
+    reporter: require('./vows/reporters/dot-matrix'),
+    matcher: /.*/,
+    error: true // Handle "error" event
+};
+
+vows.__defineGetter__('reporter', function () {
+    return vows.options.reporter;
+});
+
+var stylize = require('./vows/console').stylize;
+var console = require('./vows/console');
+
+vows.inspect = require('./vows/console').inspect;
+vows.prepare = require('./vows/extras').prepare;
+vows.tryEnd  = require('./vows/suite').tryEnd;
+
+//
+// Assertion Macros & Extensions
+//
+require('./assert/error');
+require('./assert/macros');
+
+//
+// Suite constructor
+//
+var Suite = require('./vows/suite').Suite;
+
+//
+// This function gets added to events.EventEmitter.prototype, by default.
+// It's essentially a wrapper around `on`, which adds all the specification
+// goodness.
+//
+function addVow(vow) {
+    var batch = vow.batch;
+
+    batch.total ++;
+    batch.vows.push(vow);
+
+    return this.on("success", function () {
+        var args = Array.prototype.slice.call(arguments);
+        // If the callback is expecting two or more arguments,
+        // pass the error as the first (null) and the result after.
+        if (vow.callback.length >= 2 && batch.suite.options.error) {
+            args.unshift(null);
+        }
+        runTest(args, this.ctx);
+        vows.tryEnd(batch);
+
+    }).on("error", function (err) {
+        if (vow.callback.length >= 2 || !batch.suite.options.error) {
+            runTest(arguments, this.ctx);
+        } else {
+            output('errored', { type: 'promise', error: err.stack || err.message || JSON.stringify(err) });
+        }
+        vows.tryEnd(batch);
+    });
+
+    function runTest(args, ctx) {
+        var topic, status;
+
+        if (vow.callback instanceof String) {
+            return output('pending');
+        }
+
+        // Run the test, and try to catch `AssertionError`s and other exceptions;
+        // increment counters accordingly.
+        try {
+            vow.callback.apply(ctx === global || !ctx ? vow.binding : ctx, args);
+            output('honored');
+        } catch (e) {
+            if (e.name && e.name.match(/AssertionError/)) {
+                output('broken', e.toString());
+            } else {
+                output('errored', e.stack || e.message || e);
+            }
+        }
+    }
+
+    function output(status, exception) {
+        batch[status] ++;
+        vow.status = status;
+
+        if (vow.context && batch.lastContext !== vow.context) {
+            batch.lastContext = vow.context;
+            batch.suite.report(['context', vow.context]);
+        }
+        batch.suite.report(['vow', {
+            title: vow.description,
+            context: vow.context,
+            status: status,
+            exception: exception || null
+        }]);
+    }
+};
+
+//
+// On exit, check that all promises have been fired.
+// If not, report an error message.
+//
+process.on('exit', function () {
+    var results = { honored: 0, broken: 0, errored: 0, pending: 0, total: 0 }, failure;
+
+    vows.suites.forEach(function (s) {
+        if ((s.results.total > 0) && (s.results.time === null)) {
+            s.reporter.print('\n\n');
+            s.reporter.report(['error', { error: "Asynchronous Error", suite: s }]);
+        }
+        s.batches.forEach(function (b) {
+            var unFired = [];
+
+            b.vows.forEach(function (vow) {
+                if (! vow.status) {
+                    if (unFired.indexOf(vow.context) === -1) {
+                        unFired.push(vow.context);
+                    }
+                }
+            });
+
+            if (unFired.length > 0) { sys.print('\n') }
+
+            unFired.forEach(function (title) {
+                s.reporter.report(['error', {
+                    error: "callback not fired",
+                    context: title,
+                    batch: b,
+                    suite: s
+                }]);
+            });
+
+            if (b.status === 'begin') {
+                failure = true;
+                results.errored ++;
+                results.total ++;
+            }
+            Object.keys(results).forEach(function (k) { results[k] += b[k] });
+        });
+    });
+    if (failure) {
+        sys.puts(console.result(results));
+    }
+});
+
+vows.suites = [];
+
+//
+// Create a new test suite
+//
+vows.describe = function (subject) {
+    var suite = new(Suite)(subject);
+
+    this.options.Emitter.prototype.addVow = addVow;
+    this.suites.push(suite);
+
+    //
+    // Add any additional arguments as batches if they're present
+    //
+    if (arguments.length > 1) {
+        for (var i = 1, l = arguments.length; i < l; ++i) {
+            suite.addBatch(arguments[i]);
+        }
+    }
+
+    return suite;
+};
+
+
+vows.version = require('fs').readFileSync(path.join(__dirname, '..', 'package.json'))
+                            .toString().match(/"version"\s*:\s*"([\d.]+)"/)[1];