coffeecake 0.0.1

data/node_modules/jasmine-runner/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/node_modules/jasmine-runner/node_modules/vows/lib/assert/macros.js

@@ -0,0 +1,180 @@
+var assert = require('assert');
+
+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);
+    }
+};
+
+//
+// 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;
+
+//
+// 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.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.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.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/node_modules/jasmine-runner/node_modules/vows/lib/vows.js

@@ -0,0 +1,195 @@
+//
+// 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;
+
+require.paths.unshift(__dirname);
+
+// 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([err], 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];

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/console.js

@@ -0,0 +1,93 @@
+var eyes = require('eyes').inspector({ stream: null, styles: false });
+
+// Stylize a string
+this.stylize = function stylize(str, style) {
+    var styles = {
+        'bold'      : [1,  22],
+        'italic'    : [3,  23],
+        'underline' : [4,  24],
+        'cyan'      : [96, 39],
+        'yellow'    : [33, 39],
+        'green'     : [32, 39],
+        'red'       : [31, 39],
+        'grey'      : [90, 39],
+        'green-hi'  : [92, 32],
+    };
+    return '\033[' + styles[style][0] + 'm' + str +
+           '\033[' + styles[style][1] + 'm';
+};
+
+var $ = this.$ = function (str) {
+    str = new(String)(str);
+
+    ['bold', 'grey', 'yellow', 'red', 'green', 'white', 'cyan', 'italic'].forEach(function (style) {
+        Object.defineProperty(str, style, {
+            get: function () {
+                return exports.$(exports.stylize(this, style));
+            }
+        });
+    });
+    return str;
+};
+
+this.puts = function (options) {
+    var stylize = exports.stylize;
+    return function (args) {
+        args = Array.prototype.slice.call(arguments).map(function (a) {
+            return a.replace(/`([^`]+)`/g,   function (_, capture) { return stylize(capture, 'italic') })
+                    .replace(/\*([^*]+)\*/g, function (_, capture) { return stylize(capture, 'bold') });
+        });
+        return options.stream.write(args.join('\n') + '\n');
+    };
+};
+
+this.result = function (event) {
+    var result = [], buffer = [], time = '', header;
+    var complete = event.honored + event.pending + event.errored + event.broken;
+    var status = (event.errored && 'errored') || (event.broken && 'broken') ||
+                 (event.honored && 'honored') || (event.pending && 'pending');
+
+    if (event.total === 0) {
+        return [$("Could not find any tests to run.").bold.red];
+    }
+
+    event.honored && result.push($(event.honored).bold + " honored");
+    event.broken  && result.push($(event.broken).bold  + " broken");
+    event.errored && result.push($(event.errored).bold + " errored");
+    event.pending && result.push($(event.pending).bold + " pending");
+
+    if (complete < event.total) {
+        result.push($(event.total - complete).bold + " dropped");
+    }
+
+    result = result.join(' ∙ ');
+
+    header = {
+        honored: '✓ ' + $('OK').bold.green,
+        broken:  '✗ ' + $('Broken').bold.yellow,
+        errored: '✗ ' + $('Errored').bold.red,
+        pending: '- ' + $('Pending').bold.cyan
+    }[status] + ' » ';
+
+    if (typeof(event.time) === 'number') {
+        time = ' (' + event.time.toFixed(3) + 's)';
+        time = this.stylize(time, 'grey');
+    }
+    buffer.push(header + result + time);
+
+    return buffer;
+};
+
+this.inspect = function inspect(val) {
+    return '\033[1m' + eyes(val) + '\033[22m';
+};
+
+this.error = function (obj) {
+    var string  = '✗ ' + $('Errored ').red + '» ';
+        string += $(obj.error).red.bold                         + '\n';
+        string += (obj.context ? '    in ' + $(obj.context).red + '\n': '');
+        string += '    in ' + $(obj.suite.subject).red          + '\n';
+        string += '    in ' + $(obj.suite._filename).red;
+
+    return string;
+};