coffeecake 0.0.1

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

@@ -0,0 +1,55 @@
+
+this.Context = function (vow, ctx, env) {
+    var that = this;
+
+    this.tests = vow.callback;
+    this.topics = (ctx.topics || []).slice(0);
+    this.emitter = null;
+    this.env = env || {};
+    this.env.context = this;
+
+    this.env.callback = function (/* arguments */) {
+        var ctx = this;
+        var args = Array.prototype.slice.call(arguments);
+
+        var emit = (function (args) {
+            //
+            // Convert callback-style results into events.
+            //
+            if (vow.batch.suite.options.error) {
+                return function () {
+                    var e = args.shift();
+                    that.emitter.ctx = ctx;
+                    // We handle a special case, where the first argument is a
+                    // boolean, in which case we treat it as a result, and not
+                    // an error. This is useful for `path.exists` and other
+                    // functions like it, which only pass a single boolean
+                    // parameter instead of the more common (error, result) pair.
+                    if (typeof(e) === 'boolean' && args.length === 0) {
+                        that.emitter.emit.call(that.emitter, 'success', e);
+                    } else {
+                        if (e) { that.emitter.emit.call(that.emitter, 'error', e) }
+                        else   { that.emitter.emit.apply(that.emitter, ['success'].concat(args)) }
+                    }
+                };
+            } else {
+                return function () {
+                    that.emitter.ctx = ctx;
+                    that.emitter.emit.apply(that.emitter, ['success'].concat(args));
+                };
+            }
+        })(args.slice(0));
+        // If `this.callback` is called synchronously,
+        // the emitter will not have been set yet,
+        // so we defer the emition, that way it'll behave
+        // asynchronously.
+        if (that.emitter) { emit() }
+        else              { process.nextTick(emit) }
+    };
+    this.name = vow.description;
+    this.title = [
+        ctx.title || '',
+        vow.description || ''
+    ].join(/^[#.:]/.test(vow.description) ? '' : ' ').trim();
+};
+

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

@@ -0,0 +1,28 @@
+var events = require('events');
+//
+// Wrap a Node.js style async function into an EventEmmitter
+//
+this.prepare = function (obj, targets) {
+    targets.forEach(function (target) {
+        if (target in obj) {
+            obj[target] = (function (fun) {
+                return function () {
+                    var args = Array.prototype.slice.call(arguments);
+                    var ee = new(events.EventEmitter);
+
+                    args.push(function (err /* [, data] */) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+
+                        if (err) { ee.emit('error', err) }
+                        else     { ee.emit.apply(ee, ['success'].concat(args)) }
+                    });
+                    fun.apply(obj, args);
+
+                    return ee;
+                };
+            })(obj[target]);
+        }
+    });
+    return obj;
+};
+

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/dot-matrix.js

@@ -0,0 +1,69 @@
+
+var sys = require('sys');
+
+var options = {};
+var console = require('vows/console');
+var spec = require('vows/reporters/spec');
+var stylize = console.stylize,
+    puts = console.puts(options);
+//
+// Console reporter
+//
+var stream, messages = [], lastContext;
+
+this.name = 'dot-matrix';
+this.reset = function () {
+    messages = [];
+    lastContext = null;
+};
+this.report = function (data, s) {
+    var event = data[1];
+
+    options.stream = typeof(s) === 'object' ? s : process.stdout;
+
+    switch (data[0]) {
+        case 'subject':
+            // messages.push(stylize(event, 'underline') + '\n');
+            break;
+        case 'context':
+            break;
+        case 'vow':
+            if (event.status === 'honored') {
+                sys.print(stylize('·', 'green'));
+            } else if (event.status === 'pending') {
+                sys.print(stylize('-', 'cyan'));
+            } else {
+                if (lastContext !== event.context) {
+                    lastContext = event.context;
+                    messages.push(spec.contextText(event.context));
+                }
+                if (event.status === 'broken') {
+                    sys.print(stylize('✗', 'yellow'));
+                    messages.push(spec.vowText(event));
+                } else if (event.status === 'errored') {
+                    sys.print(stylize('✗', 'red'));
+                    messages.push(spec.vowText(event));
+                }
+                messages.push('');
+            }
+            break;
+        case 'end':
+            sys.print(' ');
+            break;
+        case 'finish':
+            if (messages.length) {
+                puts('\n\n' + messages.join('\n'));
+            } else {
+                sys.print('\n');
+            }
+            puts(console.result(event).join('\n'));
+            break;
+        case 'error':
+            puts(console.error(event));
+            break;
+    }
+};
+
+this.print = function (str) {
+    sys.print(str);
+};

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/json.js

@@ -0,0 +1,10 @@
+var sys = require('sys');
+//
+// Console JSON reporter
+//
+this.name = 'json';
+this.report = function (obj) {
+    sys.puts(JSON.stringify(obj));
+};
+
+this.print = function (str) {};

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/silent.js

@@ -0,0 +1,8 @@
+//
+// Silent reporter - "Shhh"
+//
+this.name   = 'silent';
+this.reset  = function () {};
+this.report = function () {};
+this.print  = function () {};
+

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/spec.js

@@ -0,0 +1,74 @@
+var sys = require('sys');
+
+var options = {};
+var console = require('vows/console');
+var stylize = console.stylize,
+    puts = console.puts(options);
+//
+// Console reporter
+//
+
+this.name = 'spec';
+this.report = function (data, s) {
+    var event = data[1];
+
+    options.stream = typeof(s) === 'object' ? s : process.stdout;
+    buffer = [];
+
+    switch (data[0]) {
+        case 'subject':
+            puts('\n♢ ' + stylize(event, 'bold') + '\n');
+            break;
+        case 'context':
+            puts(this.contextText(event));
+            break;
+        case 'vow':
+            puts(this.vowText(event));
+            break;
+        case 'end':
+            sys.print('\n');
+            break;
+        case 'finish':
+            puts(console.result(event).join('\n'));
+            break;
+        case 'error':
+            puts(console.error(event));
+            break;
+    }
+};
+
+this.contextText = function (event) {
+    return '  ' + event;
+};
+
+this.vowText = function (event) {
+    var buffer = [];
+
+    buffer.push('   ' + {
+        honored: ' ✓ ',
+        broken:  ' ✗ ',
+        errored: ' ✗ ',
+        pending: ' - '
+    }[event.status] + stylize(event.title, ({
+        honored: 'green',
+        broken:  'yellow',
+        errored: 'red',
+        pending: 'cyan'
+    })[event.status]));
+
+    if (event.status === 'broken') {
+        buffer.push('      » ' + event.exception);
+    } else if (event.status === 'errored') {
+        if (event.exception.type === 'promise') {
+            buffer.push('      » ' + stylize("An unexpected error was caught: " +
+                           stylize(event.exception.error, 'bold'), 'red'));
+        } else {
+            buffer.push('    ' + stylize(event.exception, 'red'));
+        }
+    }
+    return buffer.join('\n');
+};
+
+this.print = function (str) {
+    sys.print(str);
+};

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/watch.js

@@ -0,0 +1,38 @@
+var sys = require('sys');
+
+var options = {};
+var console = require('vows/console');
+var spec = require('vows/reporters/spec');
+var stylize = console.stylize,
+    puts = console.puts(options);
+//
+// Console reporter
+//
+var lastContext;
+
+this.name = 'watch';
+this.reset = function () {
+    lastContext = null;
+};
+this.report = function (data) {
+    var event = data[1];
+
+    options.stream = process.stdout;
+
+    switch (data[0]) {
+        case 'vow':
+            if (['honored', 'pending'].indexOf(event.status) === -1) {
+                if (lastContext !== event.context) {
+                    lastContext = event.context;
+                    puts(spec.contextText(event.context));
+                }
+                puts(spec.vowText(event));
+                puts('');
+            }
+            break;
+        case 'error':
+            puts(console.error(event));
+            break;
+    }
+};
+this.print = function (str) {};

data/node_modules/jasmine-runner/node_modules/vows/lib/vows/reporters/xunit.js

@@ -0,0 +1,90 @@
+// xunit outoput for vows, so we can run things under hudson
+//
+// The translation to xunit is simple.  Most likely more tags/attributes can be
+// added, see: http://ant.1045680.n5.nabble.com/schema-for-junit-xml-output-td1375274.html
+//
+
+var puts = require('util').puts;
+
+var buffer       = [],
+    curSubject   = null;
+
+function xmlEnc(value) {
+    return !value ? value : String(value).replace(/&/g, "&")
+                                         .replace(/>/g, ">")
+                                         .replace(/</g, "&lt;")
+                                         .replace(/"/g, "&quot;")
+                                         .replace(/\u001b\[\d{1,2}m/g, '');
+}
+
+function tag(name, attribs, single, content) {
+    var strAttr = [], t, end = '>';
+    for (var attr in attribs) {
+        if (attribs.hasOwnProperty(attr)) {
+            strAttr.push(attr + '="' + xmlEnc(attribs[attr]) + '"');
+        }
+    }
+    if (single) {
+        end = ' />';
+    }
+    if (strAttr.length) {
+        t = '<' + name + ' ' + strAttr.join(' ') + end;
+    } else {
+        t = '<' + name + end;
+    }
+    if (typeof content !== 'undefined') {
+        return t + content + '</' + name + end;
+    }
+    return t;
+}
+
+function end(name) {
+    return '</' + name + '>';
+}
+
+function cdata(data) {
+    return '<![CDATA[' + xmlEnc(data) + ']]>';
+}
+
+this.name = 'xunit';
+this.report = function (data) {
+    var event = data[1];
+
+    switch (data[0]) {
+    case 'subject':
+        curSubject = event;
+        break;
+    case 'context':
+        break;
+    case 'vow':
+        switch (event.status) {
+        case 'honored':
+            buffer.push(tag('testcase', {classname: curSubject, name: event.context + ': ' + event.title}, true));
+            break;
+        case 'broken':
+            var err = tag('error', {type: 'vows.event.broken', message: 'Broken test'}, false, cdata(event.exception));
+            buffer.push(tag('testcase', {classname: curSubject, name: event.context + ': ' + event.title}, false, err));
+            break;
+        case 'errored':
+            var skip = tag('skipped', {type: 'vows.event.errored', message: 'Errored test'}, false, cdata(event.exception));
+            buffer.push(tag('testcase', {classname: curSubject, name: event.context + ': ' + event.title}, false, skip));
+            break;
+        case 'pending':
+            // nop
+            break;
+        }
+        break;
+    case 'end':
+        buffer.push(end('testcase'));
+        break;
+    case 'finish':
+        buffer.unshift(tag('testsuite', {name: 'Vows test', tests: event.total, timestamp: (new Date()).toUTCString(), errors: event.errored, failures: event.broken, skip: event.pending, time: event.time}));
+        buffer.push(end('testsuite'));
+        puts(buffer.join('\n'));
+        break;
+    case 'error':
+        break;
+    }
+};
+
+this.print = function (str) { };

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

@@ -0,0 +1,321 @@
+var events = require('events'),
+    path = require('path');
+
+require.paths.unshift(path.join(__dirname, '..'));
+
+var vows = require('vows');
+var Context = require('vows/context').Context;
+
+this.Suite = function (subject) {
+    this.subject = subject;
+    this.matcher = /.*/;
+    this.reporter = require('vows/reporters/dot-matrix');
+    this.batches = [];
+    this.options = { error: true };
+    this.reset();
+};
+
+this.Suite.prototype = new(function () {
+    this.reset = function () {
+        this.results = {
+            honored: 0,
+            broken:  0,
+            errored: 0,
+            pending: 0,
+            total:   0,
+            time:  null
+        };
+        this.batches.forEach(function (b) {
+            b.lastContext = null;
+            b.remaining = b._remaining;
+            b.honored = b.broken = b.errored = b.total = b.pending = 0;
+            b.vows.forEach(function (vow) { vow.status = null });
+            b.teardowns = [];
+        });
+    };
+
+    this.addBatch = function (tests) {
+        this.batches.push({
+            tests: tests,
+            suite:  this,
+            vows:     [],
+            remaining: 0,
+           _remaining: 0,
+            honored:   0,
+            broken:    0,
+            errored:   0,
+            pending:   0,
+            total:     0,
+            teardowns: []
+        });
+        return this;
+    };
+    this.addVows = this.addBatch;
+
+    this.parseBatch = function (batch, matcher) {
+        var tests = batch.tests;
+
+        if ('topic' in tests) {
+            throw new(Error)("missing top-level context.");
+        }
+        // Count the number of vows/promises expected to fire,
+        // so we know when the tests are over.
+        // We match the keys against `matcher`, to decide
+        // whether or not they should be included in the test.
+        // Any key, including assertion function keys can be matched.
+        // If a child matches, then the n parent topics must not be skipped.
+        (function count(tests, _match) {
+            var match = false;
+
+            var keys = Object.keys(tests).filter(function (k) {
+                return k !== 'topic' && k !== 'teardown';
+            });
+
+            for (var i = 0, key; i < keys.length; i++) {
+                key = keys[i];
+
+                // If the parent node, or this one matches.
+                match = _match || matcher.test(key);
+
+                if (typeof(tests[key]) === 'object') {
+                    match = count(tests[key], match);
+                } else {
+                    if (typeof(tests[key]) === 'string') {
+                        tests[key] = new(String)(tests[key]);
+                    }
+                    if (! match) {
+                        tests[key]._skip = true;
+                    }
+                }
+            }
+
+            // If any of the children matched,
+            // don't skip this node.
+            for (var i = 0; i < keys.length; i++) {
+                if (! tests[keys[i]]._skip) { match = true }
+            }
+
+            if (match) { batch.remaining ++ }
+            else       { tests._skip = true }
+
+            return match;
+        })(tests, false);
+
+        batch._remaining = batch.remaining;
+    };
+
+    this.runBatch = function (batch) {
+        var topic,
+            tests   = batch.tests,
+            promise = batch.promise = new(events.EventEmitter);
+
+        var that = this;
+
+        batch.status = 'begin';
+
+        // The test runner, it calls itself recursively, passing the
+        // previous context to the inner contexts. This is so the `topic`
+        // functions have access to all the previous context topics in their
+        // arguments list.
+        // It is defined and invoked at the same time.
+        // If it encounters a `topic` function, it waits for the returned
+        // promise to emit (the topic), at which point it runs the functions under it,
+        // passing the topic as an argument.
+        (function run(ctx, lastTopic) {
+            var old = false;
+            topic = ctx.tests.topic;
+
+            if (typeof(topic) === 'function') {
+                // Run the topic, passing the previous context topics
+                topic = topic.apply(ctx.env, ctx.topics);
+
+                if (typeof(topic) === 'undefined') { ctx._callback = true }
+            }
+
+            // If this context has a topic, store it in `lastTopic`,
+            // if not, use the last topic, passed down by a parent
+            // context.
+            if (typeof(topic) !== 'undefined' || ctx._callback) {
+                lastTopic = topic;
+            } else {
+                old   = true;
+                topic = lastTopic;
+            }
+
+            // If the topic doesn't return an event emitter (such as a promise),
+            // we create it ourselves, and emit the value on the next tick.
+            if (! (topic && topic.constructor === events.EventEmitter)) {
+                ctx.emitter = new(events.EventEmitter);
+
+                if (! ctx._callback) {
+                    process.nextTick(function (val) {
+                        return function () { ctx.emitter.emit("success", val) };
+                    }(topic));
+                }
+                topic = ctx.emitter;
+            }
+
+            topic.on('success', function (val) {
+                // Once the topic fires, add the return value
+                // to the beginning of the topics list, so it
+                // becomes the first argument for the next topic.
+                // If we're using the parent topic, no need to
+                // prepend it to the topics list, or we'll get
+                // duplicates.
+                if (! old) Array.prototype.unshift.apply(ctx.topics, arguments);
+            });
+            if (topic.setMaxListeners) { topic.setMaxListeners(Infinity) }
+
+            // Now run the tests, or sub-contexts
+            Object.keys(ctx.tests).filter(function (k) {
+                return ctx.tests[k] && k !== 'topic'    &&
+                                       k !== 'teardown' && !ctx.tests[k]._skip;
+            }).forEach(function (item) {
+                // Create a new evaluation context,
+                // inheriting from the parent one.
+                var env = Object.create(ctx.env);
+                env.suite = that;
+
+                // Holds the current test or context
+                var vow = Object.create({
+                    callback: ctx.tests[item],
+                    context: ctx.title,
+                    description: item,
+                    binding: ctx.env,
+                    status: null,
+                    batch: batch
+                });
+
+                // If we encounter a function, add it to the callbacks
+                // of the `topic` function, so it'll get called once the
+                // topic fires.
+                // If we encounter an object literal, we recurse, sending it
+                // our current context.
+                if ((typeof(vow.callback) === 'function') || (vow.callback instanceof String)) {
+                    topic.addVow(vow);
+                } else if (typeof(vow.callback) === 'object') {
+                    // If there's a setup stage, we have to wait for it to fire,
+                    // before calling the inner context. Else, just run the inner context
+                    // synchronously.
+                    if (topic) {
+                        topic.on("success", function (ctx) {
+                            return function (val) {
+                                return run(new(Context)(vow, ctx, env), lastTopic);
+                            };
+                        }(ctx));
+                    } else {
+                        run(new(Context)(vow, ctx, env), lastTopic);
+                    }
+                }
+            });
+            // Teardown
+            if (ctx.tests.teardown) {
+                batch.teardowns.push(ctx);
+            }
+            if (! ctx.tests._skip) {
+                batch.remaining --;
+            }
+            // Check if we're done running the tests
+            exports.tryEnd(batch);
+        // This is our initial, empty context
+        })(new(Context)({ callback: tests, context: null, description: null }, {}));
+        return promise;
+    };
+
+    this.report = function () {
+        return this.reporter.report.apply(this.reporter, arguments);
+    };
+
+    this.run = function (options, callback) {
+        var that = this, start;
+
+        options = options || {};
+
+        for (var k in options) { this.options[k] = options[k] }
+
+        this.matcher  = this.options.matcher  || this.matcher;
+        this.reporter = this.options.reporter || this.reporter;
+
+        this.batches.forEach(function (batch) {
+            that.parseBatch(batch, that.matcher);
+        });
+
+        this.reset();
+
+        start = new(Date);
+
+        if (this.batches.filter(function (b) { return b.remaining > 0 }).length) {
+            this.report(['subject', this.subject]);
+        }
+
+        return (function run(batches) {
+            var batch = batches.shift();
+
+            if (batch) {
+                // If the batch has no vows to run,
+                // go to the next one.
+                if (batch.remaining === 0) {
+                    run(batches);
+                } else {
+                    that.runBatch(batch).on('end', function () {
+                        run(batches);
+                    });
+                }
+            } else {
+                that.results.time = (new(Date) - start) / 1000;
+                that.report(['finish', that.results]);
+
+                if (callback) { callback(that.results) }
+
+                if (that.results.honored + that.results.pending === that.results.total) {
+                    return 0;
+                } else {
+                    return 1;
+                }
+            }
+        })(this.batches.slice(0));
+    };
+
+    this.runParallel = function () {};
+
+    this.export = function (module, options) {
+        for (var k in (options || {})) { this.options[k] = options[k] }
+
+        if (require.main === module) {
+            return this.run();
+        } else {
+            return module.exports[this.subject] = this;
+        }
+    };
+    this.exportTo = function (module, options) { // Alias, for JSLint
+        return this.export(module, options);
+    };
+});
+
+//
+// Checks if all the tests in the batch have been run,
+// and triggers the next batch (if any), by emitting the 'end' event.
+//
+this.tryEnd = function (batch) {
+    var result, style, time;
+
+    if (batch.honored + batch.broken + batch.errored + batch.pending === batch.total &&
+        batch.remaining === 0) {
+
+        Object.keys(batch).forEach(function (k) {
+            (k in batch.suite.results) && (batch.suite.results[k] += batch[k]);
+        });
+
+        // Run teardowns
+        if (batch.teardowns) {
+            for (var i = batch.teardowns.length - 1, ctx; i >= 0; i--) {
+                ctx = batch.teardowns[i];
+                ctx.tests.teardown.apply(ctx.env, ctx.topics);
+            }
+        }
+
+        batch.status = 'end';
+        batch.suite.report(['end']);
+        batch.promise.emit('end', batch.honored, batch.broken, batch.errored, batch.pending);
+    }
+};