celluloid_pubsub 0.3.3 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d8a66626deefeec22f4ab76d4c1193522c0fcd6
-  data.tar.gz: c34497b740e353741c4f8d4f4ef847769edfce54
+  metadata.gz: ef1607ef65dd326efbf983675c21f745babab415
+  data.tar.gz: fbcfed23005b8d5b22232396fb5106ef13b69877
 SHA512:
-  metadata.gz: d66edfa90a6a35e17cc345bb68131b8f18636c04b7ce4f0a56bffa7a009f9cd73bed2596c08fa3a06dbd2097ad2638fb6fca16e96363d1c683fdaa16a9b5a4ce
-  data.tar.gz: a225985eb7278dda9f4c08b30bf19dd38e2d13b06488c8aa8207fcae3b29c1b49cc293fa90f9fcdda6a1f9ad28b075850ee4e9201c85afabe2376ef3a1eb9570
+  metadata.gz: 081ee9751029919561347195180494667039584a58d71bb4b2d107582b9f26af0e9b8001bb7bcdae6e86ab2d150c1c4bd4b876879ad9797d8762e130c131fbd5
+  data.tar.gz: 64492820b1123719845b670a22d58314164604319a341af2d7f24c27e015f55f3a75b1da28f4a1d2c270449f4e008b76970cf8cee17752ff5154ecfbee89cf69

data/lib/celluloid_pubsub/client.rb

@@ -7,41 +7,29 @@ module CelluloidPubsub
   # @!attribute actor
   #   @return [Celluloid::Actor] actor to which callbacks will be delegated to
   #
-  # @!attribute connect_blk
-  #   @return [Proc] Block  that will execute after the connection is opened
-  #
-  # @!attribute connection
-  #   @return [Celluloid::WebSocket::Client] A websocket connection that is used to chat witht the webserver
-  #
   # @!attribute options
   #   @return [Hash] the options that can be used to connect to webser and send additional data
   #
-  # @!attribute hostname
-  #   @return [String] The hostname on which the webserver runs on
-  #
-  # @!attribute port
-  #  @return [String] The port on which the webserver runs on
-  #
-  # @!attribute path
-  #   @return [String] The hostname on which the webserver runs on
+  # @!attribute channel
+  #   @return [String] The channel to which the client will subscribe to
   class Client
     include Celluloid
     include Celluloid::Logger
     include CelluloidPubsub::Helper
 
-    attr_reader :actor, :connection, :options, :hostname, :port, :path, :channel
+    attr_accessor :actor, :options, :channel
     finalizer :shutdown
     #  receives a list of options that are used to connect to the webserver and an actor to which the callbacks are delegated to
     #  when receiving messages from a channel
     #
     # @param  [Hash]  options the options that can be used to connect to webser and send additional data
     # @option options [String] :actor The actor that made the connection
+    # @option options [String] :channel The channel to which the client will subscribe to once the connection is open
+    # @option options [String] :log_file_path The path to the log file where debug messages will be printed, otherwise will use STDOUT
     # @option options [String]:hostname The hostname on which the webserver runs on
     # @option options [String] :port The port on which the webserver runs on
     # @option options [String] :path The request path that the webserver accepts
     #
-    # @param [Proc] connect_blk  Block  that will execute after the connection is opened
-    #
     # @return [void]
     #
     # @api public
@@ -50,11 +38,15 @@ module CelluloidPubsub
       @actor ||= @options.fetch('actor', nil)
       @channel ||= @options.fetch('channel', nil)
       raise "#{self}: Please provide an actor in the options list!!!" if @actor.blank?
-      raise "#{self}: Please provide an channel in the options list!!!" if @channel.blank?
       supervise_actors
       setup_celluloid_logger
     end
 
+    # the method will return the path to the log file where debug messages will be printed
+    #
+    # @return [String, nil] return the path to the log file where debug messages will be printed
+    #
+    # @api public
     def log_file_path
       @log_file_path ||= @options.fetch('log_file_path', nil)
     end
@@ -80,14 +72,32 @@ module CelluloidPubsub
       @connection ||= Celluloid::WebSocket::Client.new("ws://#{hostname}:#{port}#{path}", Actor.current)
     end
 
+    # the method will return the hostname of the server
+    #
+    #
+    # @return [String] the hostname where the server runs on
+    #
+    # @api public
     def hostname
       @hostname ||= @options.fetch('hostname', CelluloidPubsub::WebServer::HOST)
     end
 
+    # the method will return the port on which the server accepts connections
+    #
+    #
+    # @return [String] the port on which the server accepts connections
+    #
+    # @api public
     def port
       @port ||= @options.fetch('port', CelluloidPubsub::WebServer::PORT)
     end
 
+    # the method will return the path of the URL on which the servers acccepts the connection
+    #
+    #
+    # @return [String] the URL path that the server is mounted on
+    #
+    # @api public
     def path
       @path ||= @options.fetch('path', CelluloidPubsub::WebServer::PATH)
     end
@@ -175,11 +185,7 @@ module CelluloidPubsub
     # @api public
     def on_open
       log_debug("#{@actor.class} websocket connection opened")
-      async.subscribe(@channel)
-    end
-
-    def log_debug(message)
-      debug message if debug_enabled?
+      async.subscribe(@channel) if @channel.present?
     end
 
     # callback executes when actor receives a message from a subscribed channel

data/lib/celluloid_pubsub/helper.rb

@@ -3,9 +3,9 @@ module CelluloidPubsub
   module Helper
     # checks if the message has the successfull subscription action
     #
-    # @param [string] message
+    # @param [string] message The message that will be checked
     #
-    # @return [void]
+    # @return [Boolean] return true if message contains key client_action with value 'succesfull_subscription'
     #
     # @api public
     def succesfull_subscription?(message)
@@ -14,6 +14,21 @@ module CelluloidPubsub
 
   module_function
 
+    # method used to determine if a action is a subsribe action
+    # @param [string] action The action that will be checked
+    #
+    # @return [Boolean] Returns true if the action equals to 'subscribe'
+    #
+    # @api public
+    def action_subscribe?(action)
+      action == 'subscribe'
+    end
+
+    # sets the celluloid logger and the celluloid exception handler
+    #
+    # @return [void]
+    #
+    # @api private
     def setup_celluloid_logger
       return if !debug_enabled? || (respond_to?(:log_file_path) && log_file_path.blank?)
       setup_log_file
@@ -21,6 +36,11 @@ module CelluloidPubsub
       setup_celluloid_exception_handler
     end
 
+    # sets the celluloid exception handler
+    #
+    # @return [void]
+    #
+    # @api private
     def setup_celluloid_exception_handler
       Celluloid.task_class = Celluloid::TaskThread
       Celluloid.exception_handler do |ex|
@@ -28,6 +48,11 @@ module CelluloidPubsub
       end
     end
 
+    # creates the log file where the debug messages will be printed
+    #
+    # @return [void]
+    #
+    # @api private
     def setup_log_file
       return if !debug_enabled? || (respond_to?(:log_file_path) && log_file_path.blank?)
       FileUtils.mkdir_p(File.dirname(log_file_path)) unless File.directory?(log_file_path)
@@ -35,28 +60,39 @@ module CelluloidPubsub
       log_file.sync = true
     end
 
+    # checks if a given error needs to be filtered
+    #
+    # @param [Exception::Error] error
+    #
+    # @return [Boolean] returns true if the error should be filtered otherwise false
+    #
+    # @api private
     def filtered_error?(error)
       [Interrupt].any? { |class_name| error.is_a?(class_name) }
     end
 
-    #  receives a list of options that are used to configure the webserver
+    #  receives a list of options that need to be parsed
+    # if it is an Array will return the first element , otherwise if it is
+    # an Hash will return the hash with string keys, otherwise an empty hash
     #
-    # @param  [Hash]  options the options that can be used to connect to webser and send additional data
-    # @option options [String]:hostname The hostname on which the webserver runs on
-    # @option options [Integer] :port The port on which the webserver runs on
-    # @option options [String] :path The request path that the webserver accepts
-    # @option options [Boolean] :spy Enable this only if you want to enable debugging for the webserver
-    # @option options [Integer]:backlog How many connections the server accepts
+    # @param  [Hash, Array]  options the options that need to be parsed
     #
-    # @return [void]
+    # @return [Hash]
     #
-    # @api public
+    # @api private
     def parse_options(options)
       options = options.is_a?(Array) ? options.first : options
       options = options.is_a?(Hash) ? options.stringify_keys : {}
       options
     end
 
+    #  receives a message, and logs it to the log file if debug is enabled
+    #
+    # @param  [Object] message
+    #
+    # @return [void]
+    #
+    # @api private
     def log_debug(message)
       debug message if respond_to?(:debug_enabled?) && debug_enabled?
     end

data/lib/celluloid_pubsub/reactor.rb

@@ -36,6 +36,12 @@ module CelluloidPubsub
       async.run
     end
 
+    # the method will return true if debug is enabled
+    #
+    #
+    # @return [Boolean] returns true if debug is enabled otherwise false
+    #
+    # @api public
     def debug_enabled?
       @server.debug_enabled?
     end
@@ -71,12 +77,16 @@ module CelluloidPubsub
       nil
     end
 
+    # the method will return the reactor's class name used in debug messages
+    #
+    #
+    # @return [Class] returns the reactor's class name used in debug messages
+    #
+    # @api public
     def reactor_class
       self.class
     end
 
-    # :nocov:
-
     # method used to parse a JSON object into a Hash object
     #
     # @param [JSON] message
@@ -145,7 +155,8 @@ module CelluloidPubsub
     # @option json_data [String] :client_action The action based on which the reactor will decide what action should make
     #
     #   Possible values are:
-    #     unsubscribe_client
+    #     unsubscribe_all
+    #     unsubscribe_clients
     #     unsubscribe
     #     subscribe
     #     publish
@@ -166,7 +177,7 @@ module CelluloidPubsub
         when 'subscribe'
           async.start_subscriber(channel, json_data)
         when 'publish'
-          @server.publish_event(channel, json_data['data'].to_json)
+          async.publish_event(channel, json_data['data'].to_json)
         else
           handle_unknown_action(json_data)
       end
@@ -185,6 +196,14 @@ module CelluloidPubsub
       @server.async.handle_dispatched_message(Actor.current, json_data)
     end
 
+    # if the reactor has unsubscribed from all his channels will close the websocket connection,
+    # otherwise will delete the channel from his channel list
+    #
+    # @param [String] channel  The channel that needs to be deleted from the reactor's list of subscribed channels
+    #
+    # @return [void]
+    #
+    # @api public
     def forget_channel(channel)
       if @channels.blank?
         @websocket.close
@@ -254,6 +273,14 @@ module CelluloidPubsub
       @websocket << message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json unless @server.redis_enabled?
     end
 
+    # this method will return a list of all subscribers to a particular channel or a empty array
+    #
+    #
+    # @param [String] channel The channel that will be used to fetch all subscribers from this channel
+    #
+    # @return [Array] returns a list of all subscribers to a particular channel or a empty array
+    #
+    # @api public
     def channel_subscribers(channel)
       @server.subscribers[channel] || []
     end
@@ -274,6 +301,23 @@ module CelluloidPubsub
       @server.subscribers[channel] = channel_subscribers(channel).push(reactor: Actor.current, message: message)
     end
 
+    #  method for publishing data to a channel
+    #
+    # @param [String] current_topic The Channel to which the reactor instance {CelluloidPubsub::Reactor} will publish the message to
+    # @param [Object] message
+    #
+    # @return [void]
+    #
+    # @api public
+    def publish_event(current_topic, message)
+      return if current_topic.blank? || message.blank?
+      (@server.subscribers[current_topic] || []).each do |hash|
+        hash[:reactor].websocket << message
+      end
+    rescue => exception
+      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
+    end
+
     # unsubscribes all actors from all channels and terminates the curent actor
     #
     # @return [void]

data/lib/celluloid_pubsub/redis_reactor.rb

@@ -0,0 +1,274 @@
+require_relative './reactor'
+require_relative './helper'
+module CelluloidPubsub
+  # reactor used for redis pubsub
+  # @!attribute connected
+  #   @return [Boolean] returns true if already connected to redis
+  # @!attribute connection
+  #   @return [EM::Hiredis] The connection used for redis
+  class RedisReactor < CelluloidPubsub::Reactor
+    include Celluloid
+    include Celluloid::IO
+    include Celluloid::Logger
+    include CelluloidPubsub::Helper
+
+    attr_accessor :connected, :connection
+
+    alias_method :connected?, :connected
+
+    # returns true if already connected to redis otherwise false
+    #
+    # @return [Boolean] returns true if already connected to redis otherwise false
+    #
+    # @api public
+    def connected
+      @connected ||= false
+    end
+
+    # method used to unsubscribe from a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    # method used to subscribe to a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def add_subscriber_to_channel(channel, message)
+      super
+      async.redis_action('subscribe', channel, message)
+    end
+
+    # method used to unsubscribe from a channel
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_from_channel(channel)
+      super
+      async.redis_action('unsubscribe', channel)
+    end
+
+    # method used to unsubscribe  from all channels
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_all
+      @channels.each do |channel|
+        async.redis_action('unsubscribe', channel)
+      end
+      info 'clearing connections'
+      shutdown
+    end
+
+    # method used to shutdown the reactor and unsubscribe from all channels
+    # @see #redis_action
+    #
+    # @return [void]
+    #
+    # @api public
+    def shutdown
+      @channels.each do |channel|
+        redis_action('unsubscribe', channel)
+      end if @channels.present?
+      super
+    end
+
+    # method used to publish event using redis
+    #
+    # @return [void]
+    #
+    # @api public
+    def publish_event(topic, data)
+      return if topic.blank? || data.blank?
+      connect_to_redis do |connection|
+        connection.publish(topic, data)
+      end
+    rescue => exception
+      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
+    end
+
+  private
+
+    # method used to run the enventmachine and setup the exception handler
+    # @see #run_the_eventmachine
+    # @see #setup_em_exception_handler
+    #
+    # @param [Proc] block the block that will use the connection
+    #
+    # @return [void]
+    #
+    # @api private
+    def connect_to_redis(&block)
+      require 'eventmachine'
+      require 'em-hiredis'
+      run_the_eventmachine(&block)
+      setup_em_exception_handler
+    end
+
+    # method used to connect to redis and yield the connection
+    #
+    # @param [Proc] block the block that will use the connection
+    #
+    # @return [void]
+    #
+    # @api private
+    def run_the_eventmachine(&block)
+      EM.run do
+        @connection ||= EM::Hiredis.connect
+        @connected = true
+        block.call @connection
+      end
+    end
+
+    # method used to setup the eventmachine exception handler
+    #
+    # @return [void]
+    #
+    # @api private
+    def setup_em_exception_handler
+      EM.error_handler do |error|
+        debug error unless filtered_error?(error)
+      end
+    end
+
+    # method used to fetch the pubsub client from the connection and yield it
+    #
+    # @return [void]
+    #
+    # @api private
+    def fetch_pubsub
+      connect_to_redis do |connection|
+        @pubsub ||= connection.pubsub
+        yield @pubsub if block_given?
+      end
+    end
+
+    # method used to fetch the pubsub client from the connection and yield it
+    # @see #action_subscribe
+    #
+    # @param [string] action The action that will be checked
+    # @param [string] channel The channel that reactor has subscribed to
+    # @param [string] message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def action_success(action, channel, message)
+      action_subscribe?(action) ? message.merge('client_action' => 'successful_subscription', 'channel' => channel) : nil
+    end
+
+    # method used execute an action (subscribe or unsubscribe ) to redis
+    # @see #prepare_redis_action
+    # @see #action_success
+    # @see #register_subscription_callbacks
+    #
+    # @param [string] action The action that will be checked
+    # @param [string] channel The channel that reactor has subscribed to
+    # @param [string] message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def redis_action(action, channel = nil, message = {})
+      fetch_pubsub do |pubsub|
+        callback = prepare_redis_action(action)
+        success_message = action_success(action, channel, message)
+        subscription = pubsub.send(action, channel, callback)
+        register_subscription_callbacks(subscription, action, success_message)
+      end
+    end
+
+    # method used check if the action is subscribe and write the incoming message to be websocket or log the message otherwise
+    # @see #log_unsubscriptions
+    # @see #action_subscribe
+    #
+    # @param [String] action The action that will be checked if it is subscribed
+    #
+    # @return [void]
+    #
+    # @api private
+    def prepare_redis_action(action)
+      log_unsubscriptions(pubsub)
+      proc do |subscribed_message|
+        action_subscribe?(action) ? (@websocket << subscribed_message) : log_debug(message)
+      end
+    end
+
+    # method used to listen to unsubscriptions and log them to log file
+    # @see #register_redis_callback
+    # @see #register_redis_error_callback
+    #
+    # @param [EM::Hiredis::PubsubClient] pubsub The pubsub client that will be used to listen to unsubscriptions
+    #
+    # @return [void]
+    #
+    # @api private
+    def log_unsubscriptions(pubsub)
+      pubsub.on(:unsubscribe) do |subscribed_channel, remaining_subscriptions|
+        log_debug [:unsubscribe_happened, subscribed_channel, remaining_subscriptions].inspect
+      end
+    end
+
+    # method used registers the sucess and error callabacks
+    # @see #register_redis_callback
+    # @see #register_redis_error_callback
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] action The action that will be checked
+    # @param [string] sucess_message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_subscription_callbacks(subscription, action, sucess_message = nil)
+      register_redis_callback(subscription, sucess_message)
+      register_redis_error_callback(subscription, action)
+    end
+
+    # method used to register a success callback  and if action is subscribe will write
+    # back to the websocket a message that will say it is a successful_subscription
+    # If action is something else, will log the incoming message
+    # @see #log_debug
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] sucess_message The initial message used to subscribe
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_redis_callback(subscription, sucess_message = nil)
+      subscription.callback do |subscriptions_ids|
+        if sucess_message.present?
+          @websocket << sucess_message.merge('subscriptions' => subscriptions_ids).to_json
+        else
+          log_debug "#{action} success #{success_response.inspect}"
+        end
+      end
+    end
+
+    # Register an error callback on the deferrable object and logs to file the incoming message
+    # @see #log_debug
+    #
+    # @param [EM::DefaultDeferrable] subscription The subscription object
+    # @param [string] action The action that will be checked
+    #
+    # @return [void]
+    #
+    # @api private
+    def register_redis_error_callback(subscription, action)
+      subscription.errback { |reply| log_debug "#{action} error #{reply.inspect}" }
+    end
+  end
+end

data/lib/celluloid_pubsub/version.rb

@@ -15,9 +15,9 @@ module CelluloidPubsub
     # major release version
     MAJOR = 0
     # minor release version
-    MINOR = 3
+    MINOR = 4
     # tiny release version
-    TINY = 3
+    TINY = 1
     # prelease version ( set this only if it is a prelease)
     PRE = nil
 

data/lib/celluloid_pubsub/web_server.rb

@@ -13,22 +13,6 @@ module CelluloidPubsub
   #
   # @!attribute subscribers
   #   @return [Hash] The hostname on which the webserver runs on
-  #
-  # @!attribute backlog
-  #   @return [Integer] Determines how many connections can be used
-  #   Defaults to 1024
-  #
-  # @!attribute hostname
-  #   @return [String] The hostname on which the webserver runs on
-  #
-  # @!attribute port
-  #  @return [String] The port on which the webserver runs on
-  #
-  # @!attribute path
-  #   @return [String] The hostname on which the webserver runs on
-  #
-  # @!attribute spy
-  #   @return [Boolean] Enable this only if you want to enable debugging for the webserver
   class WebServer < Reel::Server::HTTP
     include Celluloid::Logger
     include CelluloidPubsub::Helper
@@ -40,7 +24,7 @@ module CelluloidPubsub
     # The request path that the webserver accepts by default
     PATH = '/ws'
 
-    attr_accessor :options, :subscribers, :backlog, :hostname, :port, :path, :spy, :use_redis, :debug_enabled
+    attr_accessor :options, :subscribers
     finalizer :shutdown
     #  receives a list of options that are used to configure the webserver
     #
@@ -64,10 +48,22 @@ module CelluloidPubsub
       super(hostname, port, { spy: spy, backlog: backlog }, &method(:on_connection))
     end
 
+    # the method will  return true if redis can be used otherwise false
+    #
+    #
+    # @return [Boolean]  return true if redis can be used otherwise false
+    #
+    # @api public
     def use_redis
       @use_redis ||= @options.fetch('use_redis', false)
     end
 
+    # the method will return true if debug is enabled otherwise false
+    #
+    #
+    # @return [Boolean] returns true if debug is enabled otherwise false
+    #
+    # @api public
     def debug_enabled?
       @debug_enabled = @options.fetch('enable_debug', false)
       @debug_enabled == true
@@ -84,66 +80,74 @@ module CelluloidPubsub
       terminate
     end
 
+    # the method will return the file path of the log file where debug messages will be printed
+    #
+    #
+    # @return [String] returns the file path of the log file where debug messages will be printed
+    #
+    # @api public
     def log_file_path
       @log_file_path ||= @options.fetch('log_file_path', nil)
     end
 
+    # the method will return the hostname on which the server is running on
+    #
+    #
+    # @return [String] returns the hostname on which the server is running on
+    #
+    # @api public
     def hostname
       @hostname ||= @options.fetch('hostname', CelluloidPubsub::WebServer::HOST)
     end
 
+    # the method will return the port on which will accept connections
+    #
+    #
+    # @return [String] returns the port on which will accept connections
+    #
+    # @api public
     def port
       @port ||= @options.fetch('port', CelluloidPubsub::WebServer::PORT)
     end
 
+    # the method will return the URL path on which will acceept connections
+    #
+    #
+    # @return [String] returns the URL path on which will acceept connections
+    #
+    # @api public
     def path
       @path ||= @options.fetch('path', CelluloidPubsub::WebServer::PATH)
     end
 
+    # the method will return true if connection to the server should be spied upon
+    #
+    #
+    # @return [Boolean] returns true if connection to the server should be spied upon, otherwise false
+    #
+    # @api public
     def spy
       @spy ||= @options.fetch('spy', false)
     end
 
+    # the method will return the number of connections allowed to the server
+    #
+    #
+    # @return [Integer] returns the number of connections allowed to the server
+    #
+    # @api public
     def backlog
       @backlog = @options.fetch('backlog', 1024)
     end
 
-    # :nocov:
-
-    def redis_enabled?
-      use_redis.to_s.downcase == 'true'
-    end
-
-    #  method for publishing data to a channel
+    # the method will return true if redis is enabled otherwise false
     #
-    # @param [String] current_topic The Channel to which the reactor instance {CelluloidPubsub::Rector} will publish the message to
-    # @param [Object] message
     #
-    # @return [void]
+    # @return [Boolean] returns true if redis is enabled otherwise false
     #
     # @api public
-    def publish_event(current_topic, message)
-      if redis_enabled?
-        publish_redis_event(current_topic, message)
-      else
-        publish_clasic_event(current_topic, message)
-      end
-    rescue => exception
-      log_debug("could not publish message #{message} into topic #{current_topic} because of #{exception.inspect}")
-    end
-
-    def publish_redis_event(topic, data)
-      return if !redis_enabled? || topic.blank? || data.blank?
-      CelluloidPubsub::Redis.connect do |connection|
-        connection.publish(topic, data)
-      end
-    end
-
-    def publish_clasic_event(channel, data)
-      return if channel.blank? || data.blank?
-      (@subscribers[channel] || []).each do |hash|
-        hash[:reactor].websocket << data
-      end
+    def redis_enabled?
+      use_redis.to_s.downcase == 'true'
     end
 
     #  callback that will execute when receiving new conections
@@ -180,10 +184,24 @@ module CelluloidPubsub
       end
     end
 
+    #  returns the reactor class that will handle the connection depending if redis is enabled or not
+    # @see #redis_enabled?
+    #
+    # @return [Class]  returns the reactor class that will handle the connection depending if redis is enabled or not
+    #
+    # @api public
     def reactor_class
       redis_enabled? ? CelluloidPubsub::RedisReactor : CelluloidPubsub::Reactor
     end
 
+    # method will instantiate a new reactor object, will link the reactor to the current actor and will dispatch the request to the reactor
+    # @see #route_websocket
+    #
+    # @param [Reel::WebSocket] request The request that was made to the webserver
+    #
+    # @return [void]
+    #
+    # @api public
     def dispatch_websocket_request(request)
       reactor = reactor_class.new
       Actor.current.link reactor

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -110,7 +110,7 @@ describe CelluloidPubsub::Reactor do
 
     it 'publish' do
       data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
-      server.expects(:publish_event).with(data['channel'], data['data'].to_json)
+      subject.expects(:publish_event).with(data['channel'], data['data'].to_json)
       subject.delegate_action(data)
     end
 
@@ -196,7 +196,7 @@ describe CelluloidPubsub::Reactor do
   describe '#add_subscriber_to_channel' do
     let(:channel) { 'some channel' }
     let(:message) { { a: 'b' } }
-    let(:subscribers) {mock}
+    let(:subscribers) { mock }
 
     it 'adds subscribed' do
       CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid_pubsub
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.1
 platform: ruby
 authors:
 - bogdanRada
@@ -419,8 +419,7 @@ files:
 - lib/celluloid_pubsub/client.rb
 - lib/celluloid_pubsub/helper.rb
 - lib/celluloid_pubsub/reactor.rb
-- lib/celluloid_pubsub/redis/redis.rb
-- lib/celluloid_pubsub/redis/redis_reactor.rb
+- lib/celluloid_pubsub/redis_reactor.rb
 - lib/celluloid_pubsub/registry.rb
 - lib/celluloid_pubsub/version.rb
 - lib/celluloid_pubsub/web_server.rb

data/lib/celluloid_pubsub/redis/redis.rb

@@ -1,38 +0,0 @@
-require_relative '../helper'
-module CelluloidPubsub
-  # class that handles redis connection
-  class Redis
-    class << self
-      include Celluloid::Logger
-      include CelluloidPubsub::Helper
-
-      @connected ||= false
-      attr_accessor :connected, :connection
-
-      alias_method :connected?, :connected
-
-      def connect(&block)
-        require 'eventmachine'
-        require 'em-hiredis'
-        run_the_eventmachine(&block)
-        setup_em_exception_handler
-      end
-
-    private
-
-      def run_the_eventmachine(&block)
-        EM.run do
-          @connection ||= EM::Hiredis.connect
-          @connected = true
-          block.call @connection
-        end
-      end
-
-      def setup_em_exception_handler
-        EM.error_handler do |error|
-          debug error unless filtered_error?(error)
-        end
-      end
-    end
-  end
-end

data/lib/celluloid_pubsub/redis/redis_reactor.rb

@@ -1,96 +0,0 @@
-require_relative '../reactor'
-module CelluloidPubsub
-  # reactor used for redis pubsub
-  class RedisReactor < CelluloidPubsub::Reactor
-    include Celluloid
-    include Celluloid::IO
-    include Celluloid::Logger
-
-    def unsubscribe(channel)
-      super
-      async.redis_action('unsubscribe', channel)
-    end
-
-    def add_subscriber_to_channel(channel, message)
-      super
-      async.redis_action('subscribe', channel, message)
-    end
-
-    def unsubscribe_from_channel(channel)
-      super
-      async.redis_action('unsubscribe', channel)
-    end
-
-    def unsubscribe_all
-      CelluloidPubsub::Registry.channels.map do |channel|
-        async.redis_action('unsubscribe', channel)
-      end
-      info 'clearing connections'
-      shutdown
-    end
-
-    def shutdown
-      @channels.each do |channel|
-        redis_action('unsubscribe', channel)
-      end if @channels.present?
-      super
-    end
-
-  private
-
-    def fetch_pubsub
-      CelluloidPubsub::Redis.connect do |connection|
-        yield connection.pubsub
-      end
-    end
-
-    def action_subscribe?(action)
-      action == 'subscribe'
-    end
-
-    def action_success(action, channel, message)
-      action_subscribe?(action) ? message.merge('client_action' => 'successful_subscription', 'channel' => channel) : nil
-    end
-
-    def redis_action(action, channel = nil, message = {})
-      fetch_pubsub do |pubsub|
-        callback = prepare_redis_action(action)
-        success_message = action_success(action, channel, message)
-        subscription = pubsub.send(action, channel, callback)
-        handle_redis_action(subscription, action, success_message)
-      end
-    end
-
-    def prepare_redis_action(action)
-      log_unsubscriptions(pubsub)
-      proc do |subscribed_message|
-        action_subscribe?(action) ? (@websocket << subscribed_message) : log_debug(message)
-      end
-    end
-
-    def log_unsubscriptions(pubsub)
-      pubsub.on(:unsubscribe) do |subscribed_channel, remaining_subscriptions|
-        log_debug [:unsubscribe_happened, subscribed_channel, remaining_subscriptions].inspect
-      end
-    end
-
-    def handle_redis_action(subscription, action, sucess_message = nil)
-      register_redis_callback(subscription, sucess_message)
-      register_redis_error_callback(subscription, action)
-    end
-
-    def register_redis_callback(subscription, sucess_message = nil)
-      subscription.callback do |subscriptions_ids|
-        if sucess_message.present?
-          @websocket << sucess_message.merge('subscriptions' => subscriptions_ids).to_json
-        else
-          log_debug "#{action} success #{success_response.inspect}"
-        end
-      end
-    end
-
-    def register_redis_error_callback(subscription, action)
-      subscription.errback { |reply| log_debug "#{action} error #{reply.inspect}" }
-    end
-  end
-end