websocket-rails 0.3.0 → 0.4.0

data/lib/websocket_rails/connection_adapters.rb

@@ -26,14 +26,15 @@ module WebsocketRails
         ConnectionAdapters.register adapter
       end
 
-      attr_reader :dispatcher, :queue, :env, :request
+      attr_reader :dispatcher, :queue, :env, :request, :data_store
 
-      def initialize(request,dispatcher)
+      def initialize(request, dispatcher)
         @env        = request.env.dup
         @request    = request
-        @queue      = EventQueue.new
         @dispatcher = dispatcher
         @connected  = true
+        @queue      = EventQueue.new
+        @data_store = DataStore::Connection.new(self)
         @delegate   = WebsocketRails::DelegationController.new
         @delegate.instance_variable_set(:@_env,request.env)
         @delegate.instance_variable_set(:@_request,request)
@@ -107,6 +108,14 @@ module WebsocketRails
         @delegate
       end
 
+      def inspect
+        "#<Connnection::#{id}>"
+      end
+
+      def to_s
+        inspect
+      end
+
       private
 
       def dispatch(event)
@@ -114,6 +123,7 @@ module WebsocketRails
       end
 
       def close_connection
+        @data_store.destroy!
         dispatcher.connection_manager.close_connection self
       end
 
@@ -123,7 +133,6 @@ module WebsocketRails
       def start_ping_timer
         @pong = true
         @ping_timer = EM::PeriodicTimer.new(10) do
-          log "ping"
           if pong == true
             self.pong = false
             ping = Event.new_on_ping self

data/lib/websocket_rails/connection_manager.rb

@@ -71,13 +71,14 @@ module WebsocketRails
     def open_connection(request)
       connection = ConnectionAdapters.establish_connection( request, dispatcher )
       connections << connection
-      log "Connection opened: #{connection}"
+      info "Connection opened: #{connection}"
       connection.rack_response
     end
 
     def close_connection(connection)
+      WebsocketRails.channel_manager.unsubscribe connection
       connections.delete connection
-      log "Connection closed: #{connection}"
+      info "Connection closed: #{connection}"
       connection = nil
     end
     public :close_connection

data/lib/websocket_rails/controller_factory.rb

@@ -0,0 +1,70 @@
+module WebsocketRails
+  class ControllerFactory
+
+    attr_reader :controller_stores, :dispatcher
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+      @controller_stores = {}
+      @initialized_controllers = {}
+    end
+
+    # TODO: Add deprecation notice for user defined
+    # instance variables.
+    def new_for_event(event, controller_class)
+      reload! controller_class
+      controller = controller_class.new
+
+      prepare(controller, event)
+
+      controller
+    end
+
+    private
+
+    def store_for_controller(controller)
+      @controller_stores[controller.class] ||= DataStore::Controller.new(controller)
+    end
+
+    def prepare(controller, event)
+      set_event(controller, event)
+      set_dispatcher(controller, dispatcher)
+      set_controller_store(controller)
+      initialize_controller(controller)
+    end
+
+    def set_event(controller, event)
+      set_ivar :@_event, controller, event
+    end
+
+    def set_dispatcher(controller, dispatcher)
+      set_ivar :@_dispatcher, controller, dispatcher
+    end
+
+    def set_controller_store(controller)
+      set_ivar :@_controller_store, controller, store_for_controller(controller)
+    end
+
+    def set_ivar(ivar, object, value)
+      object.instance_variable_set(ivar, value)
+    end
+
+    def initialize_controller(controller)
+      unless @initialized_controllers[controller.class] == true
+        controller.send(:initialize_session) if controller.respond_to?(:initialize_session)
+        @initialized_controllers[controller.class] = true
+      end
+    end
+
+    # Reloads the controller class to pick up code changes
+    # while in the development environment.
+    def reload!(controller)
+      return unless defined?(Rails) and Rails.env.development?
+
+      class_name = controller.name
+      filename = class_name.underscore
+      load "#{filename}.rb"
+    end
+
+  end
+end

data/lib/websocket_rails/data_store.rb

@@ -1,79 +1,145 @@
 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.
+  # The {DataStore} provides a convenient way to persist information between
+  # execution of events. Since every event is executed within a new instance
+  # of the controller class, instance variables set while processing an
+  # action will be lost after the action finishes executing.
   #
-  # = 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] )
+  # There are two different {DataStore} classes that you can use:
   #
-  #     # This will remain private for each user
-  #     data_store[:user] = User.new( message[:user_name] )
-  #   end
+  # The {DataStore::Connection} class is unique for every active connection.
+  # You can use it similar to the Rails session store. The connection data
+  # store can be accessed within your controller using the `#connection_store`
+  # method.
   #
-  # == 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}
-      @data = @data.with_indifferent_access
-    end
+  # The {DataStore::Controller} class is unique for every controller. You
+  # can use it similar to how you would use instance variables within a
+  # plain ruby class. The values set within the controller store will be
+  # persisted between events. The controller store can be accessed within
+  # your controller using the `#controller_store` method.
+  module DataStore
+    class Base < ActiveSupport::HashWithIndifferentAccess
 
-    def []=(k,v)
-      @data[cid] = Hash.new unless @data[cid]
-      @data[cid][k] = v
-    end
+      cattr_accessor :all_instances
+      @@all_instances = Hash.new { |h,k| h[k] = [] }
 
-    def [](k)
-      @data[cid] = Hash.new unless @data[cid]
-      @data[cid][k]
-    end
+      def self.clear_all_instances
+        @@all_instances = Hash.new { |h,k| h[k] = [] }
+      end
 
-    def each(&block)
-      @data.each do |cid,hash|
-        block.call(hash) if block
+      def initialize
+        instances << self
+      end
+
+      def instances
+        all_instances[self.class]
+      end
+
+      def collect_all(key)
+        collection = instances.each_with_object([]) do |instance, array|
+          array << instance[key]
+        end
+
+        if block_given?
+          collection.each do |item|
+            yield(item)
+          end
+        else
+          collection
+        end
+      end
+
+      def destroy!
+        instances.delete_if {|store| store.object_id == self.object_id }
       end
-    end
 
-    def remove_client
-      @data.delete(cid)
     end
 
-    def delete(key)
-      @data[cid].delete(key)
+    # The connection data store operates much like the {Controller} store. The
+    # biggest difference is that the data placed inside is private for
+    # individual users and accessible from any controller. Anything placed
+    # inside the connection data store will be deleted when a user disconnects.
+    #
+    # The connection data store is accessed through the `#connection_store`
+    # instance method inside your controller.
+    #
+    # If we were writing a basic chat system, we could use the connection data
+    # store to hold onto a user's current screen name.
+    #
+    #
+    #     class UserController < WebsocketRails::BaseController
+    #
+    #       def set_screen_name
+    #         connection_store[:screen_name] = message[:screen_name]
+    #       end
+    #
+    #     end
+    #
+    #     class ChatController < WebsocketRails::BaseController
+    #
+    #       def say_hello
+    #         screen_name = connection_store[:screen_name]
+    #         send_message :new_message, "#{screen_name} says hello"
+    #       end
+    #
+    #     end
+    class Connection < Base
+
+      attr_accessor :connection
+
+      def initialize(connection)
+        super()
+        @connection = connection
+      end
+
     end
 
-    def method_missing(method, *args, &block)
-      if /each_(?<hash_key>\w*)/ =~ method
-        results = []
-        @data.each do |cid,hash|
-          results << hash[hash_key]
-        end
-        results
-      else
-        super
+    # The Controller DataStore acts as a stand-in for instance variables in your
+    # controller. At it's core, it is a Hash which is accessible inside your
+    # controller through the `#controller_store` instance method. Any values
+    # set in the controller store will be visible by all connected users which
+    # trigger events that use that controller. However, values set in one
+    # controller will not be visible by other controllers.
+    #
+    #
+    #     class AccountController < WebsocketRails::BaseController
+    #       # We will use an Event Observer to set the initial value
+    #       observe { controller_store[:event_count] ||= 0 }
+    #
+    #       # Mapped as `accounts.important_event` in the Event Router
+    #       def important_event
+    #         # This will be private for each controller
+    #         controller_store[:event_count] += 1
+    #         trigger_success controller_store[:event_count]
+    #       end
+    #     end
+    #
+    #     class ProductController < WebsocketRails::BaseController
+    #       # We will use an Event Observer to set the initial value
+    #       observe { controller_store[:event_count] ||= 0 }
+    #
+    #       # Mapped as `products.boring_event` in the Event Router
+    #       def boring_event 
+    #         # This will be private for each controller
+    #         controller_store[:event_count] += 1
+    #         trigger_success controller_store[:event_count]
+    #       end
+    #     end
+    #
+    #     # trigger `accounts.important_event`
+    #     => 1
+    #     # trigger `accounts.important_event`
+    #     => 2
+    #     # trigger `products.boring_event`
+    #     => 1
+    class Controller < Base
+
+      attr_accessor :controller
+
+      def initialize(controller)
+        super()
+        @controller = controller
       end
+
     end
   end
 end

data/lib/websocket_rails/dispatcher.rb

@@ -1,15 +1,14 @@
-#require 'actionpack/action_dispatch/request'
-
 module WebsocketRails
   class Dispatcher
 
     include Logging
 
-    attr_reader :event_map, :connection_manager
+    attr_reader :event_map, :connection_manager, :controller_factory
 
     def initialize(connection_manager)
       @connection_manager = connection_manager
-      @event_map = EventMap.new( self )
+      @controller_factory = ControllerFactory.new(self)
+      @event_map = EventMap.new(self)
     end
 
     def receive_encoded(encoded_data,connection)
@@ -25,8 +24,6 @@ module WebsocketRails
     def dispatch(event)
       return if event.is_invalid?
 
-      log "Event received: #{event.name}"
-
       if event.is_channel?
         WebsocketRails[event.channel].trigger_event event
       else
@@ -44,23 +41,27 @@ module WebsocketRails
       end
     end
 
-    def reload_controllers!
-      @event_map.reload_controllers!
-    end
-
     private
 
     def route(event)
       actions = []
-      event_map.routes_for event do |controller, method|
+      event_map.routes_for event do |controller_class, method|
         actions << Fiber.new do
           begin
-            controller.instance_variable_set(:@_event,event)
-            controller.send(:execute_observers, event.name) if controller.respond_to?(:execute_observers)
-            result = controller.send(method) if controller.respond_to?(method)
+            log_event(event) do
+              controller = controller_factory.new_for_event(event, controller_class)
+
+              if controller.respond_to?(:execute_observers)
+                controller.send(:execute_observers, event.name)
+              end
+
+              if controller.respond_to?(method)
+                controller.send(method)
+              else
+                raise EventRoutingError.new(event, controller, method)
+              end
+            end
           rescue Exception => ex
-            puts ex.backtrace
-            puts "Application Exception: #{ex}"
             event.success = false
             event.data = extract_exception_data ex
             event.trigger

data/lib/websocket_rails/event.rb

@@ -58,14 +58,20 @@ module WebsocketRails
   # :channel =>
   # The name of the channel that this event is destined for.
   class Event
+    extend Logging
 
-    def self.new_from_json(encoded_data,connection)
-      log "Event Data: #{encoded_data}"
+    def self.log_header
+      "Event"
+    end
+
+    def self.new_from_json(encoded_data, connection)
       event_name, data = JSON.parse encoded_data
       data = data.merge(:connection => connection).with_indifferent_access
       Event.new event_name, data
     rescue JSON::ParserError => ex
       warn "Invalid Event Received: #{ex}"
+      debug "Event Data: #{encoded_data}"
+      log_exception(ex)
       Event.new_on_invalid_event_received(connection, nil)
     end
 
@@ -115,6 +121,10 @@ module WebsocketRails
       name == :invalid_event
     end
 
+    def is_internal?
+      namespace.include?(:websocket_rails)
+    end
+
     def trigger
       connection.trigger self if connection
     end

data/lib/websocket_rails/event_map.rb

@@ -20,14 +20,14 @@ module WebsocketRails
   class EventMap
 
     def self.describe(&block)
-      WebsocketRails.route_block = block
+      WebsocketRails.config.route_block = block
     end
 
     attr_reader :namespace
 
     def initialize(dispatcher)
       @dispatcher = dispatcher
-      @namespace  = DSL.new(dispatcher).evaluate WebsocketRails.route_block
+      @namespace  = DSL.new(dispatcher).evaluate WebsocketRails.config.route_block
       @namespace  = DSL.new(dispatcher,@namespace).evaluate InternalEvents.events
     end
 
@@ -99,40 +99,13 @@ module WebsocketRails
       # Stores controller/action pairs for events subscribed under
       # this namespace.
       def store(event_name,options)
-        klass, action =  TargetValidator.validate_target options
-        create_controller_instance_for klass if controllers[klass].nil?
+        klass, action = TargetValidator.validate_target options
         actions[event_name] << [klass,action]
       end
 
-
-
-      # Reloads the controller instances stored in the event map
-      # collection, picking up code changes in development.
-      def reload_controllers!
-        return unless defined?(Rails) and
-          Rails.env.development? or Rails.env.test?
-
-        controllers.each_key do |klass|
-          data_store = controllers[klass].data_store
-          class_name = klass.name
-          filename = class_name.underscore
-          load "#{filename}.rb"
-          new_class = class_name.safe_constantize
-
-          controller = new_class.new
-          controller.instance_variable_set(:@_dispatcher,@dispatcher)
-          controller.instance_variable_set(:@data_store,data_store)
-          controller.send :initialize_session if controller.respond_to?(:initialize_session)
-          controllers[klass] = controller
-        end
-        unless namespaces.empty?
-          namespaces.each_value { |ns| ns.reload_controllers! unless ns.name == :websocket_rails }
-        end
-      end
-
       # Iterates through the namespace tree and yields all
       # controller/action pairs stored for the target event.
-      def routes_for(event,event_namespace=nil,&block)
+      def routes_for(event, event_namespace=nil, &block)
 
         # Grab the first level namespace from the namespace array
         # and remove it from the copy.
@@ -149,8 +122,7 @@ module WebsocketRails
         # copy of the event's namespace array.
         if namespace == @name and event_namespace.empty?
           actions[event.name].each do |klass,action|
-            controller = controllers[klass]
-            block.call controller, action
+            block.call klass, action
           end
         else
           child_namespace = event_namespace.first
@@ -161,14 +133,7 @@ module WebsocketRails
 
       private
 
-      def create_controller_instance_for(klass)
-        controller = klass.new
-        controllers[klass] = controller
-        controller.instance_variable_set(:@_dispatcher,@dispatcher)
-        controller.send :initialize_session if controller.respond_to?(:initialize_session)
-      end
-
-      def copy_event_namespace(event,namespace=nil)
+      def copy_event_namespace(event, namespace=nil)
         namespace = event.namespace.dup if namespace.nil?
         namespace
       end