websocket-rails 0.1.3 → 0.1.4

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # WebsocketRails Change Log
 
+## Version 0.1.4
+
+June 30 2012
+
+* Added channel support
+* Fix the JavaScript client to work on the iPad - Thanks to @adamkittelson
+* Add an event queue on the connection object to allow for queueing up
+  multiple events before flushing to the client.
+* Add generator for creating the events.rb intializer and requiring the
+  client in the application.js sprockets manifest file.
+
 ## Version 0.1.3
 
 June 22 2012

data/Gemfile

@@ -9,3 +9,10 @@ gem "simplecov"
 gem "ruby_gntp"
 gem "guard"
 gem "guard-rspec"
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter', :require => 'jdbc-sqlite3', :require => 'arjdbc'
+end
+platforms :ruby do
+  gem 'sqlite3'
+end

data/README.md

@@ -21,8 +21,8 @@ We are finally very close to the first production release. Any comments or sugge
 Check out the [Example Application](https://github.com/DanKnox/websocket-rails-Example-Project) for additional information.
 
 1. Add the gem to your Gemfile
-3. Create a WebsocketRails controller - [See Documentation](http://rdoc.info/github/DanKnox/websocket-rails/master/WebsocketRails/BaseController)
-4. Create an `events.rb` initializer file to map events to your controller - [See Documentation](http://rdoc.info/github/DanKnox/websocket-rails/master/WebsocketRails/Events)
+3. Create a WebsocketRails controller - [See Documentation](http://rdoc.info/github/DanKnox/websocket-rails/master/frames/WebsocketRails/BaseController)
+4. Create an `events.rb` initializer file to map events to your controller - [See Documentation](http://rdoc.info/github/DanKnox/websocket-rails/master/frames/WebsocketRails/EventMap)
 5. Launch the web server and connect a WebSocket client to `ws://yourserver:port/websocket`
 
 *Important Note About Web Servers*
@@ -42,7 +42,7 @@ There are two built in events that are fired automatically by the dispatcher. Th
 You can subscribe multiple controllers and actions to the same event to provide very clean event handling logic. The new message will be available in each controller using the `message` method discussed in the *Controllers* section below. The example event router below demonstrates subscribing to the `:new_message` event with one controller action to rebroadcast the message out to all connected clients and another controller action to log the message to a database.
 
 The Event Map now supports namespacing events. Events triggered on the
-client as `namespace.event_name` will now be dispatched the the action
+client as `namespace.event_name` will now be dispatched to the action
 subscribed to the `event_name` event under the `namespace` namespace.
 See the [EventMap
 Documentation](http://rdoc.info/github/DanKnox/websocket-rails/master/frames/WebsocketRails/EventMap) for more details.
@@ -72,28 +72,27 @@ end
 
 The `subscribe` method takes the event name as the first argument, then a hash where `:to` is the Controller class and `:with_method` is the action to execute.
 
-## JavaScript Dispatcher
+## WebSocketRails JavaScript Client
 
-There are two example dispatchers located in the [assets/javascripts](https://github.com/DanKnox/websocket-rails/tree/master/assets/javascripts) directory. One connects to the server using
-WebSockets and the other connects using streaming HTTP. These will eventually be merged into one dispatcher that selects the best transport at runtime based on what's available in the
-browser. A pull request providing this functionality will definitely be accepted.
-
-The current dispatchers are limited in functionality and meant mostly as a reference implementation. The two dispatchers are functionally equivalent and can be swapped out at will.
+There is an accompanying JavaScript client [located here](https://github.com/DanKnox/websocket-rails/tree/master/lib/assets/javascripts/websocket_rails). The client detects support for WebSockets in the browser and falls back to HTTP streaming if it is unavailable. The client currently works in every major browser except for internet explorer. If you are using the current master branch of this repository, you can require the client in your application.js manifest directly: `//= require websocket_rails/main`. The client will be released to rubygems soon. 
 
 ````javascript
-//Setting up the dispatcher and connecting to the server:
-var dispatcher = new ServerEventsDispatcher()
-dispatcher.onopen(function() {
+// Setting up the client and connecting to the server:
+// Do not pass the prefix of the URL, 'ws://' will be
+// added automatically when the client uses WebSockets
+var dispatcher = new WebSocketRails("localhost:port/websocket");
+
+dispatcher.on_open = function() {
 	// trigger a server event immediately after opening connection
-	dispatcher.trigger('new_user',{user_name: 'guest'})
-})
+	dispatcher.trigger('new_user',{user_name: 'guest'});
+}
 
 //Triggering a new event on the server
-dispatcher.trigger('event_name',object_to_be_serialized_to_json)
+dispatcher.trigger('event_name',object_to_be_serialized_to_json);
 
 //Listening for new events from the server
 dispatcher.bind('event_name', function(data) {
-	alert(data.user_name)
+	console.log(data.user_name);
 })
 ````
 

data/lib/assets/javascripts/websocket_rails/channel.js

@@ -0,0 +1,35 @@
+/*
+ * 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() { console.log('channel event!'); });
+ *   awesome_channel.trigger('awesome_event', awesome_object);
+ */
+
+WebSocketRails.Channel = function(name,dispatcher) {
+  var that = this;
+  that.name = name;
+
+  dispatcher.trigger('websocket_rails.subscribe',{channel: name})
+
+  var callbacks = {};
+
+  that.bind = function(event_name, callback) {
+    callbacks[event_name] = callbacks[event_name] || [];
+    callbacks[event_name].push(callback);
+  }
+
+  that.trigger = function(event_name, message) {
+    dispatcher.trigger_channel(that.name,event_name,message);
+  }
+
+  that.dispatch = function(event_name, message) {
+    var chain = callbacks[event_name];
+    if (typeof chain == 'undefined') return;
+    for(var i = 0; i < chain.length; i++) {
+      chain[i]( message );
+    }
+  }	
+}

data/lib/assets/javascripts/websocket_rails/http_connection.js

@@ -0,0 +1,68 @@
+/*
+ * HTTP Interface for the WebSocketRails client.
+ */
+WebSocketRails.HttpConnection = function(url,dispatcher){
+  var that = this,
+      conn = WebSocketRails.createXMLHttpObject(),
+      lastPos = 0;
+
+  conn.onreadystatechange = function() {
+    if (conn.readyState == 3) {
+      var data = conn.responseText.substring(lastPos);
+      lastPos = conn.responseText.length;
+
+      console.log('raw data: '+data);
+      var json_data = JSON.parse(data);
+
+      console.log(json_data);
+      that.new_message(json_data);
+    }
+  }
+  conn.open("GET","/websocket",true);
+  conn.send();
+
+
+  that.trigger = function(event_name, data, client_id) {
+    var payload = JSON.stringify([event_name,data]);
+    $.ajax({
+      type: 'POST',
+      url: '/websocket',
+      data: {client_id: client_id, data: payload},
+      success: function(){console.log('success');}
+    });
+    return this;
+  }
+
+  that.trigger_channel = function(channel, event_name, data, client_id) {
+    var payload = JSON.stringify([channel,event_name,data]);
+    $.ajax({
+      type: 'POST',
+      url: '/websocket',
+      data: {client_id: client_id, data: payload},
+      success: function(){console.log('success');}
+    });
+    return this;
+  }
+}
+
+WebSocketRails.XMLHttpFactories = [
+  function () {return new XMLHttpRequest()},
+  function () {return new ActiveXObject("Msxml2.XMLHTTP")},
+  function () {return new ActiveXObject("Msxml3.XMLHTTP")},
+  function () {return new ActiveXObject("Microsoft.XMLHTTP")}
+];
+
+WebSocketRails.createXMLHttpObject = function() {
+  var xmlhttp = false,
+      factories = WebSocketRails.XMLHttpFactories;
+  for (var i=0;i<factories.length;i++) {
+    try {
+      xmlhttp = factories[i]();
+    }
+    catch (e) {
+      continue;
+    }
+    break;
+  }
+  return xmlhttp;
+}

data/lib/assets/javascripts/websocket_rails/main.js

@@ -0,0 +1,4 @@
+//= require ./websocket_rails
+//= require ./http_connection
+//= require ./websocket_connection
+//= require ./channel

data/lib/assets/javascripts/websocket_rails/websocket_connection.js

@@ -0,0 +1,38 @@
+/*
+ * WebSocket Interface for the WebSocketRails client.
+ */
+WebSocketRails.WebSocketConnection = function(url,dispatcher){
+  var that = this,
+      conn = new WebSocket("ws://"+url);
+
+  that.trigger = function(event_name, data, client_id) {
+    var payload = JSON.stringify([event_name,data])
+    conn.send( payload )
+    return this;
+  }
+
+  that.trigger_channel = function(channel, event_name, data, client_id) {
+    var payload = JSON.stringify([channel,event_name,data])
+    conn.send( payload )
+    return this;
+  }
+
+  conn.onmessage = function(evt) {
+    var data = JSON.parse(evt.data);
+
+    console.log(data)
+    that.new_message(data);
+  }
+
+  conn.onclose = function(evt) {
+    dispatcher.dispatch('connection_closed', '')
+  }
+
+  var dispatch = function(event_name, message) {
+    var chain = callbacks[event_name]
+    if (typeof chain == 'undefined') return;
+    for(var i = 0; i < chain.length; i++) {
+      chain[i]( message )
+    }
+  }	
+}

data/lib/assets/javascripts/websocket_rails/websocket_rails.js

@@ -0,0 +1,100 @@
+/*
+* 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
+* 	dispatcher.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);
+* 	})
+*/
+var WebSocketRails = function(url) {
+  var that = this,
+      client_id = 0;
+  
+  that.state = 'connecting';
+
+  if( typeof(WebSocket) != "function" && typeof(WebSocket) != "object" ) {
+    var conn = new WebSocketRails.HttpConnection(url);
+  } else {
+    var conn = new WebSocketRails.WebSocketConnection(url,that);
+  }
+
+  var on_open = function(data) {
+    that.state = 'connected';
+    that.connection_id = data.connection_id;
+
+    if (typeof that.on_open !== 'undefined') {
+      that.on_open(data);
+    }
+  }
+
+  conn.new_message = function(data) {
+    for(i = 0; i < data.length; i++) {
+      socket_message = data[i];
+      var is_channel = false;
+
+      if (data.length > 2) {
+        var channel_name = socket_message[0],
+            event_name   = socket_message[1],
+            message      = socket_message[2];
+        is_channel = true;
+      } else {
+        var event_name = socket_message[0],
+            message    = socket_message[1];
+      }
+      if (that.state === 'connecting' && event_name === 'client_connected') {
+        on_open(message);
+      }
+      if (is_channel == true) {
+        that.dispatch_channel(channel_name, event_name, message);
+      } else {
+        that.dispatch(event_name, message);
+      }
+    }
+  }
+
+  var callbacks = {};
+
+  that.bind = function(event_name, callback) {
+    callbacks[event_name] = callbacks[event_name] || [];
+    callbacks[event_name].push(callback);
+  }
+
+  that.trigger = function(event_name, data) {
+    conn.trigger(event_name,data,that.connection_id);
+  }
+
+  that.trigger_channel = function(channel, event_name, data) {
+    conn.trigger_channel(channel,event_name,data,that.connection_id);
+  }
+
+  var channels = {};
+  that.subscribe = function(channel_name) {
+    var channel = new WebSocketRails.Channel(channel_name,this);
+    channels[channel_name] = channel;
+    return channel;
+  }
+  
+  that.dispatch = function(event_name, message) {
+    var chain = callbacks[event_name];
+    if (typeof chain == 'undefined') return;
+    for(var i = 0; i < chain.length; i++) {
+      chain[i]( message );
+    }
+  }	
+
+  that.dispatch_channel = function(channel, event_name, message) {
+    var channel = that.channels[channel];
+    if (typeof channel == 'undefined') return;
+    channel.dispatch(event_name, message);
+  }
+}

data/lib/generators/websocket_rails/install/install_generator.rb

@@ -0,0 +1,32 @@
+require 'rails'
+
+module WebsocketRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Create the events.rb initializer and require the JS client in the application.js manifest."
+
+      class_option :manifest, :type => :string, :aliases => "-m", :default => 'application.js',
+                   :desc => "Javascript manifest file to modify (or create)"
+
+      def create_events_initializer_file
+        template 'events.rb', File.join('config', 'initializers', 'events.rb')
+      end
+
+      def inject_websocket_rails_client
+        manifest = options[:manifest]
+        js_path  = "app/assets/javascripts"
+
+        create_file("#{js_path}/#{manifest}") unless File.exists?("#{js_path}/#{manifest}")
+
+        append_to_file "#{js_path}/#{manifest}" do
+          out = ""
+          out << "//= require websocket_rails/main"
+          out << "\n"
+          out << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/websocket_rails/install/templates/events.rb

@@ -0,0 +1,14 @@
+WebsocketRails::EventMap.describe do
+  # You can use this file to map incoming events to controller actions.
+  # One event can be mapped to any number of controller actions. The
+  # actions will be executed in the order they were subscribed.
+  #
+  # Uncomment and edit the next line to handle the client connected event:
+  #   subscribe :client_connected, :to => Controller, :with_method => :method_name
+  #
+  # Here is an example of mapping namespaced events:
+  #   namespace :product do
+  #     subscribe :new, :to => ProductController, :with_method => :new_product
+  #   end
+  # The above will handle an event triggered on the client like `product.new`.
+end

data/lib/websocket-rails.rb

@@ -22,7 +22,11 @@ require 'websocket_rails/connection_manager'
 require 'websocket_rails/dispatcher'
 require 'websocket_rails/event'
 require 'websocket_rails/event_map'
+require 'websocket_rails/event_queue'
+require 'websocket_rails/channel'
+require 'websocket_rails/channel_manager'
 require 'websocket_rails/base_controller'
+require 'websocket_rails/internal_events'
 
 require 'websocket_rails/connection_adapters'
 require 'websocket_rails/connection_adapters/http'

data/lib/websocket_rails/base_controller.rb

@@ -91,13 +91,15 @@ module WebsocketRails
     #
     # See the {EventMap} documentation for more on mapping namespaced actions.
     def send_message(event_name, message, options={})
-      event = Event.new( event_name, message, connection, options )
+      options.merge! :connection => connection
+      event = Event.new( event_name, message, options )
       @_dispatcher.send_message event if @_dispatcher.respond_to?(:send_message)
     end
     
     # Broadcasts a message to all connected clients. See {#send_message} for message passing details.
     def broadcast_message(event_name, message, options={})
-      event = Event.new( event_name, message, connection, options )
+      options.merge! :connection => connection
+      event = Event.new( event_name, message, options )
       @_dispatcher.broadcast_message event if @_dispatcher.respond_to?(:broadcast_message)
     end
     

data/lib/websocket_rails/channel.rb

@@ -0,0 +1,35 @@
+module WebsocketRails
+  class Channel
+
+    attr_reader :name, :subscribers
+
+    def initialize(channel_name)
+      @subscribers = []
+      @name = channel_name
+    end
+
+    def subscribe(connection)
+      @subscribers << connection
+    end
+
+    def trigger(event_name,data,options={})
+      options.merge! :channel => name
+      event = Event.new event_name, data, options
+      send_data event
+    end
+
+    def trigger_event(event)
+      send_data event
+    end
+
+    private
+
+    def send_data(event)
+      puts "sending channel event: #{event.serialize}"
+      subscribers.each do |subscriber|
+        subscriber.trigger event
+      end
+    end
+
+  end
+end