websocket-rails 0.1.1 → 0.1.2

data/.gitignore

@@ -3,6 +3,7 @@ coverage/
 .DS_Store
 .bundle/
 log/*.log
+*.log
 pkg/
 doc/
 test/dummy/db/*.sqlite3

data/Gemfile

@@ -5,4 +5,6 @@ gemspec
 gem "rspec-rails"
 gem "eventmachine", ">= 1.0.0.beta.3"
 gem "faye-websocket"
-gem "simplecov"
+gem "simplecov"
+gem "guard"
+gem "guard-rspec"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    websocket-rails (0.1.1)
+    websocket-rails (0.1.2)
       faye-websocket
       rack
       thin
@@ -9,101 +9,124 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    abstract (1.0.0)
-    actionmailer (3.0.12)
-      actionpack (= 3.0.12)
-      mail (~> 2.2.19)
-    actionpack (3.0.12)
-      activemodel (= 3.0.12)
-      activesupport (= 3.0.12)
-      builder (~> 2.1.2)
-      erubis (~> 2.6.6)
-      i18n (~> 0.5.0)
-      rack (~> 1.2.5)
-      rack-mount (~> 0.6.14)
-      rack-test (~> 0.5.7)
-      tzinfo (~> 0.3.23)
-    activemodel (3.0.12)
-      activesupport (= 3.0.12)
-      builder (~> 2.1.2)
-      i18n (~> 0.5.0)
-    activerecord (3.0.12)
-      activemodel (= 3.0.12)
-      activesupport (= 3.0.12)
-      arel (~> 2.0.10)
-      tzinfo (~> 0.3.23)
-    activeresource (3.0.12)
-      activemodel (= 3.0.12)
-      activesupport (= 3.0.12)
-    activesupport (3.0.12)
-    arel (2.0.10)
-    builder (2.1.2)
+    actionmailer (3.2.5)
+      actionpack (= 3.2.5)
+      mail (~> 2.4.4)
+    actionpack (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.5)
+      activesupport (= 3.2.5)
+      builder (~> 3.0.0)
+    activerecord (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.5)
+      activemodel (= 3.2.5)
+      activesupport (= 3.2.5)
+    activesupport (3.2.5)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
     daemons (1.1.8)
     diff-lcs (1.1.3)
-    erubis (2.6.6)
-      abstract (>= 1.0.0)
+    erubis (2.7.0)
     eventmachine (1.0.0.beta.4)
     faye-websocket (0.4.5)
       eventmachine (>= 0.12.0)
-    i18n (0.5.0)
-    json (1.6.5)
-    mail (2.2.19)
-      activesupport (>= 2.3.6)
+    ffi (1.0.11)
+    guard (1.1.1)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-rspec (1.0.0)
+      guard (>= 1.1)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    json (1.7.3)
+    listen (0.4.3)
+      rb-fchange (~> 0.0.5)
+      rb-fsevent (~> 0.9.1)
+      rb-inotify (~> 0.8.8)
+    mail (2.4.4)
       i18n (>= 0.4.0)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
     mime-types (1.18)
     multi_json (1.3.6)
     polyglot (0.3.3)
-    rack (1.2.5)
-    rack-mount (0.6.14)
-      rack (>= 1.0.0)
-    rack-test (0.5.7)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
       rack (>= 1.0)
-    rails (3.0.12)
-      actionmailer (= 3.0.12)
-      actionpack (= 3.0.12)
-      activerecord (= 3.0.12)
-      activeresource (= 3.0.12)
-      activesupport (= 3.0.12)
+    rails (3.2.5)
+      actionmailer (= 3.2.5)
+      actionpack (= 3.2.5)
+      activerecord (= 3.2.5)
+      activeresource (= 3.2.5)
+      activesupport (= 3.2.5)
       bundler (~> 1.0)
-      railties (= 3.0.12)
-    railties (3.0.12)
-      actionpack (= 3.0.12)
-      activesupport (= 3.0.12)
+      railties (= 3.2.5)
+    railties (3.2.5)
+      actionpack (= 3.2.5)
+      activesupport (= 3.2.5)
+      rack-ssl (~> 1.3.2)
       rake (>= 0.8.7)
       rdoc (~> 3.4)
-      thor (~> 0.14.4)
+      thor (>= 0.14.6, < 2.0)
     rake (0.9.2.2)
+    rb-fchange (0.0.5)
+      ffi
+    rb-fsevent (0.9.1)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
     rdoc (3.12)
       json (~> 1.4)
-    rspec (2.9.0)
-      rspec-core (~> 2.9.0)
-      rspec-expectations (~> 2.9.0)
-      rspec-mocks (~> 2.9.0)
-    rspec-core (2.9.0)
-    rspec-expectations (2.9.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.9.0)
-    rspec-rails (2.9.0)
+    rspec-mocks (2.10.1)
+    rspec-rails (2.10.1)
       actionpack (>= 3.0)
       activesupport (>= 3.0)
       railties (>= 3.0)
-      rspec (~> 2.9.0)
+      rspec (~> 2.10.0)
     simplecov (0.6.4)
       multi_json (~> 1.0)
       simplecov-html (~> 0.5.3)
     simplecov-html (0.5.3)
-    sqlite3 (1.3.5)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.6)
     thin (1.3.1)
       daemons (>= 1.0.9)
       eventmachine (>= 0.12.6)
       rack (>= 1.0.0)
-    thor (0.14.6)
+    thor (0.15.2)
+    tilt (1.3.3)
     treetop (1.4.10)
       polyglot
       polyglot (>= 0.3.1)
-    tzinfo (0.3.32)
+    tzinfo (0.3.33)
 
 PLATFORMS
   ruby
@@ -111,6 +134,8 @@ PLATFORMS
 DEPENDENCIES
   eventmachine (>= 1.0.0.beta.3)
   faye-websocket
+  guard
+  guard-rspec
   rails
   rake
   rspec-rails

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/websocket_rails/(.+)\.rb$})     { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -6,7 +6,7 @@ If you haven't done so yet, check out the [Project Page](http://danknox.github.c
 
 ## Overview
 
-Plug and play WebSocket support for ruby on rails. Includes event router for mapping javascript events to controller actions. There is no need for a separate WebSocket server process. Requests to `/websocket` will be passed through to the `ConnectionManager` class which is a simple Rack based WebSocket server developed using the `Faye::WebSocket` library.
+Plug and play WebSocket support for ruby on rails with streaming HTTP fallback for improved cross browser compatibility. Includes event router for mapping javascript events to controller actions. There is no need for a separate WebSocket server process. Requests to `/websocket` will be passed through to the `ConnectionManager` class which is a simple Rack based WebSocket server developed using the `Faye::WebSocket` library.
 
 *Important Note*
 
@@ -69,7 +69,8 @@ The websocket client must connect to `/websocket`. You can connect using the fol
 ````javascript
 var conn = new WebSocket("ws://localhost:3000/websocket")
 conn.onopen = function(evt) {
-	dispatcher.trigger('new_user',current_user) // Dispatcher not included
+  // Example dispatcher located in the assets/ directory
+	dispatcher.trigger('new_user',current_user)
 }
 
 conn.onmessage = function(evt) {
@@ -80,7 +81,23 @@ conn.onmessage = function(evt) {
 }
 ````
 
-We will be posting a basic javascript event dispatcher soon.
+There are two example dispatchers located in the
+[assets/javascripts](https://github.com/DanKnox/websocket-rails/tree/master/assets/javascripts) directory.
+One for connecting to the server using WebSockets and the other for
+using streaming HTTP. The HTTP dispatcher was built to mimick the
+WebSocket interface so they are completely interchangable. These will
+eventually be merged into one dispatcher which detects which protocol to
+use based on what's available in the browser. Please feel free to submit
+a pull request that accomplishes this.
+
+View the source for the dispatchers for example usage or check out the
+[example application](https://github.com/DanKnox/websocket-rails-Example-Project) for a working implementation.
+
+*Note on the dispatchers*
+
+The example dispatchers are currently meant to be used for reference and
+are not yet included into the Rails asset pipleline. If you want to use
+one, copy it into your local project.
 
 ## Controllers
 
@@ -97,7 +114,7 @@ class ChatController < WebsocketRails::BaseController
 end
 ````
 
-The Websocket::BaseController class provides methods for working with the WebSocket connection. Make sure you extend this class for controllers that you are using. The two most important methods are `send_message` and `broadcast_message`. The `send_message` method sends a message to the client that initiated this event, the `broadcast_message` method broadcasts messages to all connected clients. Both methods take two arguments, the event name to trigger on the client, and the message that accompanies it.
+The WebsocketRails::BaseController class provides methods for working with the WebSocket connection. Make sure you extend this class for controllers that you are using. The two most important methods are `send_message` and `broadcast_message`. The `send_message` method sends a message to the client that initiated this event, the `broadcast_message` method broadcasts messages to all connected clients. Both methods take two arguments, the event name to trigger on the client, and the message that accompanies it.
 
 ````ruby
 new_message = {:message => 'this is a message'}
@@ -149,7 +166,7 @@ end
 If you wish to output an Array of the assigned values in the data store for every connected client, you can use the `each_<key>` method, replacing `<key>` with the hash key that you wish to collect. 
   
 Given our ongoing chat server example, we could collect all of the current `User` objects like so:
-
+d
 ````ruby
 data_store[:user] = 'User3'
 data_store.each_user
@@ -167,7 +184,7 @@ end
 
 ## Message Format
 
-The message can be a string, hash, or array. The message is serialized as JSON before being sent to the client. The message arrives at the client as a two element serialized array with the `event_name` string as the first element and the message object you passed to the `message` parameter of the `send_message` method as the second element.
+The message can be a string, hash, or array. The message is serialized as JSON before being sent to the client. The message arrives at the client as a three element serialized array with the `client_id` as the first element,`event_name` string as the second element, and the message object you passed to the `message` parameter of the `send_message` method as the third element.
 
 If you executed this code in your controller:
 
@@ -179,7 +196,7 @@ send_message :new_message, new_message
 The message that arrives on the client would look like:
 
 ````javascript
-['new_message',{message: 'this is a message'}]
+['70291412510420','new_message',{message: 'this is a message'}]
 ````
 
 ## Development
@@ -188,4 +205,4 @@ This gem is created and maintained by Dan Knox and Kyle Whalen under the MIT Lic
 
 Brought to you by:
 
-Three Dot Loft LLC
+Three Dot Loft LLC

data/assets/javascripts/http_dispatcher.js

@@ -0,0 +1,77 @@
+/*
+* Example HTTP event dispatcher.
+* 
+* Setting up the dispatcher:
+* 	var dispatcher = new ServerEventsDispatcher()
+* 	dispatcher.onopen(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) {
+* 		alert(data.user_name)
+* 	})
+*/
+var ServerEventsDispatcher = function(){
+  var conn = new XMLHttpRequest(),
+      open_handler = function(){},
+      loaded = false,
+      lastPos = 0,
+      client_id = '';
+
+  conn.onreadystatechange = function() {
+    if (conn.readyState == 3) {
+      var data = conn.responseText.substring(lastPos);
+      lastPos = conn.responseText.length;
+      var json_data = JSON.parse(data),
+          id = json_data[0],
+          event_name = json_data[1],
+          message = json_data[2];
+
+      client_id = id
+      
+      if (loaded == false) {
+        open_handler();
+        loaded = true
+      }
+      console.log(json_data)
+      dispatch(event_name, message)
+    }
+  }
+  conn.open("GET","/websocket",true)
+  conn.send()
+
+  var callbacks = {}
+
+  this.bind = function(event_name, callback) {
+    callbacks[event_name] = callbacks[event_name] || [];
+    callbacks[event_name].push(callback)
+  }
+
+  this.trigger = function(event_name, data) {
+    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;
+  }
+
+  this.onopen = function(handler) {
+    open_handler = handler
+  }
+
+  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/assets/javascripts/websocket_dispatcher.js

@@ -0,0 +1,65 @@
+/*
+* Example WebSocket event dispatcher.
+* 
+* Setting up the dispatcher:
+* 	var dispatcher = new ServerEventsDispatcher()
+* 	dispatcher.onopen(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) {
+* 		alert(data.user_name)
+* 	})
+*/
+var ServerEventsDispatcher = function(){
+  var conn = new WebSocket("ws://localhost:3000/websocket"),
+  	open_handler = function(){},
+  	callbacks = {},
+  	client_id = '';
+
+	this.bind = function(event_name, callback) {
+		callbacks[event_name] = callbacks[event_name] || [];
+		callbacks[event_name].push(callback)
+	}
+
+	this.trigger = function(event_name, data) {
+		var payload = JSON.stringify([event_name,data])
+		conn.send( payload )
+		return this;
+	}
+
+	conn.onopen = function(evt) {
+    open_handler()
+	}
+  this.onopen = function(handler) {
+    open_handler = handler
+  }
+
+	conn.onmessage = function(evt) {
+		var data = JSON.parse(evt.data),
+      id = data[0],
+			event_name = data[1],
+			message = data[2];
+			
+    client_id = id
+		console.log(data)
+		dispatch(event_name, message)
+	}
+
+	conn.onclose = function(evt) {
+		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/websocket-rails.rb

@@ -23,5 +23,9 @@ require 'websocket_rails/dispatcher'
 require 'websocket_rails/events'
 require 'websocket_rails/base_controller'
 
+require 'websocket_rails/connection_adapters'
+require 'websocket_rails/connection_adapters/http'
+require 'websocket_rails/connection_adapters/web_socket'
+
 ::Thin::Server.send( :remove_const, 'DEFAULT_TIMEOUT' )
 ::Thin::Server.const_set( 'DEFAULT_TIMEOUT', 0 )

data/lib/websocket_rails/base_controller.rb

@@ -60,7 +60,7 @@ module WebsocketRails
     # for each currently active connection but can not be used to associate a client between
     # multiple connection attempts. 
     def client_id
-      connection.object_id
+      connection.id
     end
     
     # The current message that was passed from the client when the event was initiated. The
@@ -77,12 +77,12 @@ module WebsocketRails
     #   # Will arrive on the client as JSON string like the following:
     #   # ['new_message',{message: 'new message for the client'}]
     def send_message(event, message)
-      @_dispatcher.send_message event.to_s, message, connection if @_dispatcher.respond_to?(:send_message)
+      @_dispatcher.send_message client_id, event.to_s, message, connection 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, message)
-      @_dispatcher.broadcast_message event.to_s, message if @_dispatcher.respond_to?(:broadcast_message)
+      @_dispatcher.broadcast_message client_id, event.to_s, message if @_dispatcher.respond_to?(:broadcast_message)
     end
     
     # Provides access to the {DataStore} for the current controller. The {DataStore} provides convenience
@@ -107,4 +107,4 @@ module WebsocketRails
     end
     
   end
-end
+end

data/lib/websocket_rails/connection_adapters.rb

@@ -0,0 +1,52 @@
+module WebsocketRails
+  module ConnectionAdapters
+    
+    attr_reader :adapters
+    module_function :adapters
+    
+    def self.register_adapter(adapter)
+      @adapters ||= []
+      @adapters.unshift adapter
+    end
+    
+    def self.establish_connection(env)
+      adapter = adapters.detect { |a| a.accepts?( env ) } || return
+      adapter.new( env )
+    end
+    
+    class Base
+      
+      ADAPTER_EVENTS = [:onmessage, :onerror, :onclose]
+      
+      def self.inherited(adapter)
+        ConnectionAdapters.register_adapter( adapter )
+      end
+      
+      def initialize(env)
+        @env = env
+      end
+      
+      ADAPTER_EVENTS.each do |adapter_event|
+        define_method "#{adapter_event}" do |event=nil|
+          instance_variable_get( "@#{adapter_event}" ).call( event )
+        end
+        define_method "#{adapter_event}=" do |block=nil|
+          instance_variable_set( "@#{adapter_event}", block )
+        end
+      end
+      
+      def send(message)
+        raise NotImplementedError, "Override this method in the connection specific adapter class"
+      end
+      
+      def rack_response
+        [ -1, {}, [] ]
+      end
+      
+      def id
+        object_id.to_i
+      end
+    end
+    
+  end
+end

data/lib/websocket_rails/connection_adapters/http.rb

@@ -0,0 +1,105 @@
+module WebsocketRails
+  module ConnectionAdapters
+    class Http < Base
+      TERM = "\r\n".freeze
+      TAIL = "0#{TERM}#{TERM}".freeze
+      
+      def self.accepts?(env)
+        true
+      end
+      
+      attr_accessor :headers
+
+      def initialize(env)
+        super
+        @body = DeferrableBody.new
+        @headers = Hash.new
+        @headers['Content-Type'] = 'text/json'
+        @headers['Transfer-Encoding'] = 'chunked'
+
+        define_deferrable_callbacks
+        EM.next_tick { @env['async.callback'].call [200, @headers, @body] }
+      end
+
+      def send(message)
+        @body.chunk encode_chunk( message )
+      end
+      
+      private
+      
+      def define_deferrable_callbacks
+        @body.callback do |event|
+          onclose(event)
+        end
+        @body.errback do |event|
+          onclose(event)
+        end
+      end
+      
+      # From [Rack::Stream](https://github.com/intridea/rack-stream)
+      def encode_chunk(c)
+        return nil if c.nil?
+        # hack to work with Rack::File for now, should not TE chunked
+        # things that aren't strings or respond to bytesize
+        c = ::File.read(c.path) if c.kind_of?(Rack::File)
+        size = Rack::Utils.bytesize(c)
+        return nil if size == 0
+        c.dup.force_encoding(Encoding::BINARY) if c.respond_to?(:force_encoding)
+        puts "Chunking:: #{c}"
+        puts "Chunking:: #{size.to_s(16)}#{TERM}#{c}#{TERM}"
+        [size.to_s(16), TERM, c, TERM].join
+      end
+            
+      # From [thin_async](https://github.com/macournoyer/thin_async)
+      class DeferrableBody
+        include EM::Deferrable
+
+        # @param chunks - object that responds to each. holds initial chunks of content
+        def initialize(chunks = [])
+          @queue = []
+          chunks.each {|c| chunk(c)}
+        end
+
+        # Enqueue a chunk of content to be flushed to stream at a later time
+        def chunk(*chunks)
+          @queue += chunks
+          schedule_dequeue
+        end
+
+        # When rack attempts to iterate over `body`, save the block,
+        # and execute at a later time when `@queue` has elements
+        def each(&blk)
+          @body_callback = blk
+          schedule_dequeue
+        end
+
+        def empty?
+          @queue.empty?
+        end
+
+        def close!(flush = true)
+          EM.next_tick {
+            if !flush || empty?
+              succeed
+            else
+              schedule_dequeue
+              close!(flush)
+            end
+          }
+        end
+
+        private
+
+        def schedule_dequeue
+          return unless @body_callback
+          EM.next_tick do
+            next unless c = @queue.shift
+            @body_callback.call(c)
+            schedule_dequeue unless empty?
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/websocket_rails/connection_adapters/web_socket.rb

@@ -0,0 +1,28 @@
+module WebsocketRails
+  module ConnectionAdapters
+    class WebSocket < Base
+      
+      extend Forwardable
+      
+      def self.accepts?(env)
+        ::Faye::WebSocket.websocket?( env )
+      end
+      
+      def self.delegated_methods
+        setter_methods = ADAPTER_EVENTS.map {|e| "#{e}=".to_sym }
+        setter_methods + ADAPTER_EVENTS
+      end
+      def_delegators :@connection, *delegated_methods
+      
+      def initialize(env)
+        super
+        @connection = ::Faye::WebSocket.new( env )
+      end
+      
+      def send(message)
+        @connection.send message
+      end
+      
+    end
+  end
+end

data/lib/websocket_rails/connection_manager.rb

@@ -3,30 +3,68 @@ require 'rack'
 require 'thin'
 
 module WebsocketRails
+  class InvalidConnection < StandardError; end
   # The +ConnectionManager+ class implements the core Rack application that handles
   # incoming WebSocket connections.
   class ConnectionManager
     
     # Contains an Array of currently open Faye::WebSocket connections.
     # @return [Array]
-    attr_accessor :connections
+    attr_reader :connections
+    
+    # Contains the {Dispatcher} instance for the active server.
+    # @return [Dispatcher]
+    attr_reader :dispatcher
     
     def initialize
       @connections = []
       @dispatcher = Dispatcher.new( self )
     end
     
-    # Opens a new Faye::WebSocket connection using the Rack env Hash. New connections 
-    # dispatch the 'client_connected' event through the {Dispatcher} and are then 
-    # stored in the active {connections} Array. An Async response is returned to 
-    # signify to the web server that the connection will remain opened. Invalid 
-    # connections return an HTTP 400 Bad Request response to the client.
-    def call(env)
-      return invalid_connection_attempt unless Faye::WebSocket.websocket?( env )
-      connection = Faye::WebSocket.new( env )
+    # Primary entry point for the Rack application
+    def call(env)      
+      request = Rack::Request.new( env )
+      if request.post?
+        response = parse_incoming_event( request.params )
+      else
+        response = open_connection( env )
+      end
+      response
+    end
+    
+    # Used to broadcast a message to all connected clients. This method should never
+    # be called directly. Instead, users should use {BaseController#broadcast_message}
+    # and {BaseController#send_message} in their applications.
+    def broadcast_message(message)
+      @connections.map do |connection|
+        connection.send message
+      end
+    end
+    
+    private
+
+    def parse_incoming_event(params)
+      connection = find_connection_by_id params["client_id"]
+      data = params["data"]
+      @dispatcher.receive( data, connection )
+      [200,{'Content-Type' => 'text/plain'},['success']]
+    rescue InvalidConnection
+      [400,{'Content-Type' => 'text/plain'},['invalid connection']]
+    end
+
+    def find_connection_by_id(id)
+      connections.detect { |connection| connection.id == id.to_i } || (raise InvalidConnection)
+    end
+    
+    # Opens a persistent connection using the appropriate {ConnectionAdapter}. Stores
+    # active connections in the {connections} array.
+    def open_connection(env)
+      connection = ConnectionAdapters.establish_connection( env )
+      return invalid_connection_attempt unless connection
       
       puts "Client #{connection} connected\n"
       @dispatcher.dispatch( 'client_connected', {}, connection )
+      @dispatcher.send_message( connection.id, :connection_open, {}, connection )
       
       connection.onmessage = lambda do |event|
         @dispatcher.receive( event.data, connection )
@@ -48,21 +86,10 @@ module WebsocketRails
       connections << connection
       connection.rack_response
     end
-    
-    # Used to broadcast a message to all connected clients. This method should never
-    # be called directly. Instead, users should use {BaseController#broadcast_message}
-    # and {BaseController#send_message} in their applications.
-    def broadcast_message(message)
-      @connections.map do |connection|
-        connection.send message
-      end
-    end
-    
-    private
-    
+
     def invalid_connection_attempt
       [400,{'Content-Type' => 'text/plain'}, ['Connection was not a valid WebSocket connection']]
     end
     
   end
-end
+end

data/lib/websocket_rails/dispatcher.rb

@@ -22,12 +22,12 @@ module WebsocketRails
       dispatch( event_name, data, connection )
     end
   
-    def send_message(event_name,data,connection)
-      connection.send encoded_message( event_name, data )
+    def send_message(client_id,event_name,data,connection)
+      connection.send encoded_message( client_id, event_name, data )
     end
   
-    def broadcast_message(event_name,data)
-      @connection_manager.broadcast_message encoded_message( event_name, data )
+    def broadcast_message(client_id,event_name,data)
+      @connection_manager.broadcast_message encoded_message( client_id, event_name, data )
     end
     
     def dispatch(event_name,message,connection)
@@ -42,9 +42,9 @@ module WebsocketRails
       }.resume
     end
     
-    def encoded_message(event_name,data)
-      [event_name, data].to_json
+    def encoded_message(client_id,event_name,data)
+      [client_id, event_name, data].to_json
     end
     
   end
-end
+end

data/lib/websocket_rails/version.rb

@@ -1,3 +1,3 @@
 module WebsocketRails
-  VERSION = "0.1.1"
-end
+  VERSION = "0.1.2"
+end

data/spec/dummy/app/controllers/chat_controller.rb

@@ -26,6 +26,10 @@ class ChatController < WebsocketRails::BaseController
     # do something when a client connects
   end
   
+  def error_occurred
+    # do something when an error occurs
+  end
+    
   def new_message
     puts "Message from UID: #{client_id}\n"
     @message_counter += 1

data/spec/integration/connection_manager_spec.rb

@@ -1,38 +1,91 @@
 require 'spec_helper'
+require 'support/mock_web_socket'
 
 module WebsocketRails
-  describe ConnectionManager do
+  describe ConnectionManager, "integration test" do
     
     def define_test_events
       WebsocketRails.route_block = nil
       WebsocketRails::Events.describe_events do
         subscribe :client_connected, to: ChatController, with_method: :new_user
         subscribe :change_username, to: ChatController, with_method: :change_username
+        subscribe :client_error, to: ChatController, with_method: :error_occurred
+        subscribe :client_disconnected, to: ChatController, with_method: :delete_user
       end
     end
     
-    before(:all) { define_test_events }
-    
-    let(:env) { Hash.new }
-    let(:socket) { MockWebSocket.new }
-    
-    before(:each) do
-      Faye::WebSocket.stub(:new).and_return(MockWebSocket.new)
-      @server = ConnectionManager.new
-    end
-    
-    context "new connections" do
-      it "should execute the controller action associated with the 'client_connected' event" do
-        ChatController.any_instance.should_receive(:new_user)
-        define_test_events
-        @server.call( env )
-        #ChatController.new.send(:new_user)
+    before(:all) { 
+      define_test_events
+      if defined?(ConnectionAdapters::Test)
+        ConnectionAdapters.adapters.delete( ConnectionAdapters::Test )
+      end
+    }
+
+    shared_examples "an evented rack server" do
+      context "new connections" do
+        it "should execute the controller action associated with the 'client_connected' event" do
+          ChatController.any_instance.should_receive(:new_user)
+          @server.call( env )
+        end
       end
       
-      it "should have a ChatController present" do
-        ChatController.new.should be_present
+      context "active connections" do
+        context "new message from client" do
+          let(:test_message) { ['change_username',{user_name: 'Joe User'}] }
+          let(:encoded_message) { test_message.to_json }
+        
+          before(:each) { MockEvent = Struct.new(:data) }
+        
+          it "should execute the controller action associated with the received event" do
+            mock_event = MockEvent.new( encoded_message )
+            ChatController.any_instance.should_receive(:change_username)
+            @server.call( env )
+            socket.onmessage( mock_event )
+          end
+        end
+      
+        context "client error" do
+          it "should execute the controller action associated with the 'client_error' event" do
+            ChatController.any_instance.should_receive(:error_occurred)
+            @server.call( env )
+            socket.onerror
+          end
+        end
+        
+        context "client disconnects" do
+          it "should execute the controller action associated with the 'client_disconnected' event" do
+            ChatController.any_instance.should_receive(:delete_user)
+            @server.call( env )
+            socket.onclose
+          end
+        end
       end
     end
-    
+
+    let(:env) { Rack::MockRequest.env_for('/websocket') }
+
+    context "WebSocket Adapter" do
+      let(:socket) { MockWebSocket.new }
+      
+      before do
+        ::Faye::WebSocket.stub(:websocket?).and_return(true)
+        ::Faye::WebSocket.stub(:new).and_return(socket)
+        @server = ConnectionManager.new
+      end
+
+      it_behaves_like 'an evented rack server'
+    end
+
+    describe "HTTP Adapter" do
+      let(:socket) { ConnectionAdapters::Http.new( env ) }
+
+      before do
+        ConnectionAdapters.stub(:establish_connection).and_return(socket)
+        @server = ConnectionManager.new
+      end
+
+      it_behaves_like 'an evented rack server'
+    end
+
   end
-end
+end

data/spec/spec_helper.rb

@@ -7,7 +7,6 @@ require File.expand_path("../../spec/dummy/config/environment", __FILE__)
 require 'rspec/rails'
 require 'rspec/autorun'
 require 'thin'
-#require 'vendor/em-rspec/lib/em-rspec'
 
 $:.push File.expand_path("../../lib", __FILE__)
 require 'websocket-rails'

data/spec/support/mock_web_socket.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 module WebsocketRails
   
   class MockWebSocket

data/spec/unit/connection_adapters/http_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module WebsocketRails
+  module ConnectionAdapters
+    describe Http do
+      
+      let(:env) { Rack::MockRequest.env_for('/websocket') }
+      
+      subject { Http.new( env ) }
+      
+      it "should be a subclass of ConnectionAdapters::Base" do
+        subject.class.superclass.should == ConnectionAdapters::Base
+      end
+
+      it "should set the Content-Length header to text/json" do
+        subject.headers['Content-Type'].should == "text/json"
+      end
+
+      it "should set the Transfer-Encoding header to chunked" do
+        subject.headers['Transfer-Encoding'].should == "chunked"
+      end
+
+      context "#encode_chunk" do
+        it "should properly encode strings" do
+          subject.__send__(:encode_chunk,"test").should == "4\r\ntest\r\n"
+        end
+      end
+      
+      context "adapter methods" do
+        before do
+          @body = double('DeferrableBody').as_null_object
+          Http::DeferrableBody.stub(:new).and_return(@body)
+        end
+
+        context "#define_deferrable_callbacks" do
+          it "should define a callback for :succeeded" do
+            @body.should_receive(:callback)
+            subject
+          end
+
+          it "should define a callback for :failed" do
+            @body.should_receive(:errback)
+            subject
+          end
+        end
+
+        context "#send" do
+          it "should encode the message before sending" do
+            subject.should_receive(:encode_chunk).with('test message')
+            subject.send 'test message'
+          end
+
+          it "should enqueue the message on DeferrableBody" do
+            encoded_message = subject.__send__(:encode_chunk,'test message')
+            @body.should_receive(:chunk).with(encoded_message)
+            subject.send 'test message'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/connection_adapters/web_socket_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'support/mock_web_socket'
+
+module WebsocketRails
+  module ConnectionAdapters
+    describe WebSocket do
+      
+      before do
+        @socket = MockWebSocket.new
+        Faye::WebSocket.stub(:new).and_return(@socket)
+        @adapter = WebSocket.new( Hash.new )
+      end
+      
+      WebSocket::ADAPTER_EVENTS.each do |event|
+        it "should delegate ##{event} and ##{event}= to the Faye::WebSocket object" do
+          @socket.should_receive(event)
+          @socket.should_receive("#{event}=".to_sym)
+        
+          @adapter.__send__( "#{event}=".to_sym, Proc.new {|e| true } )
+          @adapter.__send__( event )
+        end
+      end
+      
+      context "#send" do
+        it "should send the message to the websocket connection" do
+          @socket.should_receive(:send).with(:message)
+          @adapter.send :message
+        end
+      end
+      
+    end
+  end
+end

data/spec/unit/connection_adapters_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module WebsocketRails
+  
+  class ConnectionAdapters::Test < ConnectionAdapters::Base
+    def self.accepts?(env)
+      true
+    end
+  end
+  
+  describe ConnectionAdapters do
+    
+    let(:env) { Rack::MockRequest.env_for('/websocket') }
+    
+    context ".register_adapter" do
+      it "should store a reference to the adapter in the adapters array" do
+        ConnectionAdapters.register_adapter( ConnectionAdapters::Test )
+        ConnectionAdapters.adapters.include?( ConnectionAdapters::Test ).should be_true
+      end
+    end
+    
+    context ".establish_connection" do
+      it "should return the correct connection adapter instance" do
+        adapter = ConnectionAdapters.establish_connection( env )
+        adapter.class.should == ConnectionAdapters::Test
+      end      
+    end
+    
+  end
+    
+  module ConnectionAdapters
+    describe Base do
+      
+      let(:env) { Rack::MockRequest.env_for('/websocket') }
+      
+      subject { Base.new( env ) }
+      
+      context "new adapters" do
+        it "should register themselves in the adapters array when inherited" do
+          adapter = Class.new( ConnectionAdapters::Base )
+          ConnectionAdapters.adapters.include?( adapter ).should be_true
+        end
+        
+        Base::ADAPTER_EVENTS.each do |event|
+          it "should define accessor methods for #{event}" do
+            proc = lambda { |event| true }
+            subject.__send__("#{event}=".to_sym,proc) 
+            subject.__send__(event).should == true
+          end
+        end
+      end
+      
+      context "#send" do
+        it "should raise a NotImplementedError exception" do
+          expect { subject.send :message }.to raise_exception( NotImplementedError )
+        end
+      end
+      
+    end
+  end
+end

data/spec/unit/connection_manager_spec.rb

@@ -1,22 +1,25 @@
 require 'spec_helper'
-require 'support/mock_web_socket'
 
 module WebsocketRails
   describe ConnectionManager do
-    
+    include Rack::Test::Methods
+   
+    def app
+      @app ||= ConnectionManager.new
+    end
+
     def open_connection
-      subject.call(@env)
+      subject.call(env)
     end
     
     let(:connections) { subject.connections }
+    let(:env) { Rack::MockRequest.env_for('/websocket') }
     
     before(:each) do
-      Faye::WebSocket.stub(:websocket?).and_return(true)
-      @mock_socket = MockWebSocket.new
-      Faye::WebSocket.stub(:new).and_return(@mock_socket)
+      @mock_socket = ConnectionAdapters::Base.new(env)
+      ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket)
       @dispatcher = double('dispatcher').as_null_object
       Dispatcher.stub(:new).and_return(@dispatcher)
-      @env = {}    
     end
     
     context "new connections" do
@@ -40,11 +43,23 @@ module WebsocketRails
       it "should return an Async Rack response" do
         open_connection.should == [ -1, {}, [] ]
       end
-    end    
+    end
+
+    context "new POST event" do
+      before(:each) do
+        @mock_http = ConnectionAdapters::Http.new(env)
+        app.connections << @mock_http
+      end
+      
+      it "should receive the new event for the correct connection" do
+        @dispatcher.should_receive(:receive).with('data',@mock_http)
+        post '/websocket', {:client_id => @mock_http.id, :data => 'data'}
+      end
+    end
     
     context "open connections" do
       before(:each) do
-        Faye::WebSocket.stub(:new).and_return(MockWebSocket.new,MockWebSocket.new,@mock_socket,MockWebSocket.new)
+        ConnectionAdapters.stub(:establish_connection).and_return(@mock_socket,ConnectionAdapters::Base.new(env))
         4.times { open_connection }
       end
       
@@ -100,7 +115,7 @@ module WebsocketRails
     
     context "invalid connections" do
       before(:each) do
-        Faye::WebSocket.stub(:websocket?).and_return(false)
+        ConnectionAdapters.stub(:establish_connection).and_return(false)
       end
       
       it "should return a 400 bad request error code" do
@@ -108,4 +123,4 @@ module WebsocketRails
       end
     end
   end
-end
+end

data/spec/unit/dispatcher_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'support/mock_web_socket'
 require 'json'
 
 module WebsocketRails

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: websocket-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-02 00:00:00.000000000Z
+date: 2012-06-10 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -138,13 +138,19 @@ files:
 - .travis.yml
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - MIT-LICENSE
 - README.md
 - Rakefile
+- assets/javascripts/http_dispatcher.js
+- assets/javascripts/websocket_dispatcher.js
 - bin/thin-socketrails
 - config/routes.rb
 - lib/websocket-rails.rb
 - lib/websocket_rails/base_controller.rb
+- lib/websocket_rails/connection_adapters.rb
+- lib/websocket_rails/connection_adapters/http.rb
+- lib/websocket_rails/connection_adapters/web_socket.rb
 - lib/websocket_rails/connection_manager.rb
 - lib/websocket_rails/data_store.rb
 - lib/websocket_rails/dispatcher.rb
@@ -176,7 +182,6 @@ files:
 - spec/dummy/log/development.log
 - spec/dummy/log/production.log
 - spec/dummy/log/server.log
-- spec/dummy/log/test.log
 - spec/dummy/public/404.html
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
@@ -192,6 +197,9 @@ files:
 - spec/integration/connection_manager_spec.rb
 - spec/spec_helper.rb
 - spec/support/mock_web_socket.rb
+- spec/unit/connection_adapters/http_spec.rb
+- spec/unit/connection_adapters/web_socket_spec.rb
+- spec/unit/connection_adapters_spec.rb
 - spec/unit/connection_manager_spec.rb
 - spec/unit/data_store_spec.rb
 - spec/unit/dispatcher_spec.rb
@@ -211,7 +219,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -481953751813438507
+      hash: 2040378908172396900
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -220,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -481953751813438507
+      hash: 2040378908172396900
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.19