RubyGems - coffeecake - Versions diffs - 0.0.1 - Mend

coffeecake 0.0.1

Files changed (1336) hide show

data/node_modules/jasmine-runner/node_modules/socket.io/example/chat.html ADDED

@@ -0,0 +1,61 @@
+<!doctype html>
+<html>
+  <head>
+    <title>socket.io client test</title>
+    <script src="/json.js"></script> <!-- for ie -->
+    <script src="/socket.io/socket.io.js"></script>
+  </head>
+  <body>
+    <script>
+      function message(obj){
+        var el = document.createElement('p');
+        if ('announcement' in obj) el.innerHTML = '<em>' + esc(obj.announcement) + '</em>';
+        else if ('message' in obj) el.innerHTML = '<b>' + esc(obj.message[0]) + ':</b> ' + esc(obj.message[1]);
+        document.getElementById('chat').appendChild(el);
+        document.getElementById('chat').scrollTop = 1000000;
+      }
+      function send(){
+        var val = document.getElementById('text').value;
+        socket.send(val);
+        message({ message: ['you', val] });
+        document.getElementById('text').value = '';
+      }
+      function esc(msg){
+        return msg.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      };
+      var socket = new io.Socket(null, {port: 8080, rememberTransport: false});
+      socket.connect();
+      socket.on('message', function(obj){
+        if ('buffer' in obj){
+          document.getElementById('form').style.display='block';
+          document.getElementById('chat').innerHTML = '';
+          for (var i in obj.buffer) message(obj.buffer[i]);
+        } else message(obj);
+      });
+    </script>
+    <h1>Sample chat client</h1>
+    <div id="chat"><p>Connecting...</p></div>
+    <form id="form" onsubmit="send(); return false">
+      <input type="text" autocomplete="off" id="text"><input type="submit" value="Send">
+    </form>
+    <style>
+      #chat { height: 300px; overflow: auto; width: 800px; border: 1px solid #eee; font: 13px Helvetica, Arial; }
+      #chat p { padding: 8px; margin: 0; }
+      #chat p:nth-child(odd) { background: #F6F6F6; }
+      #form { width: 782px; background: #333; padding: 5px 10px; display: none; }
+      #form input[type=text] { width: 700px; padding: 5px; background: #fff; border: 1px solid #fff; }
+      #form input[type=submit] { cursor: pointer; background: #999; border: none; padding: 6px 8px; -moz-border-radius: 8px; -webkit-border-radius: 8px; margin-left: 5px; text-shadow: 0 1px 0 #fff; }
+      #form input[type=submit]:hover { background: #A2A2A2; }
+      #form input[type=submit]:active { position: relative; top: 2px; }
+    </style>
+  </body>
+</html>

data/node_modules/jasmine-runner/node_modules/socket.io/example/json.js ADDED

@@ -0,0 +1,18 @@
+if(!this.JSON){JSON=function(){function f(n){return n<10?'0'+n:n;}
+Date.prototype.toJSON=function(){return this.getUTCFullYear()+'-'+
+f(this.getUTCMonth()+1)+'-'+
+f(this.getUTCDate())+'T'+
+f(this.getUTCHours())+':'+
+f(this.getUTCMinutes())+':'+
+f(this.getUTCSeconds())+'Z';};var m={'\b':'\\b','\t':'\\t','\n':'\\n','\f':'\\f','\r':'\\r','"':'\\"','\\':'\\\\'};function stringify(value,whitelist){var a,i,k,l,r=/["\\\x00-\x1f\x7f-\x9f]/g,v;switch(typeof value){case'string':return r.test(value)?'"'+value.replace(r,function(a){var c=m[a];if(c){return c;}
+c=a.charCodeAt();return'\\u00'+Math.floor(c/16).toString(16)+
+(c%16).toString(16);})+'"':'"'+value+'"';case'number':return isFinite(value)?String(value):'null';case'boolean':case'null':return String(value);case'object':if(!value){return'null';}
+if(typeof value.toJSON==='function'){return stringify(value.toJSON());}
+a=[];if(typeof value.length==='number'&&!(value.propertyIsEnumerable('length'))){l=value.length;for(i=0;i<l;i+=1){a.push(stringify(value[i],whitelist)||'null');}
+return'['+a.join(',')+']';}
+if(whitelist){l=whitelist.length;for(i=0;i<l;i+=1){k=whitelist[i];if(typeof k==='string'){v=stringify(value[k],whitelist);if(v){a.push(stringify(k)+':'+v);}}}}else{for(k in value){if(typeof k==='string'){v=stringify(value[k],whitelist);if(v){a.push(stringify(k)+':'+v);}}}}
+return'{'+a.join(',')+'}';}}
+return{stringify:stringify,parse:function(text,filter){var j;function walk(k,v){var i,n;if(v&&typeof v==='object'){for(i in v){if(Object.prototype.hasOwnProperty.apply(v,[i])){n=walk(i,v[i]);if(n!==undefined){v[i]=n;}}}}
+return filter(k,v);}
+if(/^[\],:{}\s]*$/.test(text.replace(/\\./g,'@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,']').replace(/(?:^|:|,)(?:\s*\[)+/g,''))){j=eval('('+text+')');return typeof filter==='function'?walk('',j):j;}
+throw new SyntaxError('parseJSON');}};}();}

data/node_modules/jasmine-runner/node_modules/socket.io/example/server.js ADDED

@@ -0,0 +1,58 @@
+var http = require('http'),
+		url = require('url'),
+		fs = require('fs'),
+		io = require('../'),
+		sys = require('sys'),
+server = http.createServer(function(req, res){
+	// your normal server code
+	var path = url.parse(req.url).pathname;
+	switch (path){
+		case '/':
+			res.writeHead(200, {'Content-Type': 'text/html'});
+			res.write('<h1>Welcome. Try the <a href="/chat.html">chat</a> example.</h1>');
+			res.end();
+			break;
+		case '/json.js':
+		case '/chat.html':
+			fs.readFile(__dirname + path, function(err, data){
+				if (err) return send404(res);
+				res.writeHead(200, {'Content-Type': path == 'json.js' ? 'text/javascript' : 'text/html'})
+				res.write(data, 'utf8');
+				res.end();
+			});
+			break;
+		default: send404(res);
+	}
+}),
+send404 = function(res){
+	res.writeHead(404);
+	res.write('404');
+	res.end();
+};
+server.listen(8080);
+// socket.io, I choose you
+// simplest chat application evar
+var io = io.listen(server),
+		buffer = [];
+io.on('connection', function(client){
+	client.send({ buffer: buffer });
+	client.broadcast({ announcement: client.sessionId + ' connected' });
+	client.on('message', function(message){
+		var msg = { message: [client.sessionId, message] };
+		buffer.push(msg);
+		if (buffer.length > 15) buffer.shift();
+		client.broadcast(msg);
+	});
+	client.on('disconnect', function(){
+		client.broadcast({ announcement: client.sessionId + ' disconnected' });
+	});
+});

data/node_modules/jasmine-runner/node_modules/socket.io/index.js ADDED

	@@ -0,0 +1 @@
1	+ module.exports = require('./lib/socket.io');

data/node_modules/jasmine-runner/node_modules/socket.io/lib/socket.io/client.js ADDED

@@ -0,0 +1,191 @@
+var urlparse = require('url').parse
+  , OutgoingMessage = require('http').OutgoingMessage
+  , Stream = require('net').Stream
+  , options = require('./utils').options
+  , encode = require('./utils').encode
+  , decode = require('./utils').decode
+  , merge = require('./utils').merge;
+var Client = module.exports = function(listener, req, res, options, head){
+  process.EventEmitter.call(this);
+  this.listener = listener;
+  this.options(merge({
+    timeout: 8000,
+    heartbeatInterval: 10000,
+    closeTimeout: 0
+  }, this.getOptions ? this.getOptions() : {}), options);
+  this.connections = 0;
+  this._open = false;
+  this._heartbeats = 0;
+  this.connected = false;
+  this.upgradeHead = head;
+  this._onConnect(req, res);
+};
+require('sys').inherits(Client, process.EventEmitter);
+Client.prototype.send = function(message){
+  if (!this._open || !(this.connection.readyState === 'open' || this.connection.readyState === 'writeOnly')){
+    return this._queue(message);
+  }
+  this._write(encode(message));
+  return this;
+};
+Client.prototype.broadcast = function(message){
+  if (!('sessionId' in this)) return this;
+  this.listener.broadcast(message, this.sessionId);
+  return this;
+};
+Client.prototype._onMessage = function(data){
+  var messages = decode(data);
+  if (messages === false) return this.listener.options.log('Bad message received from client ' + this.sessionId);
+  for (var i = 0, l = messages.length, frame; i < l; i++){
+    frame = messages[i].substr(0, 3);
+    switch (frame){
+      case '~h~':
+        return this._onHeartbeat(messages[i].substr(3));
+      case '~j~':
+        messages[i] = JSON.parse(messages[i].substr(3));
+        break;
+    }
+    this.emit('message', messages[i]);
+    this.listener._onClientMessage(messages[i], this);
+  }
+};
+Client.prototype._onConnect = function(req, res){
+  var self = this;
+  this.request = req;
+  this.response = res;
+  this.connection = req.connection;
+  this.connection.addListener('end', function(){
+    self._onClose();
+    self.connection.end();
+    self.connection.destroy();
+  });
+  if (req){
+    req.addListener('error', function(err){
+      req.end && req.end() || req.destroy && req.destroy();
+    });
+    if (res) res.addListener('error', function(err){
+      res.end && res.end() || res.destroy && res.destroy();
+    });
+    req.connection.addListener('error', function(err){
+      req.connection.end && req.connection.end() || req.connection.destroy && req.connection.destroy();
+    });
+    if (this._disconnectTimeout) clearTimeout(this._disconnectTimeout);
+  }
+};
+Client.prototype._payload = function(){
+  var payload = [];
+  this.connections++;
+  this.connected = true;
+  this._open = true;
+  if (!this.handshaked){
+    this._generateSessionId();
+    payload.push(this.sessionId);
+    this.handshaked = true;
+  }
+  payload = payload.concat(this._writeQueue || []);
+  this._writeQueue = [];
+  if (payload.length) this._write(encode(payload));
+  if (this.connections === 1) this.listener._onClientConnect(this);
+  if (this.options.timeout) this._heartbeat();
+};
+Client.prototype._heartbeat = function(){
+  var self = this;
+  this._heartbeatInterval = setTimeout(function(){
+    self.send('~h~' + ++self._heartbeats);
+    self._heartbeatTimeout = setTimeout(function(){
+      self._onClose();
+    }, self.options.timeout);
+  }, self.options.heartbeatInterval);
+};
+Client.prototype._onHeartbeat = function(h){
+  if (h == this._heartbeats){
+    clearTimeout(this._heartbeatTimeout);
+    this._heartbeat();
+  }
+};
+Client.prototype._onClose = function(skipDisconnect){
+  if (this._open){
+    var self = this;
+    if ('_heartbeatInterval' in this) clearTimeout(this._heartbeatInterval);
+    if ('_heartbeatTimeout' in this) clearTimeout(this._heartbeatTimeout);
+    this._open = false;
+    if (skipDisconnect !== false){
+      if (this.handshaked)
+        this._disconnectTimeout = setTimeout(function(){
+          self._onDisconnect();
+        }, this.options.closeTimeout);
+      else
+        this._onDisconnect();
+    }
+  }
+};
+Client.prototype._onDisconnect = function(){
+  if (this._open) this._onClose(true);
+  if (this._disconnectTimeout) clearTimeout(this._disconnectTimeout);
+  if (this.connected){
+    this._writeQueue = [];
+    this._open = false;
+    this.connected = false;
+    this.request = null;
+    this.response = null;
+    if (this.connection){
+      this.connection.end();
+      this.connection.destroy();
+      this.connection = null;
+    }
+    if (this.handshaked){
+      this.emit('disconnect');
+      this.listener._onClientDisconnect(this);
+    }
+  }
+};
+Client.prototype._queue = function(message){
+  this._writeQueue = this._writeQueue || [];
+  this._writeQueue.push(message);
+  return this;
+};
+Client.prototype._generateSessionId = function(){
+  if (this.sessionId) return this.listener.options.log('This client already has a session id');
+  this.sessionId = Math.random().toString().substr(2);
+  return this;
+};
+Client.prototype._verifyOrigin = function(origin){
+  var origins = this.listener.options.origins;
+  if (origins.indexOf('*:*') !== -1) {
+    return true;
+  }
+  if (origin) {
+    try {
+      var parts = urlparse(origin);
+      return origins.indexOf(parts.host + ':' + parts.port) !== -1 ||
+          origins.indexOf(parts.host + ':*') !== -1 ||
+          origins.indexOf('*:' + parts.port) !== -1;
+    } catch (ex) {}
+  }
+  return false;
+};
+for (var i in options) Client.prototype[i] = options[i];

data/node_modules/jasmine-runner/node_modules/socket.io/lib/socket.io/index.js ADDED

@@ -0,0 +1,4 @@
+exports.Listener = require('./listener');
+exports.listen = function(server, options){
+  return new exports.Listener(server, options);
+};

data/node_modules/jasmine-runner/node_modules/socket.io/lib/socket.io/listener.js ADDED

@@ -0,0 +1,166 @@
+var url = require('url')
+  , sys = require('sys')
+  , fs = require('fs')
+  , options = require('./utils').options
+  , Client = require('./client')
+  , clientVersion = require('./../../support/socket.io-client/lib/io').io.version
+  , transports = {
+      'flashsocket': require('./transports/flashsocket')
+    , 'htmlfile': require('./transports/htmlfile')
+    , 'websocket': require('./transports/websocket')
+    , 'xhr-multipart': require('./transports/xhr-multipart')
+    , 'xhr-polling': require('./transports/xhr-polling')
+    , 'jsonp-polling': require('./transports/jsonp-polling')
+    };
+var Listener = module.exports = function(server, options){
+  process.EventEmitter.call(this);
+  var self = this;
+  this.server = server;
+  this.options({
+    origins: '*:*',
+    resource: 'socket.io',
+    transports: ['websocket', 'flashsocket', 'htmlfile', 'xhr-multipart', 'xhr-polling', 'jsonp-polling'],
+    transportOptions: {},
+    log: sys.log
+  }, options);
+  if (!this.options.log) this.options.log = function(){};
+  this.clients = this.clientsIndex = {};
+  this._clientFiles = {};
+  var listeners = this.server.listeners('request');
+  this.server.removeAllListeners('request');
+  this.server.addListener('request', function(req, res){
+    if (self.check(req, res)) return;
+    for (var i = 0, len = listeners.length; i < len; i++){
+      listeners[i].call(this, req, res);
+    }
+  });
+  this.server.addListener('upgrade', function(req, socket, head){
+    if (!self.check(req, socket, true, head)){
+      socket.end();
+      socket.destroy();
+    }
+  });
+  for (var i in transports)
+    if ('init' in transports[i]) transports[i].init(this);
+  this.options.log('socket.io ready - accepting connections');
+};
+sys.inherits(Listener, process.EventEmitter);
+for (var i in options) Listener.prototype[i] = options[i];
+Listener.prototype.broadcast = function(message, except){
+  for (var i = 0, k = Object.keys(this.clients), l = k.length; i < l; i++){
+    if (this.clients[k[i]] && (!except || [].concat(except).indexOf(this.clients[k[i]].sessionId) == -1)){
+      this.clients[k[i]].send(message);
+    }
+  }
+  return this;
+};
+Listener.prototype.check = function(req, res, httpUpgrade, head){
+  var path = url.parse(req.url).pathname, parts, cn;
+  if (path && path.indexOf('/' + this.options.resource) === 0){
+    parts = path.substr(1).split('/');
+    if (this._serveClient(parts.slice(1).join('/'), req, res)) return true;
+    if (!(parts[1] in transports)) return false;
+    if (parts[2]){
+      cn = this.clients[parts[2]];
+      if (cn){
+        cn._onConnect(req, res);
+      } else {
+        req.connection.end();
+        req.connection.destroy();
+        this.options.log('Couldnt find client with session id "' + parts[2] + '"');
+      }
+    } else {
+      this._onConnection(parts[1], req, res, httpUpgrade, head);
+    }
+    return true;
+  }
+  return false;
+};
+Listener.prototype._serveClient = function(file, req, res){
+  var self = this
+    , clientPaths = {
+        'socket.io.js': 'socket.io.js',
+        'lib/vendor/web-socket-js/WebSocketMain.swf': 'lib/vendor/web-socket-js/WebSocketMain.swf', // for compat with old clients
+        'WebSocketMain.swf': 'lib/vendor/web-socket-js/WebSocketMain.swf'
+      }
+    , types = {
+        swf: 'application/x-shockwave-flash',
+        js: 'text/javascript'
+      };
+  function write(path){
+    if (req.headers['if-none-match'] == clientVersion){
+      res.writeHead(304);
+      res.end();
+    } else {
+      res.writeHead(200, self._clientFiles[path].headers);
+      res.end(self._clientFiles[path].content, self._clientFiles[path].encoding);
+    }
+  };
+  var path = clientPaths[file];
+  if (req.method == 'GET' && path !== undefined){
+    if (path in this._clientFiles){
+      write(path);
+      return true;
+    }
+    fs.readFile(__dirname + '/../../support/socket.io-client/' + path, function(err, data){
+      if (err){
+        res.writeHead(404);
+        res.end('404');
+      } else {
+        var ext = path.split('.').pop();
+        self._clientFiles[path] = {
+          headers: {
+            'Content-Length': data.length,
+            'Content-Type': types[ext],
+            'ETag': clientVersion
+          },
+          content: data,
+          encoding: ext == 'swf' ? 'binary' : 'utf8'
+        };
+        write(path);
+      }
+    });
+    return true;
+  }
+  return false;
+};
+Listener.prototype._onClientConnect = function(client){
+  this.clients[client.sessionId] = client;
+  this.options.log('Client '+ client.sessionId +' connected');
+  this.emit('clientConnect', client);
+  this.emit('connection', client);
+};
+Listener.prototype._onClientMessage = function(data, client){
+  this.emit('clientMessage', data, client);
+};
+Listener.prototype._onClientDisconnect = function(client){
+  delete this.clients[client.sessionId];
+  this.options.log('Client '+ client.sessionId +' disconnected');
+  this.emit('clientDisconnect', client);
+};
+Listener.prototype._onConnection = function(transport, req, res, httpUpgrade, head){
+  this.options.log('Initializing client with transport "'+ transport +'"');
+  new transports[transport](this, req, res, this.options.transportOptions[transport], head);
+};