vulcan 0.1.6 → 0.2.0

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

@@ -1,27 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,77 +0,0 @@
-
-// 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

@@ -1,193 +0,0 @@
-//
-// 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];