coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/socket.io/tests/transports.xhr-polling.js

@@ -0,0 +1,138 @@
+var io = require('socket.io')
+  , http = require('http')
+  , querystring = require('querystring')
+  , port = 7400
+  , encode = require('socket.io/utils').encode
+  , decode = require('socket.io/utils').decode
+  , Polling = require('socket.io/transports/xhr-polling');
+
+function server(callback){
+  return http.createServer(function(){});
+};
+
+function listen(s, callback){
+  s._port = port;
+  s.listen(port, callback);
+  port++;
+  return s;
+};
+
+function client(s){
+  return http.createClient(s._port, 'localhost');
+};
+
+function socket(server, options){
+  if (!options) options = {};
+  options.log = false;
+  if (!options.transportOptions) options.transportOptions = { 
+    'xhr-polling': {
+      closeTimeout: 100
+    }
+  };
+  return io.listen(server, options);
+};
+
+function get(client, url, callback){
+  var request = client.request('GET', url, {host: 'localhost'});
+  request.end();
+  request.on('response', function(response){
+    var data = '';
+    response.setEncoding('utf8');
+    response.on('data', function(chunk){
+      data += chunk;
+    });
+    response.on('end', function(chunk){
+      callback(data);
+    });
+  });
+};
+
+function post(client, url, data, callback){
+  var query = querystring.stringify(data)
+    , request = client.request('POST', url, {'Content-Length': Buffer.byteLength(query)});
+  request.write(query);
+  request.end();
+};
+
+module.exports = {
+  
+  'test connection and handshake': function(assert){
+    var _server = server()
+      , _socket = socket(_server)
+      , trips = 2;
+
+    _socket.on('connection', function(client){
+      assert.ok(client instanceof Polling);
+      client.on('message', function(msg){
+        assert.ok(msg == 'from client');
+        --trips || _server.close();
+      });
+    });
+
+    listen(_server, function(){
+      get(client(_server), '/socket.io/xhr-polling', function(data){
+        var sessid = decode(data);
+        assert.ok(Object.keys(_socket.clients).length == 1);
+        assert.ok(sessid == Object.keys(_socket.clients)[0]);
+        assert.ok(_socket.clients[sessid] instanceof Polling);
+        
+        _socket.clients[sessid].send('from server');
+        
+        get(client(_server), '/socket.io/xhr-polling/' + sessid, function(data){
+          assert.ok(decode(data), 'from server');
+          --trips || _server.close();
+        });
+        
+        post(client(_server), '/socket.io/xhr-polling/' + sessid + '/send', {data: encode('from client')});
+      });
+    });
+  },
+  
+  'test clients tracking': function(assert){
+    var _server = server()
+      , _socket = socket(_server);
+    
+    listen(_server, function(){
+      get(client(_server), '/socket.io/xhr-polling', function(){
+        assert.ok(Object.keys(_socket.clients).length == 1);
+        get(client(_server), '/socket.io/xhr-polling', function(){
+          assert.ok(Object.keys(_socket.clients).length == 2);
+          _server.close();
+        });
+      });
+    });
+  },
+  
+  'test buffered messages': function(assert){
+    var _server = server()
+      , _socket = socket(_server, { transportOptions: { 
+        'xhr-polling': {
+          closeTimeout: 100,
+          duration: 200
+        }
+      } });
+      
+    listen(_server, function(){
+      get(client(_server), '/socket.io/xhr-polling', function(data){
+        var sessid = decode(data);
+        assert.ok(_socket.clients[sessid]._open === false);
+        assert.ok(_socket.clients[sessid].connected);
+        _socket.clients[sessid].send('from server');
+        get(client(_server), '/socket.io/xhr-polling/' + sessid, function(data){
+          var durationCheck;
+          assert.ok(decode(data) == 'from server');
+          setTimeout(function(){
+            assert.ok(_socket.clients[sessid]._open);
+            assert.ok(_socket.clients[sessid].connected);
+            durationCheck = true;
+          }, 100);
+          get(client(_server), '/socket.io/xhr-polling/' + sessid, function(){
+            assert.ok(durationCheck);
+            _server.close();
+          });
+        });
+      });
+    });
+  }
+  
+};

data/node_modules/jasmine-runner/node_modules/socket.io/tests/utils.js

@@ -0,0 +1,25 @@
+var encode = require('socket.io/utils').encode,
+    decode = require('socket.io/utils').decode;
+
+module.exports = {
+  'test decoding': function(assert){
+    var decoded = decode('~m~5~m~abcde' + '~m~9~m~123456789');
+    assert.equal(decoded.length, 2);
+    assert.equal(decoded[0], 'abcde');
+    assert.equal(decoded[1], '123456789');
+  },
+  
+  'test decoding of bad framed messages': function(assert){
+    var decoded = decode('~m~5~m~abcde' + '~m\uffsdaasdfd9~m~1aaa23456789');
+    assert.equal(decoded.length, 1);
+    assert.equal(decoded[0], 'abcde');
+    assert.equal(decoded[1], undefined);
+  },
+  
+  'test encoding': function(assert){
+    assert.equal(encode(['abcde', '123456789']), '~m~5~m~abcde' + '~m~9~m~123456789');
+    assert.equal(encode('asdasdsad'), '~m~9~m~asdasdsad');
+    assert.equal(encode(''), '~m~0~m~');
+    assert.equal(encode(null), '~m~0~m~');
+  }
+};

data/node_modules/jasmine-runner/node_modules/vows/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 cloudhead
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/node_modules/jasmine-runner/node_modules/vows/Makefile

@@ -0,0 +1,7 @@
+#
+# Run all tests
+#
+test: 
+	@@bin/vows test/*
+
+.PHONY: test install

data/node_modules/jasmine-runner/node_modules/vows/README.md

@@ -0,0 +1,39 @@
+Vows
+====
+
+> Asynchronous BDD & continuous integration for node.js
+
+#### <http://vowsjs.org> #
+
+introduction
+------------
+There are two reasons why we might want asynchronous testing. The first, and obvious reason is that node.js is asynchronous, and therefore our tests need to be. The second reason is to make test suites which target I/O libraries run much faster.
+
+_Vows_ is an experiment in making this possible, while adding a minimum of overhead.
+
+synopsis
+--------
+
+    var vows = require('vows'),
+        assert = require('assert');
+
+    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);
+            }
+        }
+    });
+
+installation
+------------
+
+    $ npm install vows
+
+documentation
+-------------
+
+Head over to <http://vowsjs.org>
+

data/node_modules/jasmine-runner/node_modules/vows/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);
+}