websocket-rails-js 0.0.1

data/src/websocket_rails/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/src/websocket_rails/channel.js

@@ -0,0 +1,133 @@
+
+/*
+The channel object is returned when you subscribe to a channel.
+
+For instance:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  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, on_success, on_failure) {
+      var event, event_name, _ref;
+      this.name = name;
+      this._dispatcher = _dispatcher;
+      this.is_private = is_private;
+      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);
+      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, {
+          channel: this.name
+        }, {
+          connection_id: this.connection_id
+        }
+      ], this._success_launcher, this._failure_launcher);
+      this._dispatcher.trigger_event(event);
+      this._callbacks = {};
+      this._token = void 0;
+      this._queue = [];
+    }
+
+    Channel.prototype.is_public = function() {
+      return !this.is_private;
+    };
+
+    Channel.prototype.destroy = function() {
+      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, {
+            channel: this.name
+          }, {
+            connection_id: this.connection_id,
+            token: this._token
+          }
+        ]);
+        this._dispatcher.trigger_event(event);
+      }
+      return this._callbacks = {};
+    };
+
+    Channel.prototype.bind = function(event_name, callback) {
+      var _base;
+      if ((_base = this._callbacks)[event_name] == null) {
+        _base[event_name] = [];
+      }
+      return this._callbacks[event_name].push(callback);
+    };
+
+    Channel.prototype.unbind = function(event_name) {
+      return delete this._callbacks[event_name];
+    };
+
+    Channel.prototype.trigger = function(event_name, message) {
+      var event;
+      event = new WebSocketRails.Event([
+        event_name, message, {
+          connection_id: this.connection_id,
+          channel: this.name,
+          token: this._token
+        }
+      ]);
+      if (!this._token) {
+        return this._queue.push(event);
+      } else {
+        return this._dispatcher.trigger_event(event);
+      }
+    };
+
+    Channel.prototype.dispatch = function(event_name, message) {
+      var callback, event, _i, _j, _len, _len1, _ref, _ref1, _results;
+      if (event_name === 'websocket_rails.channel_token') {
+        this._token = message['token'];
+        _ref = this._queue;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          event = _ref[_i];
+          this._dispatcher.trigger_event(event);
+        }
+        return this._queue = [];
+      } else {
+        if (this._callbacks[event_name] == null) {
+          return;
+        }
+        _ref1 = this._callbacks[event_name];
+        _results = [];
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+          callback = _ref1[_j];
+          _results.push(callback(message));
+        }
+        return _results;
+      }
+    };
+
+    Channel.prototype._success_launcher = function(data) {
+      if (this.on_success != null) {
+        return this.on_success(data);
+      }
+    };
+
+    Channel.prototype._failure_launcher = function(data) {
+      if (this.on_failure != null) {
+        return this.on_failure(data);
+      }
+    };
+
+    return Channel;
+
+  })();
+
+}).call(this);

data/src/websocket_rails/connection.js

@@ -0,0 +1,91 @@
+
+/*
+WebSocket Interface for the WebSocketRails client.
+ */
+
+(function() {
+  WebSocketRails.Connection = (function() {
+    function Connection(url, dispatcher) {
+      this.url = url;
+      this.dispatcher = dispatcher;
+      this.message_queue = [];
+      this.state = 'connecting';
+      this.connection_id;
+      if (!(this.url.match(/^wss?:\/\//) || this.url.match(/^ws?:\/\//))) {
+        if (window.location.protocol === 'https:') {
+          this.url = "wss://" + this.url;
+        } else {
+          this.url = "ws://" + this.url;
+        }
+      }
+      this._conn = new WebSocket(this.url);
+      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);
+    }
+
+    Connection.prototype.on_message = function(event) {
+      return this.dispatcher.new_message(event);
+    };
+
+    Connection.prototype.on_close = function(event) {
+      var data;
+      this.dispatcher.state = 'disconnected';
+      data = (event != null ? event.data : void 0) ? event.data : event;
+      return this.dispatcher.dispatch(new WebSocketRails.Event(['connection_closed', data]));
+    };
+
+    Connection.prototype.on_error = function(event) {
+      this.dispatcher.state = 'disconnected';
+      return this.dispatcher.dispatch(new WebSocketRails.Event(['connection_error', event.data]));
+    };
+
+    Connection.prototype.trigger = function(event) {
+      if (this.dispatcher.state !== 'connected') {
+        return this.message_queue.push(event);
+      } else {
+        return this.send_event(event);
+      }
+    };
+
+    Connection.prototype.close = function() {
+      return this._conn.close();
+    };
+
+    Connection.prototype.setConnectionId = function(connection_id) {
+      return this.connection_id = connection_id;
+    };
+
+    Connection.prototype.send_event = function(event) {
+      return this._conn.send(event.serialize());
+    };
+
+    Connection.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 Connection;
+
+  })();
+
+}).call(this);

data/src/websocket_rails/event.js

@@ -0,0 +1,66 @@
+
+/*
+The Event object stores all the relevant event information.
+ */
+
+(function() {
+  WebSocketRails.Event = (function() {
+    function Event(message, success_callback, failure_callback) {
+      var options;
+      this.success_callback = success_callback;
+      this.failure_callback = failure_callback;
+      this.name = message[0];
+      this.data = message[1];
+      options = message[2];
+      if (options != null) {
+        this.id = options['id'] != null ? options['id'] : ((1 + Math.random()) * 0x10000) | 0;
+        this.channel = options.channel;
+        this.token = options.token;
+        this.connection_id = options.connection_id;
+        if (options.success != null) {
+          this.result = true;
+          this.success = options.success;
+        }
+      }
+    }
+
+    Event.prototype.is_channel = function() {
+      return this.channel != null;
+    };
+
+    Event.prototype.is_result = function() {
+      return typeof this.result !== 'undefined';
+    };
+
+    Event.prototype.is_ping = function() {
+      return this.name === 'websocket_rails.ping';
+    };
+
+    Event.prototype.serialize = function() {
+      return JSON.stringify([this.name, this.data, this.meta_data()]);
+    };
+
+    Event.prototype.meta_data = function() {
+      return {
+        id: this.id,
+        connection_id: this.connection_id,
+        channel: this.channel,
+        token: this.token
+      };
+    };
+
+    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(this.result) : void 0;
+      }
+    };
+
+    return Event;
+
+  })();
+
+}).call(this);

data/src/websocket_rails/http_connection.js

@@ -0,0 +1,97 @@
+
+/*
+ HTTP Interface for the WebSocketRails client.
+ */
+
+(function() {
+  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);
+
+    HttpConnection.prototype.connection_type = 'http';
+
+    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");
+        }
+      ];
+    };
+
+    function HttpConnection(url, dispatcher) {
+      this.dispatcher = dispatcher;
+      HttpConnection.__super__.constructor.apply(this, arguments);
+      this._url = "http://" + url;
+      this._conn = this._createXMLHttpObject();
+      this.last_pos = 0;
+      this._conn.onreadystatechange = (function(_this) {
+        return function() {
+          return _this._parse_stream();
+        };
+      })(this);
+      this._conn.addEventListener("load", this.on_close, false);
+      this._conn.open("GET", this._url, true);
+      this._conn.send();
+    }
+
+    HttpConnection.prototype.close = function() {
+      return this._conn.abort();
+    };
+
+    HttpConnection.prototype.send_event = function(event) {
+      HttpConnection.__super__.send_event.apply(this, arguments);
+      return this._post_data(event.serialize());
+    };
+
+    HttpConnection.prototype._post_data = function(payload) {
+      return $.ajax(this._url, {
+        type: 'POST',
+        data: {
+          client_id: this.connection_id,
+          data: payload
+        },
+        success: function() {}
+      });
+    };
+
+    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;
+    };
+
+    HttpConnection.prototype._parse_stream = function() {
+      var data, 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, "],[");
+        event_data = JSON.parse(data);
+        return this.on_message(event_data);
+      }
+    };
+
+    return HttpConnection;
+
+  })(WebSocketRails.AbstractConnection);
+
+}).call(this);