websocket-rails 0.0.1 → 0.1.0

data/lib/websocket_rails/connection_manager.rb

@@ -1,38 +1,68 @@
+require 'faye/websocket'
 require 'rack'
-require 'rack/websocket'
-require 'json'
+require 'thin'
+
 module WebsocketRails
-  class ConnectionManager < Rack::WebSocket::Application
-    def initialize(*args)
-      @dispatcher = Dispatcher.new(self)
-      super
-    end
-  
-    def on_open(env)
-      puts "Client connected\n"
-      @dispatcher.dispatch('client_connected',{},env)
-    end
+  # The +ConnectionManager+ class implements the core Rack application that handles
+  # incoming WebSocket connections.
+  class ConnectionManager
     
-    def on_message(env, msg)
-      @dispatcher.receive( msg, env )
-    end
+    # Contains an Array of currently open Faye::WebSocket connections.
+    # @return [Array]
+    attr_accessor :connections
     
-    def on_error(env, error)
-      puts "Error occured: " + error.message
+    def initialize
+      @connections = []
+      @dispatcher = Dispatcher.new( self )
     end
     
-    def on_close(env)
-      close_connection(env['websocket.client_id'])
-      @dispatcher.dispatch('client_disconnected',{},env)
-      puts "Client disconnected\n"
+    # 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 )
+      
+      puts "Client #{connection} connected\n"
+      @dispatcher.dispatch( 'client_connected', {}, connection )
+      
+      connection.onmessage = lambda do |event|
+        @dispatcher.receive( event.data, connection )
+      end
+      
+      connection.onerror = lambda do |event|
+        @dispatcher.dispatch( 'client_error', {}, connection )
+        connection.onclose
+      end
+      
+      connection.onclose = lambda do |event|
+        @dispatcher.dispatch( 'client_disconnected', {}, connection )
+        connections.delete( connection )
+        
+        puts "Client #{connection} disconnected\n"
+        connection = nil
+      end
+      
+      connections << connection
+      connection.rack_response
     end
-  
-    def send_message(msg,uid)
-      send_data msg, uid
+    
+    # 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
-  
-    def broadcast_message(msg)
-      send_data_all msg
+    
+    private
+    
+    def invalid_connection_attempt
+      [400,{'Content-Type' => 'text/plain'}, ['Connection was not a valid WebSocket connection']]
     end
+    
   end
 end

data/lib/websocket_rails/data_store.rb

@@ -1,5 +1,39 @@
 module WebsocketRails
+  # Provides a convenient way to persist data between events on a per client basis. Since every
+  # events from every client is executed on the same instance of the controller object, instance
+  # variables defined in actions will be shared between clients. The {DataStore} provides a Hash
+  # that is private for each connected client. It is accessed through a WebsocketRails controller
+  # using the {BaseController.data_store} instance method.
+  # 
+  # = Example Usage
+  # == Creating a user
+  #   # action on ChatController called by :client_connected event
+  #   def new_user
+  #     # This would be overwritten when the next user joins
+  #     @user = User.new( message[:user_name] )
+  #     
+  #     # This will remain private for each user
+  #     data_store[:user] = User.new( message[:user_name] ) 
+  #   end
+  #
+  # == Collecting all Users from the DataStore
+  # Calling the {#each} method will yield the Hash for all connected clients:
+  #   # From your controller
+  #   all_users = []
+  #   data_store.each { |store| all_users << store[:user] }
+  # The {DataStore} also uses method_missing to provide a convenience for the above case. Calling
+  # +data_store.each_<key>+ from a controller where +<key>+ is the hash key that you wish to collect
+  # will return an Array of the values for each connected client.
+  #   # From your controller, assuming two users have already connected
+  #   data_store[:user] = UserThree
+  #   data_store.each_user
+  #   => [UserOne,UserTwo,UserThree]
   class DataStore
+    
+    extend Forwardable
+    
+    def_delegator :@base, :client_id, :cid
+    
     def initialize(base_controller)
       @base = base_controller
       @data = Hash.new {|h,k| h[k] = Hash.new}
@@ -30,10 +64,6 @@ module WebsocketRails
       @data[cid].delete(key)
     end
     
-    def cid
-      @base.client_id
-    end
-    
     def method_missing(method, *args, &block)
       if /each_(?<hash_key>\w*)/ =~ method
         results = []

data/lib/websocket_rails/dispatcher.rb

@@ -1,71 +1,50 @@
 require 'json'
 
 module WebsocketRails
-  class Dispatcher  
-    def initialize(connection)
-      puts "Initializing dispatcher\n"
-      @connection = connection
-      @events  = Hash.new {|h,k| h[k] = Array.new}
-      @classes = Hash.new
-      evaluate(&@@event_routes) if @@event_routes
+  class Dispatcher
+    
+    def self.describe_events(&block)
+      raise "This method has been deprecated. Please use WebsocketRails::Events.describe_events instead."
+    end
+    
+    attr_reader :events
+    
+    def initialize(connection_manager)
+      @connection_manager = connection_manager
+      @events = Events.new( self )
     end
   
-    def receive(enc_message,env)
+    def receive(enc_message,connection)
       message = JSON.parse( enc_message )
       event_name = message.first
       data = message.last
       data['received'] = Time.now.strftime("%I:%M:%p")
-      dispatch( event_name, data, env )
+      dispatch( event_name, data, connection )
     end
   
-    def send_message(event_name,data)
-      @connection.send_message encoded_message( event_name, data.last ), data.first
+    def send_message(event_name,data,connection)
+      connection.send encoded_message( event_name, data )
     end
   
     def broadcast_message(event_name,data)
-      @connection.broadcast_message encoded_message( event_name, data )
+      @connection_manager.broadcast_message encoded_message( event_name, data )
     end
     
-    def dispatch(event_name,data,env)
-      puts "#{event_name} is handled by #{@events[event_name.to_sym].inspect}\n\n"
-      message = [env['websocket.client_id'],data]
+    def dispatch(event_name,message,connection)
       Fiber.new {
-        @events[event_name.to_sym].each do |event|
-          handler = event.first
-          klass   = @classes[handler]
-          klass.instance_variable_set(:@_message,message)
-          method  = event.last
-          klass.send( method )
+        event_symbol = event_name.to_sym
+        events.routes_for(event_symbol) do |controller,method|
+          controller.instance_variable_set(:@_message,message)
+          controller.instance_variable_set(:@_connection,connection)
+          controller.send :execute_observers, event_symbol
+          controller.send method if controller.respond_to?(method)
         end
       }.resume
     end
-  
-    def close_connection
-      @connection.close_connection
-    end
-  
+    
     def encoded_message(event_name,data)
       [event_name, data].to_json
     end
-  
-    def subscribe(event_name,options)
-      klass = options[:to] || raise("Must specify a class for to: option in event route")
-      method = options[:with_method] || raise("Must specify a method for with_method: option in event route")
-      controller = klass.new
-      if @classes[klass].nil?
-        @classes[klass] = controller
-        controller.instance_variable_set(:@_dispatcher,self)
-        controller.send :initialize_session if controller.respond_to?(:initialize_session)
-      end
-      @events[event_name] << [klass,method]
-    end
-  
-    def self.describe_events(&block)
-      @@event_routes = block
-    end
-  
-    def evaluate(&block)
-      instance_eval &block
-    end
+    
   end
 end

data/lib/websocket_rails/events.rb

@@ -0,0 +1,53 @@
+module WebsocketRails
+  # Provides a DSL for mapping client events to controller actions. A single event can be mapped to any
+  # number of controllers and actions. You can define your event routes by creating an +events.rb+ file in
+  # your application's +initializers+ directory. The DSL currently consists of a single method, {#subscribe},
+  # which takes a symbolized event name as the first argument, and a Hash with the controller and method
+  # name as the second arguments.
+  #
+  # == Example events.rb file
+  #   # located in config/initializers/events.rb
+  #   WebsocketRails::Events.describe_events do
+  #     subscribe :client_connected, to: ChatController, with_method: :client_connected
+  #     subscribe :new_user, to: ChatController, with_method: :new_user
+  #   end
+  class Events
+    
+    def self.describe_events(&block)
+      WebsocketRails.route_block = block
+    end
+    
+    attr_reader :classes, :events
+    
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+      evaluate( WebsocketRails.route_block ) if WebsocketRails.route_block
+    end
+    
+    def routes_for(event,&block)
+      @events[event].each do |klass,method|
+        controller = @classes[klass]
+        block.call( controller, method )
+      end
+    end
+    
+    def subscribe(event_name,options)
+      klass  = options[:to] || raise("Must specify a class for to: option in event route")
+      method = options[:with_method] || raise("Must specify a method for with_method: option in event route")
+      controller = klass.new
+      if @classes[klass].nil?
+        @classes[klass] = controller
+        controller.instance_variable_set(:@_dispatcher,@dispatcher)
+        controller.send :initialize_session if controller.respond_to?(:initialize_session)
+      end
+      @events[event_name] << [klass,method]
+    end    
+    
+    def evaluate(block)
+      @events  = Hash.new {|h,k| h[k] = Array.new}
+      @classes = Hash.new
+      instance_eval &block
+    end
+    
+  end
+end

data/lib/websocket_rails/version.rb

@@ -1,3 +1,3 @@
 module WebsocketRails
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

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

@@ -0,0 +1,57 @@
+class ChatController < WebsocketRails::BaseController
+
+  observe {
+    if data_store.each_user.count > 0
+      puts 'it worked'
+    end
+    
+    if message_counter > 10
+      puts 'message counter needs to be dumped'
+      self.message_counter = 0
+    end
+  }
+  
+  observe(:new_message) {
+    puts "message observer fired for #{message}"
+  }
+  
+  attr_accessor :message_counter
+
+  def initialize_session
+    # perform application setup here
+    @message_counter = 0
+  end
+  
+  def client_connected
+    # do something when a client connects
+  end
+  
+  def new_message
+    puts "Message from UID: #{client_id}\n"
+    @message_counter += 1
+    broadcast_message :new_message, message
+  end
+  
+  def new_user
+    puts "storing user in data store\n"
+    data_store[:user] = message
+    broadcast_user_list
+  end
+  
+  def change_username
+    data_store[:user] = message
+    broadcast_user_list
+  end
+  
+  def delete_user
+    data_store.remove_client
+    broadcast_user_list
+  end
+  
+  def broadcast_user_list
+    users = data_store.each_user
+    puts "broadcasting user list: #{users}\n"
+    broadcast_message :user_list, users
+  end
+  
+end

data/{test → spec}/dummy/config/application.rb

@@ -7,7 +7,7 @@ require "action_view/railtie"
 require "action_mailer/railtie"
 
 Bundler.require
-require "websocket_rails"
+require "websocket-rails"
 
 module Dummy
   class Application < Rails::Application

data/spec/dummy/config/initializers/events.rb

@@ -0,0 +1,7 @@
+WebsocketRails::Events.describe_events do
+  subscribe :client_connected, to: ChatController, with_method: :client_connected
+  subscribe :new_message, to: ChatController, with_method: :new_message
+  subscribe :new_user, to: ChatController, with_method: :new_user
+  subscribe :change_username, to: ChatController, with_method: :change_username
+  subscribe :client_disconnected, to: ChatController, with_method: :delete_user
+end