websocket-rails 0.6.2 → 0.7.0

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

@@ -1,74 +1,59 @@
+
 /*
 WebSocket Interface for the WebSocketRails client.
-*/
-
+ */
 
 (function() {
-  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  WebSocketRails.WebSocketConnection = (function(_super) {
+    __extends(WebSocketConnection, _super);
+
+    WebSocketConnection.prototype.connection_type = 'websocket';
 
-  WebSocketRails.WebSocketConnection = (function() {
     function WebSocketConnection(url, dispatcher) {
       this.url = url;
       this.dispatcher = dispatcher;
-      this.flush_queue = __bind(this.flush_queue, this);
-      this.on_error = __bind(this.on_error, this);
-      this.on_close = __bind(this.on_close, this);
-      this.on_message = __bind(this.on_message, this);
-      this.trigger = __bind(this.trigger, this);
+      WebSocketConnection.__super__.constructor.apply(this, arguments);
       if (this.url.match(/^wss?:\/\//)) {
         console.log("WARNING: Using connection urls with protocol specified is depricated");
-      } else if (window.location.protocol === 'http:') {
-        this.url = "ws://" + this.url;
-      } else {
+      } else if (window.location.protocol === 'https:') {
         this.url = "wss://" + this.url;
+      } else {
+        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;
-      this._conn.onerror = this.on_error;
+      this._conn.onmessage = (function(_this) {
+        return function(event) {
+          var event_data;
+          event_data = JSON.parse(event.data);
+          return _this.on_message(event_data);
+        };
+      })(this);
+      this._conn.onclose = (function(_this) {
+        return function(event) {
+          return _this.on_close(event);
+        };
+      })(this);
+      this._conn.onerror = (function(_this) {
+        return function(event) {
+          return _this.on_error(event);
+        };
+      })(this);
     }
 
-    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', event]);
-      this.dispatcher.state = 'disconnected';
-      return this.dispatcher.dispatch(close_event);
-    };
-
-    WebSocketConnection.prototype.on_error = function(event) {
-      var error_event;
-      error_event = new WebSocketRails.Event(['connection_error', event]);
-      this.dispatcher.state = 'disconnected';
-      return this.dispatcher.dispatch(error_event);
+    WebSocketConnection.prototype.close = function() {
+      return this._conn.close();
     };
 
-    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 = [];
+    WebSocketConnection.prototype.send_event = function(event) {
+      WebSocketConnection.__super__.send_event.apply(this, arguments);
+      return this._conn.send(event.serialize());
     };
 
     return WebSocketConnection;
 
-  })();
+  })(WebSocketRails.AbstractConnection);
 
 }).call(this);

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

@@ -1,3 +1,4 @@
+
 /*
 WebsocketRails JavaScript Client
 
@@ -15,8 +16,7 @@ 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); }; };
@@ -38,17 +38,46 @@ Listening for new events from the server
       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.reconnect = __bind(this.reconnect, this);
       this.callbacks = {};
       this.channels = {};
       this.queue = {};
+      this.connect();
+    }
+
+    WebSocketRails.prototype.connect = function() {
+      this.state = 'connecting';
       if (!(this.supports_websockets() && this.use_websockets)) {
-        this._conn = new WebSocketRails.HttpConnection(url, this);
+        this._conn = new WebSocketRails.HttpConnection(this.url, this);
       } else {
-        this._conn = new WebSocketRails.WebSocketConnection(url, this);
+        this._conn = new WebSocketRails.WebSocketConnection(this.url, this);
       }
-      this._conn.new_message = this.new_message;
-    }
+      return this._conn.new_message = this.new_message;
+    };
+
+    WebSocketRails.prototype.disconnect = function() {
+      if (this._conn) {
+        this._conn.close();
+        delete this._conn._conn;
+        delete this._conn;
+      }
+      return this.state = 'disconnected';
+    };
+
+    WebSocketRails.prototype.reconnect = function() {
+      var event, id, old_connection_id, _ref, _ref1;
+      old_connection_id = (_ref = this._conn) != null ? _ref.connection_id : void 0;
+      this.disconnect();
+      this.connect();
+      _ref1 = this.queue;
+      for (id in _ref1) {
+        event = _ref1[id];
+        if (event.connection_id === old_connection_id && !event.is_result()) {
+          this.trigger_event(event);
+        }
+      }
+      return this.reconnect_channels();
+    };
 
     WebSocketRails.prototype.new_message = function(data) {
       var event, socket_message, _i, _len, _ref, _results;
@@ -60,7 +89,7 @@ Listening for new events from the server
           if ((_ref = this.queue[event.id]) != null) {
             _ref.run_callbacks(event.success, event.data);
           }
-          this.queue[event.id] = null;
+          delete this.queue[event.id];
         } else if (event.is_channel()) {
           this.dispatch_channel(event);
         } else if (event.is_ping()) {
@@ -79,8 +108,8 @@ Listening for new events from the server
 
     WebSocketRails.prototype.connection_established = function(data) {
       this.state = 'connected';
-      this.connection_id = data.connection_id;
-      this._conn.flush_queue(data.connection_id);
+      this._conn.setConnectionId(data.connection_id);
+      this._conn.flush_queue();
       if (this.on_open != null) {
         return this.on_open(data);
       }
@@ -95,10 +124,9 @@ Listening for new events from the server
     };
 
     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);
+      var event, _ref;
+      event = new WebSocketRails.Event([event_name, data, (_ref = this._conn) != null ? _ref.connection_id : void 0], success_callback, failure_callback);
+      return this.trigger_event(event);
     };
 
     WebSocketRails.prototype.trigger_event = function(event) {
@@ -106,7 +134,10 @@ Listening for new events from the server
       if ((_base = this.queue)[_name = event.id] == null) {
         _base[_name] = event;
       }
-      return this._conn.trigger(event);
+      if (this._conn) {
+        this._conn.trigger(event);
+      }
+      return event;
     };
 
     WebSocketRails.prototype.dispatch = function(event) {
@@ -123,10 +154,10 @@ Listening for new events from the server
       return _results;
     };
 
-    WebSocketRails.prototype.subscribe = function(channel_name) {
+    WebSocketRails.prototype.subscribe = function(channel_name, success_callback, failure_callback) {
       var channel;
       if (this.channels[channel_name] == null) {
-        channel = new WebSocketRails.Channel(channel_name, this);
+        channel = new WebSocketRails.Channel(channel_name, this, false, success_callback, failure_callback);
         this.channels[channel_name] = channel;
         return channel;
       } else {
@@ -134,10 +165,10 @@ Listening for new events from the server
       }
     };
 
-    WebSocketRails.prototype.subscribe_private = function(channel_name) {
+    WebSocketRails.prototype.subscribe_private = function(channel_name, success_callback, failure_callback) {
       var channel;
       if (this.channels[channel_name] == null) {
-        channel = new WebSocketRails.Channel(channel_name, this, true);
+        channel = new WebSocketRails.Channel(channel_name, this, true, success_callback, failure_callback);
         this.channels[channel_name] = channel;
         return channel;
       } else {
@@ -165,8 +196,8 @@ Listening for new events from the server
     };
 
     WebSocketRails.prototype.pong = function() {
-      var pong;
-      pong = new WebSocketRails.Event(['websocket_rails.pong', {}, this.connection_id]);
+      var pong, _ref;
+      pong = new WebSocketRails.Event(['websocket_rails.pong', {}, (_ref = this._conn) != null ? _ref.connection_id : void 0]);
       return this._conn.trigger(pong);
     };
 
@@ -174,6 +205,22 @@ Listening for new events from the server
       return this.state !== 'connected';
     };
 
+    WebSocketRails.prototype.reconnect_channels = function() {
+      var callbacks, channel, name, _ref, _results;
+      _ref = this.channels;
+      _results = [];
+      for (name in _ref) {
+        channel = _ref[name];
+        callbacks = channel._callbacks;
+        channel.destroy();
+        delete this.channels[name];
+        channel = channel.is_private ? this.subscribe_private(name) : this.subscribe(name);
+        channel._callbacks = callbacks;
+        _results.push(channel);
+      }
+      return _results;
+    };
+
     return WebSocketRails;
 
   })();

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

@@ -1,25 +1,95 @@
 (function() {
   describe('WebSocketRails.Channel:', function() {
     beforeEach(function() {
-      this.dispatcher = {
-        new_message: function() {
+      var WebSocketRailsStub;
+      this.dispatcher = new (WebSocketRailsStub = (function() {
+        function WebSocketRailsStub() {}
+
+        WebSocketRailsStub.prototype.new_message = function() {
           return true;
-        },
-        dispatch: function() {
+        };
+
+        WebSocketRailsStub.prototype.dispatch = function() {
           return true;
-        },
-        trigger_event: function(event) {
+        };
+
+        WebSocketRailsStub.prototype.trigger_event = function(event) {
           return true;
-        },
-        state: 'connected',
-        connection_id: 12345
-      };
+        };
+
+        WebSocketRailsStub.prototype.state = 'connected';
+
+        WebSocketRailsStub.prototype._conn = {
+          connection_id: 12345
+        };
+
+        return WebSocketRailsStub;
+
+      })());
       this.channel = new WebSocketRails.Channel('public', this.dispatcher);
       return sinon.spy(this.dispatcher, 'trigger_event');
     });
     afterEach(function() {
       return this.dispatcher.trigger_event.restore();
     });
+    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);
+      });
+    });
+    describe('.trigger', function() {
+      describe('before the channel token is set', function() {
+        return it('queues the events', function() {
+          var queue;
+          this.channel.trigger('someEvent', 'someData');
+          queue = this.channel._queue;
+          expect(queue[0].name).toEqual('someEvent');
+          return expect(queue[0].data).toEqual('someData');
+        });
+      });
+      return describe('when channel token is set', function() {
+        return it('adds token to event metadata and dispatches event', function() {
+          this.channel._token = 'valid token';
+          this.channel.trigger('someEvent', 'someData');
+          return expect(this.dispatcher.trigger_event.calledWith([
+            'someEvent', {
+              token: 'valid token',
+              data: 'someData'
+            }
+          ]));
+        });
+      });
+    });
+    describe('.destroy', function() {
+      it('should destroy all callbacks', function() {
+        var event_callback;
+        event_callback = function() {
+          return true;
+        };
+        this.channel.bind('new_message', this.event_callback);
+        this.channel.destroy();
+        return expect(this.channel._callbacks).toEqual({});
+      });
+      describe('when this channel\'s connection is still active', function() {
+        return it('should send unsubscribe event', function() {
+          this.channel.destroy();
+          return expect(this.dispatcher.trigger_event.args[0][0].name).toEqual('websocket_rails.unsubscribe');
+        });
+      });
+      return describe('when this channel\'s connection is no more active', function() {
+        beforeEach(function() {
+          return this.dispatcher._conn.connection_id++;
+        });
+        return it('should not send unsubscribe event', function() {
+          this.channel.destroy();
+          return expect(this.dispatcher.trigger_event.notCalled).toEqual(true);
+        });
+      });
+    });
     describe('public channels', function() {
       beforeEach(function() {
         this.channel = new WebSocketRails.Channel('forchan', this.dispatcher, false);
@@ -35,17 +105,30 @@
         expect(this.channel._callbacks).toBeDefined();
         return expect(this.channel._callbacks).toEqual({});
       });
-      it('should be public', function() {
+      return 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);
+    });
+    describe('channel tokens', function() {
+      it('should set token when event_name is websocket_rails.channel_token', function() {
+        this.channel.dispatch('websocket_rails.channel_token', {
+          token: 'abc123'
+        });
+        return expect(this.channel._token).toEqual('abc123');
+      });
+      it("should refresh channel's connection_id after channel_token has been received", function() {
+        this.channel.connection_id = null;
+        this.channel.dispatch('websocket_rails.channel_token', {
+          token: 'abc123'
+        });
+        return expect(this.channel.connection_id).toEqual(this.dispatcher._conn.connection_id);
+      });
+      return it('should flush the event queue after setting token', function() {
+        this.channel.trigger('someEvent', 'someData');
+        this.channel.dispatch('websocket_rails.channel_token', {
+          token: 'abc123'
         });
+        return expect(this.channel._queue.length).toEqual(0);
       });
     });
     return describe('private channels', function() {
@@ -57,7 +140,7 @@
         return expect(this.event.name).toEqual('websocket_rails.subscribe_private');
       });
       return it('should be private', function() {
-        return expect(this.channel.is_private).toBe(true);
+        return expect(this.channel.is_private).toBeTruthy;
       });
     });
   });

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

@@ -0,0 +1,17 @@
+(function() {
+  window.helpers = {
+    startConnection: function(dispatcher, connection_id) {
+      var message;
+      if (connection_id == null) {
+        connection_id = 1;
+      }
+      message = {
+        data: {
+          connection_id: connection_id
+        }
+      };
+      return dispatcher.new_message([['client_connected', message]]);
+    }
+  };
+
+}).call(this);