coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/.bin/jade

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys'),
+    jade = require('jade'),
+    fs = require('fs');
+
+/**
+ * Arguments.
+ */
+
+var args = process.argv.slice(2);
+
+/**
+ * Output to stdout.
+ */
+
+var pipe;
+
+/**
+ * Options javascript.
+ */
+
+var options = {};
+
+/**
+ * Usage information.
+ */
+
+var usage = ''
+    + '\x1b[1mUsage\x1b[0m: jade [options] <path ...>\n'
+    + '\n'
+    + '\x1b[1mOptions:\x1b[0m\n'
+    + '  -o, --options STR   JavaScript options object passed\n'
+    + '  -p, --pipe          Output to stdout instead of PATH.html\n'
+    + '  -h, --help          Output help information\n';
+
+// Parse arguments
+
+var arg,
+    files = [];
+while (args.length) {
+    arg = args.shift();
+    switch (arg) {
+        case '-h':
+        case '--help':
+            sys.puts(usage);
+            process.exit(1);
+            break;
+        case '-p':
+        case '--pipe':
+            pipe = true;
+            break;
+        case '-o':
+        case '--options':
+            var str = args.shift();
+            if (str) {
+                options = eval('(' + str + ')');
+            } else {
+                sys.error('-o, --options requires a string.');
+                process.exit(1);
+            }
+            break;
+        default:
+            files.push(arg);
+    }
+}
+
+// Render files
+
+if (files.length) {
+    files.forEach(function(file){
+        jade.renderFile(file, options, function(err, html){
+            if (err) throw err;
+            if (pipe) {
+                sys.puts(html);
+            }  else {
+                file = file.replace(/\.jade$/, '.html');
+                fs.writeFile(file, html, function(err){
+                    if (err) throw err;
+                    sys.error('  create : ' + file);
+                });
+            }
+        });
+    });
+} else {
+    sys.error('files required.');
+    process.exit(1);
+}

data/node_modules/jasmine-runner/node_modules/.bin/vows

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+var path   = require('path'),
+    fs     = require('fs'),
+    util   = require('util'),
+    events = require('events');
+
+//
+// Attempt to load Coffee-Script. If it's not available, continue on our
+// merry way, if it is available, set it up so we can include `*.coffee`
+// scripts and start searching for them.
+//
+var fileExt, specFileExt;
+
+try {
+    var coffee = require('coffee-script');
+    if (require.extensions) {
+        require.extensions['.coffee'] = function (module, filename) {
+            var content = coffee.compile(fs.readFileSync(filename, 'utf8'));
+            return module._compile(content, filename);
+        };
+    } else {
+        require.registerExtension('.coffee', function (content) { return coffee.compile(content) });
+    }
+    fileExt     = /\.(js|coffee)$/;
+    specFileExt = /[.-](test|spec)\.(js|coffee)$/;
+} catch (_) {
+    fileExt     = /\.js$/;
+    specFileExt = /[.-](test|spec)\.js$/;
+}
+
+var inspect = require('eyes').inspector({
+    stream: null,
+    styles: { string: 'grey', regexp: 'grey' }
+});
+
+require.paths.unshift(path.join(__dirname, '..', 'lib'));
+
+var vows = require('vows');
+var cutils = require('vows/console');
+var stylize = require('vows/console').stylize;
+var _reporter = require('vows/reporters/dot-matrix'), reporter = {
+    name: _reporter.name,
+};
+
+var help = [
+    "usage: vows [FILE, ...] [options]",
+    "",
+    "options:",
+    "  -v, --verbose     Enable verbose output",
+    "  -w, --watch       Watch mode",
+    "  -s, --silent      Don't report",
+    "  -m  PATTERN       Only run tests matching the PATTERN string",
+    "  -r  PATTERN       Only run tests matching the PATTERN regexp",
+    "  --json            Use JSON reporter",
+    "  --spec            Use Spec reporter",
+    "  --dot-matrix      Use Dot-Matrix reporter",
+    "  --xunit           Use xUnit reporter",
+    //"  --no-color        Don't use terminal colors",
+    "  --version         Show version",
+    "  -h, --help        You're staring at it"
+].join('\n');
+
+var options = {
+    reporter: reporter,
+    matcher: /.*/,
+    watch: false
+};
+
+var files = [];
+
+// Get rid of process runner
+// ('node' in most cases)
+var arg, args = [], argv = process.argv.slice(2);
+
+// Current directory index,
+// and path of test folder.
+var root, testFolder;
+
+//
+// Parse command-line parameters
+//
+while (arg = argv.shift()) {
+    if (arg === __filename) { continue }
+
+    if (arg[0] !== '-') {
+        args.push(arg);
+    } else {
+        arg = arg.match(/^--?(.+)/)[1];
+
+        if (arg[0] === 'r') {
+            options.matcher = new(RegExp)(argv.shift());
+        } else if (arg[0] === 'm') {
+            options.matcher = (function (str) { // Create an escaped RegExp
+                var specials = '. * + ? | ( ) [ ] { } \\ ^ ? ! = : $'.split(' ').join('|\\'),
+                    regex    = new(RegExp)('(\\' + specials + ')', 'g');
+                return new(RegExp)(str.replace(regex, '\\$1'));
+            })(argv.shift());
+        } else if (arg in options) {
+            options[arg] = true;
+        } else {
+            switch (arg) {
+                case 'json':
+                    _reporter = require('vows/reporters/json');
+                    break;
+                case 'spec':
+                    _reporter = require('vows/reporters/spec');
+                    break;
+                case 'dot-matrix':
+                    _reporter = require('vows/reporters/dot-matrix');
+                    break;
+                case 'silent':
+                case 's':
+                    _reporter = require('vows/reporters/silent');
+                    break;
+                case 'xunit':
+                    _reporter = require('vows/reporters/xunit');
+                    break;
+                case 'verbose':
+                case 'v':
+                    options.verbose = true;
+                    break;
+                case 'watch':
+                case 'w':
+                    options.watch = true;
+                    break;
+                case 'no-color':
+                    options.nocolor = true;
+                    break;
+                case 'no-error':
+                    options.error = false;
+                    break;
+                case 'version':
+                    console.log('vows ' + vows.version);
+                    process.exit(0);
+                case 'help':
+                case 'h':
+                    console.log(help);
+                    process.exit(0);
+                    break;
+            }
+        }
+    }
+}
+
+if (options.watch) {
+    options.reporter = reporter = require('vows/reporters/watch');
+}
+
+msg('bin', 'argv', args);
+msg('bin', 'options', { reporter: options.reporter.name, matcher: options.matcher });
+
+if (args.length === 0 || options.watch) {
+    msg('bin', 'discovering', 'folder structure');
+    root = fs.readdirSync('.');
+
+    if (root.indexOf('test') !== -1) {
+        testFolder = 'test';
+    } else if (root.indexOf('spec') !== -1) {
+        testFolder = 'spec';
+    } else {
+        abort("runner", "couldn't find test folder");
+    }
+    msg('bin', 'discovered', "./" + testFolder);
+
+    if (args.length === 0) {
+        args = paths(testFolder).filter(function (f) {
+            return new(RegExp)('-' + testFolder + '.(js|coffee)$').test(f);
+        });
+
+        if (options.watch) {
+            args = args.concat(paths('lib'),
+                               paths('src'));
+        }
+    }
+}
+
+if (! options.watch) {
+    reporter.report = function (data, filename) {
+        switch (data[0]) {
+            case 'subject':
+            case 'vow':
+            case 'context':
+            case 'error':
+                _reporter.report(data, filename);
+                break;
+            case 'end':
+                (options.verbose || _reporter.name === 'json') && _reporter.report(data);
+                break;
+            case 'finish':
+                options.verbose ? _reporter.print('\n') : _reporter.print(' ');
+                break;
+        }
+    };
+    reporter.reset = function () { _reporter.reset && _reporter.reset() };
+    reporter.print = _reporter.print;
+
+    files = args.map(function (a) {
+        return path.join(process.cwd(), a.replace(fileExt, ''));
+    });
+
+    runSuites(importSuites(files), function (results) {
+        var status = results.errored ? 2 : (results.broken ? 1 : 0);
+
+        !options.verbose && _reporter.print('\n');
+        msg('runner', 'finish');
+        _reporter.report(['finish', results], {
+            write: function (str) {
+                util.print(str.replace(/^\n\n/, '\n'));
+            }
+        });
+        if (process.stdout.write('')) { // Check if stdout is drained
+            process.exit(status);
+        } else {
+            process.stdout.on('drain', function () {
+                process.exit(status);
+            });
+        }
+    });
+} else {
+    //
+    // Watch mode
+    //
+    (function () {
+        var pendulum = [
+            '.   ', '..  ', '... ', ' ...',
+            '  ..', '   .', '   .', '  ..',
+            '... ', '..  ', '.   '
+        ];
+        var strobe = ['.', ' '];
+        var status,
+            cue,
+            current = 0,
+            running = 0,
+            lastRun,
+            colors = ['32m', '33m', '31m'],
+            timer = setInterval(tick, 100);
+
+        process.on('uncaughtException', cleanup);
+        process.on('exit', cleanup);
+        process.on('SIGINT', function () {
+            process.exit(0);
+        });
+        process.on('SIGQUIT', function () {
+            changed();
+        });
+
+        cursorHide();
+
+        // Run every 100ms
+        function tick() {
+            if (running && (cue !== strobe)) {
+                cue = strobe, current = 0;
+            } else if (!running && (cue !== pendulum)) {
+                cue = pendulum, current = 0;
+            }
+
+            eraseLine();
+            lastRun && !running && esc(colors[status.errored ? 2 : (status.broken ? 1 : 0)]);
+            print(cue[current]);
+
+            if (current == cue.length - 1) { current = -1 }
+
+            current ++;
+            esc('39m');
+            cursorRestore();
+        }
+
+        //
+        // Utility functions
+        //
+        function print(str)      { util.print(str) }
+        function esc(str)        { print("\x1b[" + str) }
+        function eraseLine()     { esc("0K") }
+        function cursorRestore() { esc("0G") }
+        function cursorHide()    { esc("?25l") }
+        function cursorShow()    { esc("?25h") }
+        function cleanup()       { eraseLine(), cursorShow(), clearInterval(timer), print('\n') }
+
+        //
+        // Called when a file has been modified.
+        // Run the matching tests and change the status.
+        //
+        function changed(file) {
+            status = { honored: 0, broken: 0, errored: 0, pending: 0 };
+
+            msg('watcher', 'detected change in', file);
+
+            file = (specFileExt.test(file) ? path.join(testFolder, file)
+                                           : path.join(testFolder, file + '-' + testFolder));
+
+            try {
+                fs.statSync(file);
+            } catch (e) {
+                msg('watcher', 'no equivalence found, running all tests.');
+                file = null;
+            }
+
+            var files = (specFileExt.test(file) ? [file] : paths(testFolder)).map(function (p) {
+                return path.join(process.cwd(), p);
+            }).map(function (p) {
+                var cache = require.main.moduleCache || require.cache;
+                if (cache[p]) { delete(cache[p]) }
+                return p;
+            }).map(function (p) {
+                return p.replace(fileExt, '');
+            });
+
+            running ++;
+
+            runSuites(importSuites(files), function (results) {
+                delete(results.time);
+                print(cutils.result(results).join('') + '\n\n');
+                lastRun = new(Date);
+                status = results;
+                running --;
+            });
+        }
+
+        msg('watcher', 'watching', args);
+
+        //
+        // Watch all relevant files,
+        // and call `changed()` on change.
+        //
+        args.forEach(function (p) {
+            fs.watchFile(p, function (current, previous) {
+                if (new(Date)(current.mtime).valueOf() ===
+                    new(Date)(previous.mtime).valueOf()) { return }
+                else {
+                    changed(p);
+                }
+            });
+        });
+    })();
+}
+
+function runSuites(suites, callback) {
+    var results = {
+        honored: 0,
+        broken:  0,
+        errored: 0,
+        pending: 0,
+        total:   0,
+        time:    0
+    };
+    reporter.reset();
+
+    (function run(suites, callback) {
+        var suite = suites.shift();
+        if (suite) {
+            msg('runner', "running", suite.subject + ' ', options.watch ? false : true);
+            suite.run(options, function (result) {
+                Object.keys(result).forEach(function (k) {
+                    results[k] += result[k];
+                });
+                run(suites, callback);
+            });
+        } else {
+            callback(results);
+        }
+    })(suites, callback);
+}
+
+function importSuites(files) {
+    msg(options.watcher ? 'watcher' : 'runner', 'loading', files);
+
+    return files.reduce(function (suites, f) {
+        var obj = require(f);
+        return suites.concat(Object.keys(obj).map(function (s) {
+            obj[s]._filename = f.replace(process.cwd() + '/', '') + '.js';
+            return obj[s];
+        }));
+    }, [])
+}
+
+//
+// Recursively traverse a hierarchy, returning
+// a list of all relevant .js files.
+//
+function paths(dir) {
+    var paths = [];
+
+    try { fs.statSync(dir) }
+    catch (e) { return [] }
+
+    (function traverse(dir, stack) {
+        stack.push(dir);
+        fs.readdirSync(stack.join('/')).forEach(function (file) {
+            var path = stack.concat([file]).join('/'),
+                stat = fs.statSync(path);
+
+            if (file[0] == '.' || file === 'vendor') {
+                return;
+            } else if (stat.isFile() && fileExt.test(file)) {
+                paths.push(path);
+            } else if (stat.isDirectory()) {
+                traverse(file, stack);
+            }
+        });
+        stack.pop();
+    })(dir || '.', []);
+
+    return paths;
+}
+
+function msg(cmd, subject, str, p) {
+    if (options.verbose) {
+        util[p ? 'print' : 'puts']( stylize('vows ', 'green')
+              + stylize(cmd, 'bold')
+              + ' ' + subject + ' '
+              + (str ? (typeof(str) === 'string' ? str : inspect(str)) : '')
+              );
+    }
+}
+
+function abort(cmd, str) {
+    console.log(stylize('vows ', 'red') + stylize(cmd, 'bold') + ' ' + str);
+    console.log(stylize('vows ', 'red') + stylize(cmd, 'bold') + ' exiting');
+    process.exit(-1);
+}