first commit

node_modules/vows/lib/assert/error.js

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

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.lengthOf = 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;
+}

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;
+}
+