websocket-rails 0.1.5 → 0.1.6

data/spec/javascripts/generated/assets/http_connection.js

@@ -0,0 +1,108 @@
+
+/*
+ HTTP Interface for the WebSocketRails client.
+*/
+
+
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  WebSocketRails.HttpConnection = (function() {
+
+    HttpConnection.prototype.httpFactories = function() {
+      return [
+        function() {
+          return new XMLHttpRequest();
+        }, function() {
+          return new ActiveXObject("Msxml2.XMLHTTP");
+        }, function() {
+          return new ActiveXObject("Msxml3.XMLHTTP");
+        }, function() {
+          return new ActiveXObject("Microsoft.XMLHTTP");
+        }
+      ];
+    };
+
+    HttpConnection.prototype.createXMLHttpObject = function() {
+      var factories, factory, xmlhttp, _i, _len;
+      xmlhttp = false;
+      factories = this.httpFactories();
+      for (_i = 0, _len = factories.length; _i < _len; _i++) {
+        factory = factories[_i];
+        try {
+          xmlhttp = factory();
+        } catch (e) {
+          continue;
+        }
+        break;
+      }
+      return xmlhttp;
+    };
+
+    function HttpConnection(url, dispatcher) {
+      this.url = url;
+      this.dispatcher = dispatcher;
+      this.flush_queue = __bind(this.flush_queue, this);
+
+      this.trigger = __bind(this.trigger, this);
+
+      this.parse_stream = __bind(this.parse_stream, this);
+
+      this.createXMLHttpObject = __bind(this.createXMLHttpObject, this);
+
+      this._conn = this.createXMLHttpObject();
+      this.last_pos = 0;
+      this.message_queue = [];
+      this._conn.onreadystatechange = this.parse_stream;
+      this._conn.open("GET", "/websocket", true);
+      this._conn.send();
+    }
+
+    HttpConnection.prototype.parse_stream = function() {
+      var data, decoded_data;
+      if (this._conn.readyState === 3) {
+        data = this._conn.responseText.substring(this.last_pos);
+        this.last_pos = this._conn.responseText.length;
+        data = data.replace("]][[", "],[");
+        decoded_data = JSON.parse(data);
+        return this.dispatcher.new_message(decoded_data);
+      }
+    };
+
+    HttpConnection.prototype.trigger = function(event) {
+      if (this.dispatcher.state !== 'connected') {
+        return this.message_queue.push(event);
+      } else {
+        return this.post_data(this.dispatcher.connection_id, event.serialize());
+      }
+    };
+
+    HttpConnection.prototype.post_data = function(connection_id, payload) {
+      return $.ajax("/websocket", {
+        type: 'POST',
+        data: {
+          client_id: connection_id,
+          data: payload
+        },
+        success: function() {}
+      });
+    };
+
+    HttpConnection.prototype.flush_queue = function(connection_id) {
+      var event, _i, _len, _ref;
+      _ref = this.message_queue;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        event = _ref[_i];
+        if (connection_id != null) {
+          event.connection_id = this.dispatcher.connection_id;
+        }
+        this.trigger(event);
+      }
+      return this.message_queue = [];
+    };
+
+    return HttpConnection;
+
+  })();
+
+}).call(this);

data/spec/javascripts/generated/assets/websocket_connection.js

@@ -0,0 +1,66 @@
+
+/*
+WebSocket Interface for the WebSocketRails client.
+*/
+
+
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  WebSocketRails.WebSocketConnection = (function() {
+
+    function WebSocketConnection(url, dispatcher) {
+      this.url = url;
+      this.dispatcher = dispatcher;
+      this.flush_queue = __bind(this.flush_queue, this);
+
+      this.on_close = __bind(this.on_close, this);
+
+      this.on_message = __bind(this.on_message, this);
+
+      this.trigger = __bind(this.trigger, this);
+
+      if (!this.url.match(/^wss?:\/\//)) {
+        this.url = "ws://" + this.url;
+      }
+      this.message_queue = [];
+      this._conn = new WebSocket(this.url);
+      this._conn.onmessage = this.on_message;
+      this._conn.onclose = this.on_close;
+    }
+
+    WebSocketConnection.prototype.trigger = function(event) {
+      if (this.dispatcher.state !== 'connected') {
+        return this.message_queue.push(event);
+      } else {
+        return this._conn.send(event.serialize());
+      }
+    };
+
+    WebSocketConnection.prototype.on_message = function(event) {
+      var data;
+      data = JSON.parse(event.data);
+      return this.dispatcher.new_message(data);
+    };
+
+    WebSocketConnection.prototype.on_close = function(event) {
+      var close_event;
+      close_event = new WebSocketRails.Event(['connection_closed', {}]);
+      return this.dispatcher.dispatch(close_event);
+    };
+
+    WebSocketConnection.prototype.flush_queue = function() {
+      var event, _i, _len, _ref;
+      _ref = this.message_queue;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        event = _ref[_i];
+        this._conn.send(event.serialize());
+      }
+      return this.message_queue = [];
+    };
+
+    return WebSocketConnection;
+
+  })();
+
+}).call(this);

data/spec/javascripts/generated/assets/websocket_rails.js

@@ -0,0 +1,180 @@
+
+/*
+WebsocketRails JavaScript Client
+
+Setting up the dispatcher:
+  var dispatcher = new WebSocketRails('localhost:3000');
+  dispatcher.on_open = function() {
+    // trigger a server event immediately after opening connection
+    dispatcher.trigger('new_user',{user_name: 'guest'});
+  })
+
+Triggering a new event on the server
+  dispatcherer.trigger('event_name',object_to_be_serialized_to_json);
+
+Listening for new events from the server
+  dispatcher.bind('event_name', function(data) {
+    console.log(data.user_name);
+  });
+*/
+
+
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  window.WebSocketRails = (function() {
+
+    function WebSocketRails(url, use_websockets) {
+      this.url = url;
+      this.use_websockets = use_websockets != null ? use_websockets : true;
+      this.pong = __bind(this.pong, this);
+
+      this.supports_websockets = __bind(this.supports_websockets, this);
+
+      this.dispatch_channel = __bind(this.dispatch_channel, this);
+
+      this.subscribe_private = __bind(this.subscribe_private, this);
+
+      this.subscribe = __bind(this.subscribe, this);
+
+      this.dispatch = __bind(this.dispatch, this);
+
+      this.trigger_event = __bind(this.trigger_event, this);
+
+      this.trigger = __bind(this.trigger, this);
+
+      this.bind = __bind(this.bind, this);
+
+      this.connection_established = __bind(this.connection_established, this);
+
+      this.new_message = __bind(this.new_message, this);
+
+      this.state = 'connecting';
+      this.callbacks = {};
+      this.channels = {};
+      this.queue = {};
+      if (!(this.supports_websockets() && this.use_websockets)) {
+        this._conn = new WebSocketRails.HttpConnection(url, this);
+      } else {
+        this._conn = new WebSocketRails.WebSocketConnection(url, this);
+      }
+      this._conn.new_message = this.new_message;
+    }
+
+    WebSocketRails.prototype.new_message = function(data) {
+      var event, socket_message, _i, _len, _ref, _results;
+      _results = [];
+      for (_i = 0, _len = data.length; _i < _len; _i++) {
+        socket_message = data[_i];
+        event = new WebSocketRails.Event(socket_message);
+        if (event.is_result()) {
+          if ((_ref = this.queue[event.id]) != null) {
+            _ref.run_callbacks(event.success, event.data);
+          }
+          this.queue[event.id] = null;
+        } else if (event.is_channel()) {
+          this.dispatch_channel(event);
+        } else if (event.is_ping()) {
+          this.pong();
+        } else {
+          this.dispatch(event);
+        }
+        if (this.state === 'connecting' && event.name === 'client_connected') {
+          _results.push(this.connection_established(event.data));
+        } else {
+          _results.push(void 0);
+        }
+      }
+      return _results;
+    };
+
+    WebSocketRails.prototype.connection_established = function(data) {
+      this.state = 'connected';
+      this.connection_id = data.connection_id;
+      this._conn.flush_queue(data.connection_id);
+      if (this.on_open != null) {
+        return this.on_open(data);
+      }
+    };
+
+    WebSocketRails.prototype.bind = function(event_name, callback) {
+      var _base, _ref;
+      if ((_ref = (_base = this.callbacks)[event_name]) == null) {
+        _base[event_name] = [];
+      }
+      return this.callbacks[event_name].push(callback);
+    };
+
+    WebSocketRails.prototype.trigger = function(event_name, data, success_callback, failure_callback) {
+      var event;
+      event = new WebSocketRails.Event([event_name, data, this.connection_id], success_callback, failure_callback);
+      this.queue[event.id] = event;
+      return this._conn.trigger(event);
+    };
+
+    WebSocketRails.prototype.trigger_event = function(event) {
+      var _base, _name, _ref;
+      if ((_ref = (_base = this.queue)[_name = event.id]) == null) {
+        _base[_name] = event;
+      }
+      return this._conn.trigger(event);
+    };
+
+    WebSocketRails.prototype.dispatch = function(event) {
+      var callback, _i, _len, _ref, _results;
+      if (this.callbacks[event.name] == null) {
+        return;
+      }
+      _ref = this.callbacks[event.name];
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        callback = _ref[_i];
+        _results.push(callback(event.data));
+      }
+      return _results;
+    };
+
+    WebSocketRails.prototype.subscribe = function(channel_name) {
+      var channel;
+      if (this.channels[channel_name] == null) {
+        channel = new WebSocketRails.Channel(channel_name, this);
+        this.channels[channel_name] = channel;
+        return channel;
+      } else {
+        return this.channels[channel_name];
+      }
+    };
+
+    WebSocketRails.prototype.subscribe_private = function(channel_name) {
+      var channel;
+      if (this.channels[channel_name] == null) {
+        channel = new WebSocketRails.Channel(channel_name, this, true);
+        this.channels[channel_name] = channel;
+        return channel;
+      } else {
+        return this.channels[channel_name];
+      }
+    };
+
+    WebSocketRails.prototype.dispatch_channel = function(event) {
+      if (this.channels[event.channel] == null) {
+        return;
+      }
+      return this.channels[event.channel].dispatch(event.name, event.data);
+    };
+
+    WebSocketRails.prototype.supports_websockets = function() {
+      return typeof WebSocket === "function" || typeof WebSocket === "object";
+    };
+
+    WebSocketRails.prototype.pong = function() {
+      var pong;
+      pong = new WebSocketRails.Event(['websocket_rails.pong', {}, this.connection_id]);
+      return this._conn.trigger(pong);
+    };
+
+    return WebSocketRails;
+
+  })();
+
+}).call(this);

data/spec/javascripts/generated/specs/channel_spec.js

@@ -0,0 +1,66 @@
+(function() {
+
+  describe('WebSocketRails.Channel:', function() {
+    beforeEach(function() {
+      this.dispatcher = {
+        new_message: function() {
+          return true;
+        },
+        dispatch: function() {
+          return true;
+        },
+        trigger_event: function(event) {
+          return true;
+        },
+        state: 'connected',
+        connection_id: 12345
+      };
+      this.channel = new WebSocketRails.Channel('public', this.dispatcher);
+      return sinon.spy(this.dispatcher, 'trigger_event');
+    });
+    afterEach(function() {
+      return this.dispatcher.trigger_event.restore();
+    });
+    describe('public channels', function() {
+      beforeEach(function() {
+        this.channel = new WebSocketRails.Channel('forchan', this.dispatcher, false);
+        return this.event = this.dispatcher.trigger_event.lastCall.args[0];
+      });
+      it('should trigger an event containing the channel name', function() {
+        return expect(this.event.data.channel).toEqual('forchan');
+      });
+      it('should trigger an event containing the correct connection_id', function() {
+        return expect(this.event.connection_id).toEqual(12345);
+      });
+      it('should initialize an empty callbacks property', function() {
+        expect(this.channel._callbacks).toBeDefined();
+        return expect(this.channel._callbacks).toEqual({});
+      });
+      it('should be public', function() {
+        return expect(this.channel.is_private).toBeFalsy;
+      });
+      return describe('.bind', function() {
+        return it('should add a function to the callbacks collection', function() {
+          var test_func;
+          test_func = function() {};
+          this.channel.bind('event_name', test_func);
+          expect(this.channel._callbacks['event_name'].length).toBe(1);
+          return expect(this.channel._callbacks['event_name']).toContain(test_func);
+        });
+      });
+    });
+    return describe('private channels', function() {
+      beforeEach(function() {
+        this.channel = new WebSocketRails.Channel('forchan', this.dispatcher, true);
+        return this.event = this.dispatcher.trigger_event.lastCall.args[0];
+      });
+      it('should trigger a subscribe_private event when created', function() {
+        return expect(this.event.name).toEqual('websocket_rails.subscribe_private');
+      });
+      return it('should be private', function() {
+        return expect(this.channel.is_private).toBe(true);
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/generated/specs/event_spec.js

@@ -0,0 +1,107 @@
+(function() {
+
+  describe('WebSocketRails.Event', function() {
+    describe('standard events', function() {
+      beforeEach(function() {
+        this.data = [
+          'event', {
+            data: {
+              message: 'test'
+            }
+          }, 12345
+        ];
+        return this.event = new WebSocketRails.Event(this.data);
+      });
+      it('should generate an ID', function() {
+        return expect(this.event.id).not.toBeNull;
+      });
+      it('should have a connection ID', function() {
+        return expect(this.event.connection_id).toEqual(12345);
+      });
+      it('should assign the correct properties when passed a data array', function() {
+        expect(this.event.name).toEqual('event');
+        return expect(this.event.data.message).toEqual('test');
+      });
+      describe('.serialize()', function() {
+        return it('should serialize the event as JSON', function() {
+          var serialized;
+          this.event.id = 1;
+          serialized = "[\"event\",{\"id\":1,\"data\":{\"message\":\"test\"}}]";
+          return expect(this.event.serialize()).toEqual(serialized);
+        });
+      });
+      return describe('.is_channel()', function() {
+        return it('should be false', function() {
+          return expect(this.event.is_channel()).toEqual(false);
+        });
+      });
+    });
+    describe('channel events', function() {
+      beforeEach(function() {
+        this.data = [
+          'event', {
+            channel: 'channel',
+            data: {
+              message: 'test'
+            }
+          }
+        ];
+        return this.event = new WebSocketRails.Event(this.data);
+      });
+      it('should assign the channel property', function() {
+        expect(this.event.channel).toEqual('channel');
+        expect(this.event.name).toEqual('event');
+        return expect(this.event.data.message).toEqual('test');
+      });
+      describe('.is_channel()', function() {
+        return it('should be true', function() {
+          return expect(this.event.is_channel()).toEqual(true);
+        });
+      });
+      return describe('.serialize()', function() {
+        return it('should serialize the event as JSON', function() {
+          var serialized;
+          this.event.id = 1;
+          serialized = "[\"event\",{\"id\":1,\"channel\":\"channel\",\"data\":{\"message\":\"test\"}}]";
+          return expect(this.event.serialize()).toEqual(serialized);
+        });
+      });
+    });
+    return describe('.run_callbacks()', function() {
+      beforeEach(function() {
+        var failure_func, success_func;
+        success_func = function(data) {
+          return data;
+        };
+        failure_func = function(data) {
+          return data;
+        };
+        this.data = [
+          'event', {
+            data: {
+              message: 'test'
+            }
+          }, 12345
+        ];
+        return this.event = new WebSocketRails.Event(this.data, success_func, failure_func);
+      });
+      describe('when successful', function() {
+        it('should run the success callback when passed true', function() {
+          return expect(this.event.run_callbacks(true, 'success')).toEqual('success');
+        });
+        return it('should not run the failure callback', function() {
+          return expect(this.event.run_callbacks(true, 'success')).toBeUndefined;
+        });
+      });
+      return describe('when failure', function() {
+        it('should run the failure callback when passed true', function() {
+          return expect(this.event.run_callbacks(false, 'failure')).toEqual('failure');
+        });
+        return it('should not run the failure callback', function() {
+          return expect(this.event.run_callbacks(false, 'failure')).toBeUndefined;
+        });
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/generated/specs/websocket_connection_spec.js

@@ -0,0 +1,117 @@
+(function() {
+
+  describe('WebsocketRails.WebSocketConnection:', function() {
+    beforeEach(function() {
+      var dispatcher;
+      dispatcher = {
+        new_message: function() {
+          return true;
+        },
+        dispatch: function() {
+          return true;
+        },
+        state: 'connected'
+      };
+      window.WebSocket = function(url) {
+        this.url = url;
+        return this.send = function() {
+          return true;
+        };
+      };
+      return this.connection = new WebSocketRails.WebSocketConnection('localhost:3000/websocket', dispatcher);
+    });
+    describe('constructor', function() {
+      it('should set the onmessage event on the WebSocket object to this.on_message', function() {
+        return expect(this.connection._conn.onmessage).toEqual(this.connection.on_message);
+      });
+      it('should set the onclose event on the WebSocket object to this.on_close', function() {
+        return expect(this.connection._conn.onclose).toEqual(this.connection.on_close);
+      });
+      describe('with ssl', function() {
+        return it('should not add the ws:// prefix to the URL', function() {
+          var connection;
+          connection = new WebSocketRails.WebSocketConnection('wss://localhost.com');
+          return expect(connection.url).toEqual('wss://localhost.com');
+        });
+      });
+      return describe('without ssl', function() {
+        return it('should add the ws:// prefix to the URL', function() {
+          return expect(this.connection.url).toEqual('ws://localhost:3000/websocket');
+        });
+      });
+    });
+    describe('.trigger', function() {
+      describe('before the connection has been fully established', function() {
+        return it('should queue up the events', function() {
+          var event, mock_queue;
+          this.connection.dispatcher.state = 'connecting';
+          event = new WebSocketRails.Event(['event', 'message']);
+          mock_queue = sinon.mock(this.connection.message_queue);
+          return mock_queue.expects('push').once().withArgs(event);
+        });
+      });
+      return describe('after the connection has been fully established', function() {
+        return it('should encode the data and send it through the WebSocket object', function() {
+          var event, mock_connection;
+          this.connection.dispatcher.state = 'connected';
+          event = new WebSocketRails.Event(['event', 'message']);
+          this.connection._conn = {
+            send: function() {
+              return true;
+            }
+          };
+          mock_connection = sinon.mock(this.connection._conn);
+          mock_connection.expects('send').once().withArgs(event.serialize());
+          this.connection.trigger(event);
+          return mock_connection.verify();
+        });
+      });
+    });
+    describe('.on_message', function() {
+      return it('should decode the message and pass it to the dispatcher', function() {
+        var encoded_data, event, mock_dispatcher;
+        encoded_data = JSON.stringify(['event', 'message']);
+        event = {
+          data: encoded_data
+        };
+        mock_dispatcher = sinon.mock(this.connection.dispatcher);
+        mock_dispatcher.expects('new_message').once().withArgs(JSON.parse(encoded_data));
+        this.connection.on_message(event);
+        return mock_dispatcher.verify();
+      });
+    });
+    describe('.on_close', function() {
+      return it('should dispatch the connection_closed event', function() {
+        var mock_dispatcher;
+        mock_dispatcher = sinon.mock(this.connection.dispatcher);
+        mock_dispatcher.expects('dispatch').once();
+        this.connection.on_close();
+        return mock_dispatcher.verify();
+      });
+    });
+    return describe('.flush_queue', function() {
+      beforeEach(function() {
+        this.event = new WebSocketRails.Event(['event', 'message']);
+        this.connection.message_queue.push(this.event);
+        return this.connection._conn = {
+          send: function() {
+            return true;
+          }
+        };
+      });
+      it('should send out all of the messages in the queue', function() {
+        var mock_connection;
+        mock_connection = sinon.mock(this.connection._conn);
+        mock_connection.expects('send').once().withArgs(this.event.serialize());
+        this.connection.flush_queue();
+        return mock_connection.verify();
+      });
+      return it('should empty the queue after sending', function() {
+        expect(this.connection.message_queue.length).toEqual(1);
+        this.connection.flush_queue();
+        return expect(this.connection.message_queue.length).toEqual(0);
+      });
+    });
+  });
+
+}).call(this);