websocket-rails 0.6.2 → 0.7.0

data/lib/websocket_rails/event.rb

@@ -71,6 +71,11 @@ module WebsocketRails
       case encoded_data
       when String
         event_name, data = JSON.parse encoded_data
+
+        unless event_name.is_a?(String) && data.is_a?(Hash)
+          raise UnknownDataType
+        end
+
         data = data.merge(:connection => connection).with_indifferent_access
         Event.new event_name, data
         # when Array
@@ -93,7 +98,7 @@ module WebsocketRails
     include Logging
     extend StaticEvents
 
-    attr_reader :id, :name, :connection, :namespace, :channel, :user_id
+    attr_reader :id, :name, :connection, :namespace, :channel, :user_id, :token
 
     attr_accessor :data, :result, :success, :server_token
 
@@ -108,7 +113,8 @@ module WebsocketRails
       end
       @id           = options[:id]
       @data         = options[:data].is_a?(Hash) ? options[:data].with_indifferent_access : options[:data]
-      @channel      = options[:channel].to_sym if options[:channel]
+      @channel      = options[:channel].to_sym rescue options[:channel].to_s.to_sym if options[:channel]
+      @token        = options[:token] if options[:token]
       @connection   = options[:connection]
       @server_token = options[:server_token]
       @user_id      = options[:user_id]
@@ -125,6 +131,7 @@ module WebsocketRails
           :data => data,
           :success => success,
           :result => result,
+          :token => token,
           :server_token => server_token
         }
       ]

data/lib/websocket_rails/logging.rb

@@ -46,7 +46,6 @@ module WebsocketRails
       message.chomp.split("\n").each do |line|
         logger.send(level, wrap(level, self, line, options || {}))
       end
-      logger << "\n"
     end
 
     def log_event_start(event)

data/lib/websocket_rails/synchronization.rb

@@ -33,6 +33,10 @@ module WebsocketRails
       singleton.shutdown!
     end
 
+    def self.redis
+      singleton.redis
+    end
+
     def self.singleton
       @singleton ||= new
     end
@@ -40,7 +44,10 @@ module WebsocketRails
     include Logging
 
     def redis
-      @redis ||= Redis.new(WebsocketRails.config.redis_options)
+      @redis ||= begin
+        redis_options = WebsocketRails.config.redis_options
+        EM.reactor_running? ? Redis.new(redis_options) : ruby_redis
+      end
     end
 
     def ruby_redis
@@ -52,9 +59,8 @@ module WebsocketRails
 
     def publish(event)
       Fiber.new do
-        redis_client = EM.reactor_running? ? redis : ruby_redis
         event.server_token = server_token
-        redis_client.publish "websocket_rails.events", event.serialize
+        redis.publish "websocket_rails.events", event.serialize
       end.resume
     end
 
@@ -157,16 +163,14 @@ module WebsocketRails
 
     def find_user(identifier)
       Fiber.new do
-        redis_client = EM.reactor_running? ? redis : ruby_redis
-        raw_user = redis_client.hget('websocket_rails.users', identifier)
+        raw_user = redis.hget('websocket_rails.users', identifier)
         raw_user ? JSON.parse(raw_user) : nil
       end.resume
     end
 
     def all_users
       Fiber.new do
-        redis_client = EM.reactor_running? ? redis : ruby_redis
-        redis_client.hgetall('websocket_rails.users')
+        redis.hgetall('websocket_rails.users')
       end.resume
     end
 

data/lib/websocket_rails/version.rb

@@ -1,3 +1,3 @@
 module WebsocketRails
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

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

@@ -0,0 +1,71 @@
+
+/*
+ Abstract Interface for the WebSocketRails client.
+ */
+
+(function() {
+  WebSocketRails.AbstractConnection = (function() {
+    function AbstractConnection(url, dispatcher) {
+      this.dispatcher = dispatcher;
+      this.message_queue = [];
+    }
+
+    AbstractConnection.prototype.close = function() {};
+
+    AbstractConnection.prototype.trigger = function(event) {
+      if (this.dispatcher.state !== 'connected') {
+        return this.message_queue.push(event);
+      } else {
+        return this.send_event(event);
+      }
+    };
+
+    AbstractConnection.prototype.send_event = function(event) {
+      if (this.connection_id != null) {
+        return event.connection_id = this.connection_id;
+      }
+    };
+
+    AbstractConnection.prototype.on_close = function(event) {
+      var close_event;
+      if (this.dispatcher && this.dispatcher._conn === this) {
+        close_event = new WebSocketRails.Event(['connection_closed', event]);
+        this.dispatcher.state = 'disconnected';
+        return this.dispatcher.dispatch(close_event);
+      }
+    };
+
+    AbstractConnection.prototype.on_error = function(event) {
+      var error_event;
+      if (this.dispatcher && this.dispatcher._conn === this) {
+        error_event = new WebSocketRails.Event(['connection_error', event]);
+        this.dispatcher.state = 'disconnected';
+        return this.dispatcher.dispatch(error_event);
+      }
+    };
+
+    AbstractConnection.prototype.on_message = function(event_data) {
+      if (this.dispatcher && this.dispatcher._conn === this) {
+        return this.dispatcher.new_message(event_data);
+      }
+    };
+
+    AbstractConnection.prototype.setConnectionId = function(connection_id) {
+      this.connection_id = connection_id;
+    };
+
+    AbstractConnection.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.trigger(event);
+      }
+      return this.message_queue = [];
+    };
+
+    return AbstractConnection;
+
+  })();
+
+}).call(this);

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

@@ -1,3 +1,4 @@
+
 /*
 The channel object is returned when you subscribe to a channel.
 
@@ -6,51 +7,53 @@ For instance:
   var awesome_channel = dispatcher.subscribe('awesome_channel');
   awesome_channel.bind('event', function(data) { console.log('channel event!'); });
   awesome_channel.trigger('awesome_event', awesome_object);
-*/
-
+ */
 
 (function() {
   var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
 
   WebSocketRails.Channel = (function() {
-    function Channel(name, _dispatcher, is_private) {
-      var event, event_name;
+    function Channel(name, _dispatcher, is_private, on_success, on_failure) {
+      var event, event_name, _ref;
       this.name = name;
       this._dispatcher = _dispatcher;
-      this.is_private = is_private;
+      this.is_private = is_private != null ? is_private : false;
+      this.on_success = on_success;
+      this.on_failure = on_failure;
       this._failure_launcher = __bind(this._failure_launcher, this);
       this._success_launcher = __bind(this._success_launcher, this);
-      this.dispatch = __bind(this.dispatch, this);
-      this.trigger = __bind(this.trigger, this);
-      this.bind = __bind(this.bind, this);
-      this.destroy = __bind(this.destroy, this);
+      this._callbacks = {};
+      this._token = void 0;
+      this._queue = [];
       if (this.is_private) {
         event_name = 'websocket_rails.subscribe_private';
       } else {
         event_name = 'websocket_rails.subscribe';
       }
+      this.connection_id = (_ref = this._dispatcher._conn) != null ? _ref.connection_id : void 0;
       event = new WebSocketRails.Event([
         event_name, {
           data: {
             channel: this.name
           }
-        }, this._dispatcher.connection_id
+        }, this.connection_id
       ], this._success_launcher, this._failure_launcher);
       this._dispatcher.trigger_event(event);
-      this._callbacks = {};
     }
 
     Channel.prototype.destroy = function() {
-      var event, event_name;
-      event_name = 'websocket_rails.unsubscribe';
-      event = new WebSocketRails.Event([
-        event_name, {
-          data: {
-            channel: this.name
-          }
-        }, this._dispatcher.connection_id
-      ]);
-      this._dispatcher.trigger_event(event);
+      var event, event_name, _ref;
+      if (this.connection_id === ((_ref = this._dispatcher._conn) != null ? _ref.connection_id : void 0)) {
+        event_name = 'websocket_rails.unsubscribe';
+        event = new WebSocketRails.Event([
+          event_name, {
+            data: {
+              channel: this.name
+            }
+          }, this.connection_id
+        ]);
+        this._dispatcher.trigger_event(event);
+      }
       return this._callbacks = {};
     };
 
@@ -67,24 +70,35 @@ For instance:
       event = new WebSocketRails.Event([
         event_name, {
           channel: this.name,
-          data: message
-        }, this._dispatcher.connection_id
+          data: message,
+          token: this._token
+        }, this.connection_id
       ]);
-      return this._dispatcher.trigger_event(event);
+      if (!this._token) {
+        return this._queue.push(event);
+      } else {
+        return this._dispatcher.trigger_event(event);
+      }
     };
 
     Channel.prototype.dispatch = function(event_name, message) {
-      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(message));
+      var callback, _i, _len, _ref, _ref1, _results;
+      if (event_name === 'websocket_rails.channel_token') {
+        this.connection_id = (_ref = this._dispatcher._conn) != null ? _ref.connection_id : void 0;
+        this._token = message['token'];
+        return this.flush_queue();
+      } else {
+        if (this._callbacks[event_name] == null) {
+          return;
+        }
+        _ref1 = this._callbacks[event_name];
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          callback = _ref1[_i];
+          _results.push(callback(message));
+        }
+        return _results;
       }
-      return _results;
     };
 
     Channel.prototype._success_launcher = function(data) {
@@ -99,6 +113,16 @@ For instance:
       }
     };
 
+    Channel.prototype.flush_queue = function() {
+      var event, _i, _len, _ref;
+      _ref = this._queue;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        event = _ref[_i];
+        this._dispatcher.trigger_event(event);
+      }
+      return this._queue = [];
+    };
+
     return Channel;
 
   })();

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

@@ -1,28 +1,21 @@
+
 /*
 The Event object stores all the relevant event information.
-*/
-
+ */
 
 (function() {
-  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
-
   WebSocketRails.Event = (function() {
     function Event(data, success_callback, failure_callback) {
       var attr;
       this.success_callback = success_callback;
       this.failure_callback = failure_callback;
-      this.run_callbacks = __bind(this.run_callbacks, this);
-      this.attributes = __bind(this.attributes, this);
-      this.serialize = __bind(this.serialize, this);
-      this.is_ping = __bind(this.is_ping, this);
-      this.is_result = __bind(this.is_result, this);
-      this.is_channel = __bind(this.is_channel, this);
       this.name = data[0];
       attr = data[1];
       if (attr != null) {
         this.id = attr['id'] != null ? attr['id'] : ((1 + Math.random()) * 0x10000) | 0;
         this.channel = attr.channel != null ? attr.channel : void 0;
         this.data = attr.data != null ? attr.data : attr;
+        this.token = attr.token != null ? attr.token : void 0;
         this.connection_id = data[2];
         if (attr.success != null) {
           this.result = true;
@@ -36,7 +29,7 @@ The Event object stores all the relevant event information.
     };
 
     Event.prototype.is_result = function() {
-      return this.result === true;
+      return typeof this.result !== 'undefined';
     };
 
     Event.prototype.is_ping = function() {
@@ -51,15 +44,18 @@ The Event object stores all the relevant event information.
       return {
         id: this.id,
         channel: this.channel,
-        data: this.data
+        data: this.data,
+        token: this.token
       };
     };
 
-    Event.prototype.run_callbacks = function(success, data) {
-      if (success === true) {
-        return typeof this.success_callback === "function" ? this.success_callback(data) : void 0;
+    Event.prototype.run_callbacks = function(success, result) {
+      this.success = success;
+      this.result = result;
+      if (this.success === true) {
+        return typeof this.success_callback === "function" ? this.success_callback(this.result) : void 0;
       } else {
-        return typeof this.failure_callback === "function" ? this.failure_callback(data) : void 0;
+        return typeof this.failure_callback === "function" ? this.failure_callback(this.result) : void 0;
       }
     };
 

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

@@ -1,15 +1,22 @@
+
 /*
  HTTP 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.HttpConnection = (function(_super) {
+    __extends(HttpConnection, _super);
 
-  WebSocketRails.HttpConnection = (function() {
-    HttpConnection.prototype.httpFactories = function() {
+    HttpConnection.prototype.connection_type = 'http';
+
+    HttpConnection.prototype._httpFactories = function() {
       return [
         function() {
+          return new XDomainRequest();
+        }, function() {
           return new XMLHttpRequest();
         }, function() {
           return new ActiveXObject("Msxml2.XMLHTTP");
@@ -21,93 +28,88 @@
       ];
     };
 
-    HttpConnection.prototype.createXMLHttpObject = function() {
-      var e, 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 (_error) {
-          e = _error;
-          continue;
-        }
-        break;
-      }
-      return xmlhttp;
-    };
-
     function HttpConnection(url, dispatcher) {
-      this.url = url;
+      var e;
       this.dispatcher = dispatcher;
-      this.connectionClosed = __bind(this.connectionClosed, this);
-      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._url = this.url;
-      this._conn = this.createXMLHttpObject();
+      HttpConnection.__super__.constructor.apply(this, arguments);
+      this._url = "http://" + url;
+      this._conn = this._createXMLHttpObject();
       this.last_pos = 0;
-      this.message_queue = [];
-      this._conn.onreadystatechange = this.parse_stream;
-      this._conn.addEventListener("load", this.connectionClosed, false);
+      try {
+        this._conn.onreadystatechange = (function(_this) {
+          return function() {
+            return _this._parse_stream();
+          };
+        })(this);
+        this._conn.addEventListener("load", this.on_close, false);
+      } catch (_error) {
+        e = _error;
+        this._conn.onprogress = (function(_this) {
+          return function() {
+            return _this._parse_stream();
+          };
+        })(this);
+        this._conn.onload = this.on_close;
+        this._conn.readyState = 3;
+      }
       this._conn.open("GET", this._url, 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(/\]\]\[\[/g, "],[");
-        decoded_data = JSON.parse(data);
-        return this.dispatcher.new_message(decoded_data);
-      }
+    HttpConnection.prototype.close = function() {
+      return this._conn.abort();
     };
 
-    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.send_event = function(event) {
+      HttpConnection.__super__.send_event.apply(this, arguments);
+      return this._post_data(event.serialize());
     };
 
-    HttpConnection.prototype.post_data = function(connection_id, payload) {
+    HttpConnection.prototype._post_data = function(payload) {
       return $.ajax(this._url, {
         type: 'POST',
         data: {
-          client_id: connection_id,
+          client_id: this.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;
+    HttpConnection.prototype._createXMLHttpObject = function() {
+      var e, 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 (_error) {
+          e = _error;
+          continue;
         }
-        this.trigger(event);
+        break;
       }
-      return this.message_queue = [];
+      return xmlhttp;
     };
 
-    HttpConnection.prototype.connectionClosed = function(event) {
-      var close_event;
-      close_event = new WebSocketRails.Event(['connection_closed', event]);
-      this.dispatcher.state = 'disconnected';
-      return this.dispatcher.dispatch(close_event);
+    HttpConnection.prototype._parse_stream = function() {
+      var data, e, event_data;
+      if (this._conn.readyState === 3) {
+        data = this._conn.responseText.substring(this.last_pos);
+        this.last_pos = this._conn.responseText.length;
+        data = data.replace(/\]\]\[\[/g, "],[");
+        try {
+          event_data = JSON.parse(data);
+          return this.on_message(event_data);
+        } catch (_error) {
+          e = _error;
+        }
+      }
     };
 
     return HttpConnection;
 
-  })();
+  })(WebSocketRails.AbstractConnection);
 
 }).call(this);