coffeecake 0.0.1

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

@@ -0,0 +1,24 @@
+/**
+ * Socket.IO client
+ * 
+ * @author Guillermo Rauch <guillermo@learnboost.com>
+ * @license The MIT license.
+ * @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+ */
+
+this.io = {
+	version: '0.6',
+	
+	setPath: function(path){
+		if (window.console && console.error) console.error('io.setPath will be removed. Please set the variable WEB_SOCKET_SWF_LOCATION pointing to WebSocketMain.swf');
+		this.path = /\/$/.test(path) ? path : path + '/';
+		WEB_SOCKET_SWF_LOCATION = path + 'lib/vendor/web-socket-js/WebSocketMain.swf';
+	}
+};
+
+if ('jQuery' in this) jQuery.io = this.io;
+
+if (typeof window != 'undefined'){
+  // WEB_SOCKET_SWF_LOCATION = (document.location.protocol == 'https:' ? 'https:' : 'http:') + '//cdn.socket.io/' + this.io.version + '/WebSocketMain.swf';
+  WEB_SOCKET_SWF_LOCATION = '/socket.io/lib/vendor/web-socket-js/WebSocketMain.swf';
+}

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

@@ -0,0 +1,157 @@
+/**
+ * Socket.IO client
+ * 
+ * @author Guillermo Rauch <guillermo@learnboost.com>
+ * @license The MIT license.
+ * @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+ */
+
+(function(){
+	
+	var Socket = io.Socket = function(host, options){
+		this.host = host || document.domain;
+		this.options = {
+			secure: false,
+			document: document,
+			port: document.location.port || 80,
+			resource: 'socket.io',
+			transports: ['websocket', 'flashsocket', 'htmlfile', 'xhr-multipart', 'xhr-polling', 'jsonp-polling'],
+			transportOptions: {
+				'xhr-polling': {
+					timeout: 25000 // based on polling duration default
+				},
+				'jsonp-polling': {
+					timeout: 25000
+				}
+			},
+			connectTimeout: 5000,
+			tryTransportsOnConnectTimeout: true,
+			rememberTransport: true
+		};
+		io.util.merge(this.options, options);
+		this.connected = false;
+		this.connecting = false;
+		this._events = {};
+		this.transport = this.getTransport();
+		if (!this.transport && 'console' in window) console.error('No transport available');
+	};
+	
+	Socket.prototype.getTransport = function(override){
+		var transports = override || this.options.transports, match;
+		if (this.options.rememberTransport && !override){
+			match = this.options.document.cookie.match('(?:^|;)\\s*socketio=([^;]*)');
+			if (match){
+				this._rememberedTransport = true;
+				transports = [decodeURIComponent(match[1])];
+			}
+		} 
+		for (var i = 0, transport; transport = transports[i]; i++){
+			if (io.Transport[transport] 
+				&& io.Transport[transport].check() 
+				&& (!this._isXDomain() || io.Transport[transport].xdomainCheck())){
+				return new io.Transport[transport](this, this.options.transportOptions[transport] || {});
+			}
+		}
+		return null;
+	};
+	
+	Socket.prototype.connect = function(){
+		if (this.transport && !this.connected){
+			if (this.connecting) this.disconnect();
+			this.connecting = true;
+			this.transport.connect();
+			if (this.options.connectTimeout){
+				var self = this;
+				setTimeout(function(){
+					if (!self.connected){
+						self.disconnect();
+						if (self.options.tryTransportsOnConnectTimeout && !self._rememberedTransport){
+							var remainingTransports = [], transports = self.options.transports;
+							for (var i = 0, transport; transport = transports[i]; i++){
+								if (transport != self.transport.type) remainingTransports.push(transport);
+							}
+							if (remainingTransports.length){
+								self.transport = self.getTransport(remainingTransports);
+								self.connect();
+							}
+						}
+					}
+				}, this.options.connectTimeout);
+			}
+		}
+		return this;
+	};
+	
+	Socket.prototype.send = function(data){
+		if (!this.transport || !this.transport.connected) return this._queue(data);
+		this.transport.send(data);
+		return this;
+	};
+	
+	Socket.prototype.disconnect = function(){
+		this.transport.disconnect();
+		return this;
+	};
+	
+	Socket.prototype.on = function(name, fn){
+		if (!(name in this._events)) this._events[name] = [];
+		this._events[name].push(fn);
+		return this;
+	};
+	
+	Socket.prototype.fire = function(name, args){
+		if (name in this._events){
+			for (var i = 0, ii = this._events[name].length; i < ii; i++) 
+				this._events[name][i].apply(this, args === undefined ? [] : args);
+		}
+		return this;
+	};
+	
+	Socket.prototype.removeEvent = function(name, fn){
+		if (name in this._events){
+			for (var a = 0, l = this._events[name].length; a < l; a++)
+				if (this._events[name][a] == fn) this._events[name].splice(a, 1);		
+		}
+		return this;
+	};
+	
+	Socket.prototype._queue = function(message){
+		if (!('_queueStack' in this)) this._queueStack = [];
+		this._queueStack.push(message);
+		return this;
+	};
+	
+	Socket.prototype._doQueue = function(){
+		if (!('_queueStack' in this) || !this._queueStack.length) return this;
+		this.transport.send(this._queueStack);
+		this._queueStack = [];
+		return this;
+	};
+	
+	Socket.prototype._isXDomain = function(){
+		return this.host !== document.domain;
+	};
+	
+	Socket.prototype._onConnect = function(){
+		this.connected = true;
+		this.connecting = false;
+		this._doQueue();
+		if (this.options.rememberTransport) this.options.document.cookie = 'socketio=' + encodeURIComponent(this.transport.type);
+		this.fire('connect');
+	};
+	
+	Socket.prototype._onMessage = function(data){
+		this.fire('message', [data]);
+	};
+	
+	Socket.prototype._onDisconnect = function(){
+		var wasConnected = this.connected;
+		this.connected = false;
+		this.connecting = false;
+		this._queueStack = [];
+		if (wasConnected) this.fire('disconnect');
+	};
+	
+	Socket.prototype.addListener = Socket.prototype.addEvent = Socket.prototype.addEventListener = Socket.prototype.on;
+	
+})();

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

@@ -0,0 +1,141 @@
+/**
+ * Socket.IO client
+ * 
+ * @author Guillermo Rauch <guillermo@learnboost.com>
+ * @license The MIT license.
+ * @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+ */
+
+// abstract
+
+(function(){
+	
+	var frame = '~m~',
+	
+	stringify = function(message){
+		if (Object.prototype.toString.call(message) == '[object Object]'){
+			if (!('JSON' in window)){
+				if ('console' in window && console.error) console.error('Trying to encode as JSON, but JSON.stringify is missing.');
+				return '{ "$error": "Invalid message" }';
+			}
+			return '~j~' + JSON.stringify(message);
+		} else {
+			return String(message);
+		}
+	};
+	
+	Transport = io.Transport = function(base, options){
+		this.base = base;
+		this.options = {
+			timeout: 15000 // based on heartbeat interval default
+		};
+		io.util.merge(this.options, options);
+	};
+
+	Transport.prototype.send = function(){
+		throw new Error('Missing send() implementation');
+	};
+
+	Transport.prototype.connect = function(){
+		throw new Error('Missing connect() implementation');
+	};
+
+	Transport.prototype.disconnect = function(){
+		throw new Error('Missing disconnect() implementation');
+	};
+	
+	Transport.prototype._encode = function(messages){
+		var ret = '', message,
+				messages = io.util.isArray(messages) ? messages : [messages];
+		for (var i = 0, l = messages.length; i < l; i++){
+			message = messages[i] === null || messages[i] === undefined ? '' : stringify(messages[i]);
+			ret += frame + message.length + frame + message;
+		}
+		return ret;
+	};
+	
+	Transport.prototype._decode = function(data){
+		var messages = [], number, n;
+		do {
+			if (data.substr(0, 3) !== frame) return messages;
+			data = data.substr(3);
+			number = '', n = '';
+			for (var i = 0, l = data.length; i < l; i++){
+				n = Number(data.substr(i, 1));
+				if (data.substr(i, 1) == n){
+					number += n;
+				} else {	
+					data = data.substr(number.length + frame.length);
+					number = Number(number);
+					break;
+				} 
+			}
+			messages.push(data.substr(0, number)); // here
+			data = data.substr(number);
+		} while(data !== '');
+		return messages;
+	};
+	
+	Transport.prototype._onData = function(data){
+		this._setTimeout();
+		var msgs = this._decode(data);
+		if (msgs && msgs.length){
+			for (var i = 0, l = msgs.length; i < l; i++){
+				this._onMessage(msgs[i]);
+			}
+		}
+	};
+	
+	Transport.prototype._setTimeout = function(){
+		var self = this;
+		if (this._timeout) clearTimeout(this._timeout);
+		this._timeout = setTimeout(function(){
+			self._onTimeout();
+		}, this.options.timeout);
+	};
+	
+	Transport.prototype._onTimeout = function(){
+		this._onDisconnect();
+	};
+	
+	Transport.prototype._onMessage = function(message){
+		if (!this.sessionid){
+			this.sessionid = message;
+			this._onConnect();
+		} else if (message.substr(0, 3) == '~h~'){
+			this._onHeartbeat(message.substr(3));
+		} else if (message.substr(0, 3) == '~j~'){
+			this.base._onMessage(JSON.parse(message.substr(3)));
+		} else {
+			this.base._onMessage(message);
+		}
+	},
+	
+	Transport.prototype._onHeartbeat = function(heartbeat){
+		this.send('~h~' + heartbeat); // echo
+	};
+	
+	Transport.prototype._onConnect = function(){
+		this.connected = true;
+		this.connecting = false;
+		this.base._onConnect();
+		this._setTimeout();
+	};
+
+	Transport.prototype._onDisconnect = function(){
+		this.connecting = false;
+		this.connected = false;
+		this.sessionid = null;
+		this.base._onDisconnect();
+	};
+
+	Transport.prototype._prepareUrl = function(){
+		return (this.base.options.secure ? 'https' : 'http') 
+			+ '://' + this.base.host 
+			+ ':' + this.base.options.port
+			+ '/' + this.base.options.resource
+			+ '/' + this.type
+			+ (this.sessionid ? ('/' + this.sessionid) : '/');
+	};
+
+})();

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/transports/flashsocket.js

@@ -0,0 +1,53 @@
+/**
+ * Socket.IO client
+ * 
+ * @author Guillermo Rauch <guillermo@learnboost.com>
+ * @license The MIT license.
+ * @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+ */
+
+(function(){
+	
+	var Flashsocket = io.Transport.flashsocket = function(){
+		io.Transport.websocket.apply(this, arguments);
+	};
+	
+	io.util.inherit(Flashsocket, io.Transport.websocket);
+	
+	Flashsocket.prototype.type = 'flashsocket';
+	
+	Flashsocket.prototype.connect = function(){
+		var self = this, args = arguments;
+		WebSocket.__addTask(function(){
+			io.Transport.websocket.prototype.connect.apply(self, args);
+		});
+		return this;
+	};
+	
+	Flashsocket.prototype.send = function(){
+		var self = this, args = arguments;
+		WebSocket.__addTask(function(){
+			io.Transport.websocket.prototype.send.apply(self, args);
+		});
+		return this;
+	};
+	
+	Flashsocket.check = function(){
+		if (typeof WebSocket == 'undefined' || !('__addTask' in WebSocket)) return false;
+		if (io.util.opera) return false; // opera is buggy with this transport
+		if ('navigator' in window && 'plugins' in navigator && navigator.plugins['Shockwave Flash']){
+			return !!navigator.plugins['Shockwave Flash'].description;
+	  }
+		if ('ActiveXObject' in window) {
+			try {
+				return !!new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version');
+			} catch (e) {}
+		}
+		return false;
+	};
+	
+	Flashsocket.xdomainCheck = function(){
+		return true;
+	};
+	
+})();

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/transports/htmlfile.js

@@ -0,0 +1,73 @@
+/**
+ * Socket.IO client
+ * 
+ * @author Guillermo Rauch <guillermo@learnboost.com>
+ * @license The MIT license.
+ * @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+ */
+
+(function(){
+	
+	var HTMLFile = io.Transport.htmlfile = function(){
+		io.Transport.XHR.apply(this, arguments);
+	};
+	
+	io.util.inherit(HTMLFile, io.Transport.XHR);
+	
+	HTMLFile.prototype.type = 'htmlfile';
+	
+	HTMLFile.prototype._get = function(){
+		var self = this;
+		this._open();
+		window.attachEvent('onunload', function(){ self._destroy(); });
+	};
+	
+	HTMLFile.prototype._open = function(){
+		this._doc = new ActiveXObject('htmlfile');
+		this._doc.open();
+		this._doc.write('<html></html>');
+		this._doc.parentWindow.s = this;
+		this._doc.close();
+
+		var _iframeC = this._doc.createElement('div');
+		this._doc.body.appendChild(_iframeC);
+		this._iframe = this._doc.createElement('iframe');
+		_iframeC.appendChild(this._iframe);
+		this._iframe.src = this._prepareUrl() + '/' + (+ new Date);
+	};
+	
+	HTMLFile.prototype._ = function(data, doc){
+		this._onData(data);
+		var script = doc.getElementsByTagName('script')[0];
+		script.parentNode.removeChild(script);
+	};
+
+  HTMLFile.prototype._destroy = function(){
+    if (this._iframe){
+      this._iframe.src = 'about:blank';
+      this._doc = null;
+      CollectGarbage();
+    }
+  };
+	
+	HTMLFile.prototype.disconnect = function(){
+		this._destroy();
+		return io.Transport.XHR.prototype.disconnect.call(this);
+	};
+	
+	HTMLFile.check = function(){
+		if ('ActiveXObject' in window){
+			try {
+				var a = new ActiveXObject('htmlfile');
+				return a && io.Transport.XHR.check();
+			} catch(e){}
+		}
+		return false;
+	};
+
+	HTMLFile.xdomainCheck = function(){
+		// we can probably do handling for sub-domains, we should test that it's cross domain but a subdomain here
+		return false;
+	};
+	
+})();