websocket-rails 0.1.5 → 0.1.6

data/lib/websocket_rails/event.rb

@@ -1,53 +1,112 @@
-require 'json'
-
 module WebsocketRails
-  class Event
 
-    def self.new_from_json(encoded_data,connection)
-      event_name, data, namespace, channel = decode encoded_data
-      Event.new event_name, data, 
-        :connection => connection,
-        :namespace => namespace,
-        :channel => channel
+  module StaticEvents
+
+    def new_on_open(connection,data=nil)
+      connection_id = {
+        :connection_id => connection.id
+      }
+      data = data.is_a?(Hash) ? data.merge( connection_id ) : connection_id
+      Event.new :client_connected, :data => data, :connection => connection
     end
 
-    def self.new_on_open(connection,data=nil)
-      connection_id = { :connection_id => connection.id }
-      on_open_data  = data.is_a?(Hash) ? data.merge(connection_id) : connection_id
+    def new_on_close(connection,data=nil)
+      Event.new :client_disconnected, :data => data, :connection => connection
+    end
 
-      Event.new :client_connected, on_open_data, :connection => connection
+    def new_on_error(connection,data=nil)
+      Event.new :client_error, :data => data, :connection => connection
     end
 
-    def self.new_on_close(connection,data=nil)
-      Event.new :client_disconnected, data, :connection => connection
+    def new_on_ping(connection)
+      Event.new :ping, :data => {}, :connection => connection, :namespace => :websocket_rails
     end
 
-    def self.new_on_error(connection,data=nil)
-      Event.new :client_error, data, :connection => connection
+  end
+
+  # Contains all of the relevant information for incoming and outgoing events.
+  # All events except for channel events will have a connection object associated.
+  #
+  # Events require an event name and hash of options:
+  #
+  # :data =>
+  # The data object will be passed to any callback functions bound on the
+  # client side.
+  #
+  # You can also pass a Hash of options to specify:
+  #
+  # :connection =>
+  # Connection that will be receiving or that sent this event.
+  #
+  # :namespace =>
+  # The namespace this event is under. Will default to :global
+  # If the namespace is nested under multiple levels pass them as an array.
+  # For instance, if the namespace route looks like the following:
+  #
+  #   namespace :products do
+  #     namespace :hats do
+  #       # events
+  #     end
+  #   end
+  #
+  # Then you would pass the namespace argument as [:products,:hats]
+  #
+  # :channel =>
+  # The name of the channel that this event is destined for.
+  class Event
+
+    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}"
     end
 
-    attr_reader :name, :data, :connection, :namespace, :channel
+    include Logging
+    extend StaticEvents
+
+    attr_reader :id, :name, :connection, :namespace, :channel
 
-    def initialize(event_name,data,options={})
-      @name       = event_name.to_sym
-      @data       = data.is_a?(Hash) ? data.with_indifferent_access : data
-      @channel    = options[:channel]
+    attr_accessor :data, :result, :success
+
+    def initialize(event_name,options={})
+      case event_name
+      when String
+        namespace = event_name.split('.')
+        @name     = namespace.pop.to_sym
+      when Symbol
+        @name     = event_name
+        namespace = [:global]
+      end
+      @id         = options[:id]
+      @data       = options[:data].is_a?(Hash) ? options[:data].with_indifferent_access : options[:data]
+      @channel    = options[:channel].to_sym if options[:channel]
       @connection = options[:connection]
-      @namespace  = validate_namespace options[:namespace]
+      @namespace  = validate_namespace( options[:namespace] || namespace )
     end
 
     def serialize
-      if is_channel?
-        [channel, encoded_name, data].to_json
-      else
-        [encoded_name, data].to_json
-      end
+      [
+        encoded_name,
+        {
+          :id => id,
+          :channel => channel,
+          :data => data,
+          :success => success,
+          :result => result
+        }
+      ].to_json
     end
 
     def is_channel?
       !@channel.nil?
     end
 
+    def trigger
+      connection.trigger self if connection
+    end
+
     private
 
     def validate_namespace(namespace)
@@ -67,19 +126,5 @@ module WebsocketRails
       combined_name
     end
 
-    def self.decode(encoded_data)
-      message = JSON.parse( encoded_data )
-
-      channel_name = message.shift if message.size == 3
-      event_name   = message[0]
-      data         = message[1]
-
-      namespace  = event_name.split('.')
-      event_name = namespace.pop
-
-      data['received'] = Time.now if data.is_a?(Hash)
-      [event_name, data, namespace, channel_name]
-    end
-
   end
 end

data/lib/websocket_rails/event_map.rb

@@ -1,26 +1,21 @@
 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 two methods. The first is
-  # {#subscribe}, which takes a symbolized event name as the first argument, and a Hash with the controller 
-  # and method name as the second argument. The second is {#namespace} which allows you to scope your
-  # actions within particular namespaces. The {#namespace} method takes a symbol representing the name
-  # of the namespace, and a block which contains the actions you wish to subscribe within that namespace.
-  # When an event is dispatched to the client, the namespace will be attached to the front of the event
-  # name separated by a period. The `new` event listed in the example below under the `product` namespace
-  # would arrive on the client as `product.new`. Similarly, incoming events in the `namespace.event_name`
-  # format will be properly dispatched to the `event_name` under the correct `namespace`. Namespaces can
-  # be nested.
+  # Provides a DSL for mapping client events to controller actions.
   #
   # == Example events.rb file
   #   # located in config/initializers/events.rb
   #   WebsocketRails::EventMap.describe do
   #     subscribe :client_connected, to: ChatController, with_method: :client_connected
-  #     subscribe :new_user, :to => ChatController, :with_method => :new_user
+  #   end
+  #
+  # A single event can be mapped to any number of controller actions.
+  #
+  #   subscribe :new_message, :to => ChatController, :with_method => :rebroadcast_message
+  #   subscribe :new_message, :to => LogController, :with_method => :log_message
   #
-  #     namespace :product do
-  #       subscribe :new, :to => ProductController, :with_method => :new
-  #     end
+  # Events can be nested underneath namesapces.
+  #
+  #   namespace :product do
+  #     subscribe :new, :to => ProductController, :with_method => :new
   #   end
   class EventMap
     
@@ -39,6 +34,11 @@ module WebsocketRails
     def routes_for(event, &block)
       @namespace.routes_for event, &block
     end
+
+    # Proxy the reload_controllers! method to the global namespace.
+    def reload_controllers!
+      @namespace.reload_controllers!
+    end
     
     # Provides the DSL methods available to the Event routes file
     class DSL
@@ -66,11 +66,17 @@ module WebsocketRails
         @namespace = @namespace.parent
       end
 
+      def private_channel(channel)
+        WebsocketRails[channel].make_private
+      end
+
     end
 
     # Stores route map for nested namespaces 
     class Namespace
-      
+
+      include Logging
+
       attr_reader :name, :controllers, :actions, :namespaces, :parent
 
       def initialize(name,dispatcher,parent=nil)
@@ -90,6 +96,8 @@ module WebsocketRails
         child
       end
 
+      # Stores controller/action pairs for events subscribed under
+      # this namespace.
       def store(event_name,options)
         klass  = options[:to] || raise("Must specify a class for to: option in event route")
         action = options[:with_method] || raise("Must specify a method for with_method: option in event route")
@@ -97,10 +105,47 @@ module WebsocketRails
         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)
-        event_namespace = event.namespace.dup if event_namespace.nil?
-        return if event_namespace.nil?
-        namespace = event_namespace.shift
+
+        # Grab the first level namespace from the namespace array
+        # and remove it from the copy.
+        event_namespace = copy_event_namespace( event, event_namespace ) || return
+        namespace       = event_namespace.shift
+
+        # If the namespace matches the current namespace and we are
+        # at the last namespace level, yield any controller/action
+        # pairs for this event.
+        #
+        # If the namespace does not match, search the list of child
+        # namespaces stored at this level for a match and delegate
+        # to it's #routes_for method, passing along the current
+        # copy of the event's namespace array.
         if namespace == @name and event_namespace.empty?
           actions[event.name].each do |klass,action|
             controller = controllers[klass]
@@ -121,6 +166,11 @@ module WebsocketRails
         controller.instance_variable_set(:@_dispatcher,@dispatcher)
         controller.send :initialize_session if controller.respond_to?(:initialize_session)
       end
+
+      def copy_event_namespace(event,namespace=nil)
+        namespace = event.namespace.dup if namespace.nil?
+        namespace
+      end
       
     end
     

data/lib/websocket_rails/event_queue.rb

@@ -16,6 +16,10 @@ module WebsocketRails
       @queue.last
     end
 
+    def size
+      @queue.size
+    end
+
     def flush(&block)
       unless block.nil?
         @queue.each do |item|

data/lib/websocket_rails/internal_events.rb

@@ -3,6 +3,8 @@ module WebsocketRails
     def self.events
       Proc.new do
         namespace :websocket_rails do
+          subscribe :pong, :to => InternalController, :with_method => :do_pong
+          subscribe :reload!, :to => InternalController, :with_method => :reload_controllers!
           subscribe :subscribe, :to => InternalController, :with_method => :subscribe_to_channel
         end
       end
@@ -10,10 +12,26 @@ module WebsocketRails
   end
 
   class InternalController < BaseController
+    include Logging
+
     def subscribe_to_channel
-      puts "subscribed to: #{data[:channel]}"
-      channel_name = data[:channel]
-      WebsocketRails[channel_name].subscribe connection
+      channel_name = event.data[:channel]
+      unless WebsocketRails[channel_name].is_private?
+        WebsocketRails[channel_name].subscribe connection
+        trigger_success
+      else
+        trigger_failure( { :reason => "channel is private", :hint => "use subscibe_private instead." } )
+      end
+    end
+
+    def reload_controllers!
+      return unless defined?(Rails) and Rails.env.development? || Rails.env.test?
+      log 'reloading controllers'
+      @_dispatcher.reload_controllers!
+    end
+
+    def do_pong
+      connection.pong = true
     end
   end
 end

data/lib/websocket_rails/logging.rb

@@ -0,0 +1,18 @@
+module WebsocketRails
+  # Need to replace this module with a real logger
+  module Logging
+    
+    def log(msg)
+      puts msg if debug?
+    end
+
+    def warn(msg)
+      puts msg
+    end
+
+    def debug?
+      LOG_LEVEL == :debug
+    end
+
+  end
+end

data/lib/websocket_rails/version.rb

@@ -1,3 +1,3 @@
 module WebsocketRails
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end