wwl-websocket-rails 0.7.1

data/lib/spec_helpers/matchers/route_matchers.rb

@@ -0,0 +1,65 @@
+module WebsocketRails
+
+  module SpecHelpers
+
+      def self.verify_route(event, target, non_exclusive)
+
+        raise ArgumentError, 'event must be of type SpecHelperEvent' unless event.is_a? WebsocketRails::SpecHelperEvent
+        target_class, target_method = WebsocketRails::TargetValidator.validate_target target
+
+        result = false
+        no_of_routes = 0
+        event.dispatcher.event_map.routes_for event do |controller_class, method|
+          no_of_routes += 1
+          controller = controller_class.new
+          if controller.class == target_class and method == target_method
+            result = true
+          end
+        end
+        result and (non_exclusive or no_of_routes == 1)
+      end
+
+  end
+
+end
+
+
+RSpec::Matchers.define :be_routed_to do |target|
+
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_route event, target, true
+  end
+
+  failure_message_for_should do |event|
+    "expected event #{event.name} to be routed to target #{target}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected event #{event.name} not to be routed to target #{target}"
+  end
+
+  description do
+    "be routed to target #{target}"
+  end
+
+end
+
+RSpec::Matchers.define :be_routed_only_to do |target|
+
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_route event, target, false
+  end
+
+  failure_message_for_should do |event|
+    "expected event #{event.name} to be routed only to target #{target}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected event #{event.name} not to be routed only to target #{target}"
+  end
+
+  description do
+    "be routed only to target #{target}"
+  end
+
+end

data/lib/spec_helpers/matchers/trigger_matchers.rb

@@ -0,0 +1,138 @@
+module WebsocketRails
+
+  module SpecHelpers
+
+    def self.compare_trigger_data(event, data)
+      return true if data.nil?
+      return true if data == :any and event.data
+      return true if data == :nil and event.data.nil?
+      data.eql? event.data
+    end
+
+    def self.expected_data_for_spec_message(data)
+      case data
+        when nil
+          ''
+        when :nil
+          ' with no data'
+        when :any
+          ' with some data'
+        else
+          " with data #{data}"
+      end
+    end
+
+    def self.actual_data_for_spec_message(data)
+      data ? "with data #{data}": 'with no data'
+    end
+
+    def self.actual_for_spec_message(event)
+      if event.triggered?
+        success = event.success
+        if success.nil?
+          "triggered message #{actual_data_for_spec_message(event.data)}"
+        else
+          success_state = 
+          case success
+          when 0 then "a success"
+          when 1 then "a failure"
+          when 2 then "a no result"
+          else success
+          end
+          "triggered #{success_state} message #{actual_data_for_spec_message(event.data)}"
+        end
+      else
+        'did not trigger any message'
+      end
+    end
+
+    def self.verify_trigger(event, data, success=nil)
+      return false unless event.triggered?
+      return false unless compare_trigger_data(event, data)
+      success.nil? || success == event.success
+    end
+
+  end
+
+end
+
+
+RSpec::Matchers.define :trigger_message do |data|
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_trigger event, data
+  end
+
+  failure_message_for_should do |event|
+    "expected #{event.encoded_name} to trigger message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}, " +
+        "instead it #{WebsocketRails::SpecHelpers.actual_for_spec_message event}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected #{event.encoded_name} not to trigger message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+
+  description do
+    "trigger message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+end
+
+RSpec::Matchers.define :trigger_success_message do |data|
+
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_trigger event, data, 0
+  end
+
+  failure_message_for_should do |event|
+    "expected #{event.encoded_name} to trigger success message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}, "+
+        "instead it #{WebsocketRails::SpecHelpers.actual_for_spec_message event}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected #{event.encoded_name} not to trigger success message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+
+  description do
+    "trigger success message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+
+end
+
+RSpec::Matchers.define :trigger_failure_message do |data|
+
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_trigger event, data, 1
+  end
+
+  failure_message_for_should do |event|
+    "expected #{event.encoded_name} to trigger failure message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}, " +
+        "instead it #{WebsocketRails::SpecHelpers.actual_for_spec_message event}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected #{event.encoded_name} not to trigger failure message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+
+  description do
+    "trigger failure message#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+
+end
+
+Rspec::Matchers.define :trigger_no_result_message do |data|
+  match do |event|
+    WebsocketRails::SpecHelpers.verify_trigger event, data, 2
+  end
+
+  failure_message_for_should do |event|
+    "expected #{event.encoded_name} to trigger no result message (success == 2)#{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}, "+
+      "instead it #{WebsocketRails::SpecHelpers.actual_for_spec_message event}"
+  end
+
+  failure_message_for_should_not do |event|
+    "expected #{event.encoded_name} not to trigger no result message (success == 2)"
+  end
+
+  description do 
+    "trigger no result message #{WebsocketRails::SpecHelpers.expected_data_for_spec_message data}"
+  end
+end

data/lib/spec_helpers/spec_helper_event.rb

@@ -0,0 +1,34 @@
+module WebsocketRails
+
+  class SpecHelperEvent < Event
+
+    attr_reader :dispatcher, :triggered
+
+    alias :triggered? :triggered
+
+    def initialize(event_name,options={})
+      super(event_name, options)
+      @triggered = false
+      @dispatcher =  Dispatcher.new(nil)
+    end
+
+    def trigger
+      @triggered = true
+    end
+
+    def dispatch
+      @dispatcher.dispatch(self)
+      self
+    end
+
+    def connection
+      OpenStruct.new(:id => 1)
+    end
+
+  end
+
+end
+
+def create_event(name, data)
+  WebsocketRails::SpecHelperEvent.new(name, {data: data})
+end

data/lib/websocket-rails.rb

@@ -0,0 +1,108 @@
+require "active_support/dependencies"
+require "logger"
+require "thin"
+
+module WebsocketRails
+
+  class << self
+    def setup
+      yield config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def synchronize?
+      config.synchronize == true || config.standalone == true
+    end
+
+    def standalone?
+      config.standalone == true
+    end
+
+    def logger
+      config.logger
+    end
+  end
+
+end
+
+require 'websocket_rails/engine'
+
+require 'websocket_rails/configuration'
+require 'websocket_rails/logging'
+require 'websocket_rails/synchronization'
+require 'websocket_rails/connection_manager'
+require 'websocket_rails/dispatcher'
+require 'websocket_rails/controller_factory'
+require 'websocket_rails/event'
+require 'websocket_rails/event_map'
+require 'websocket_rails/event_queue'
+require 'websocket_rails/channel'
+require 'websocket_rails/channel_manager'
+require 'websocket_rails/user_manager'
+require 'websocket_rails/base_controller'
+require 'websocket_rails/internal_events'
+
+require 'websocket_rails/connection_adapters'
+require 'websocket_rails/connection_adapters/http'
+require 'websocket_rails/connection_adapters/web_socket'
+
+# Exceptions
+class WebsocketRails::InvalidConnectionError < StandardError
+  def rack_response
+    [400,{'Content-Type' => 'text/plain'},['invalid connection']]
+  end
+end
+
+class WebsocketRails::EventRoutingError < StandardError
+
+  attr_reader :event, :controller, :method
+
+  def initialize(event, controller, method)
+    @event = event
+    @controller = controller
+  end
+
+  def to_s
+    out =  "Routing Error:\n"
+    out << "Event: #{event.name}\n"
+    out << "Controller #{controller.class} does not respond to #{method}"
+    out
+  end
+
+  def to_json
+    super({
+      :error => "EventRoutingError",
+      :event => event.name,
+      :method => method,
+      :reason => "Controller #{controller.class} does not respond to #{method}"
+    })
+  end
+
+end
+
+class WebsocketRails::ConfigDeprecationError < StandardError
+  def to_s
+    out = "Deprecation Error:\n\n\t"
+    out << "config/initializers/events.rb has been moved to config/events.rb\n\t"
+    out << "Make sure events.rb is in the proper location and the old one has been removed.\n\t"
+    out << "More information can be found in the wiki.\n\n"
+  end
+end
+
+raise WebsocketRails::ConfigDeprecationError if File.exists?("config/initializers/events.rb")
+
+
+# Deprecation Notices
+class WebsocketRails::Dispatcher
+  def self.describe_events(&block)
+    raise "This method has been deprecated. Please use WebsocketRails::EventMap.describe instead."
+  end
+end
+class WebsocketRails::Events
+  def self.describe_events(&block)
+    raise "This method has been deprecated. Please use WebsocketRails::EventMap.describe instead."
+  end
+end

data/lib/websocket_rails/base_controller.rb

@@ -0,0 +1,208 @@
+require "websocket_rails/data_store"
+require 'abstract_controller/callbacks'
+
+module WebsocketRails
+  # Provides controller helper methods for developing a WebsocketRails controller. Action methods
+  # defined on a WebsocketRails controller can be mapped to events using the {EventMap} class.
+  #
+  # == Example WebsocketRails controller
+  #   class ChatController < WebsocketRails::BaseController
+  #     # Can be mapped to the :client_connected event in the events.rb file.
+  #     def new_user
+  #       send_message :new_message, {:message => 'Welcome to the Chat Room!'}
+  #     end
+  #   end
+  #
+  # It is best to use the provided {DataStore} to temporarily persist data for each client between
+  # events. Read more about it in the {DataStore} documentation.
+  #
+  #
+  class BaseController
+
+    # We need process_action to be in a module loaded before AbstractController::Callbacks
+    # to get inheritance properly
+    module Metal
+      def process_action(method, event)
+        if respond_to?(method)
+          self.send(method)
+          trigger_finished
+        else
+          raise EventRoutingError.new(event, self, method)
+        end
+      end
+      def response_body
+        false
+      end
+    end
+
+    include Metal
+    include AbstractController::Callbacks
+
+    # Tell Rails that BaseController and children can be reloaded when in
+    # the Development environment.
+    def self.inherited(controller)
+      unless controller.name == "WebsocketRails::InternalController" || Rails.version =~/^4/
+        unloadable controller
+      end
+    end
+
+    # Tell the dispatcher to use channel filtering on specific channels.
+    # If supplied, the :catch_all => :method will be processed for every
+    # event that comes into the channel(s).
+    #
+    #
+    # Example:
+    # To process events based upon the event_name inside :channel_one
+    #
+    #  filter_for_channels :channel_one
+    #
+    # To process events based upon the event_name and a catch all
+    #
+    #  filter_for_channels :channel_one, :catch_all => :logger_method
+    #
+    def self.filter_for_channels(*channels)
+      options = channels.last.is_a?(Hash) ? channels.pop : {}
+      channels.each do |channel|
+        WebsocketRails.filtered_channels[channel] = options[:catch_all].nil? ? self : [self, options[:catch_all]]
+      end
+    end
+
+    # Provides direct access to the connection object for the client that
+    # initiated the event that is currently being executed.
+    def connection
+      @_event.connection
+    end
+
+    # The numerical ID for the client connection that initiated the event. The ID is unique
+    # for each currently active connection but can not be used to associate a client between
+    # multiple connection attempts.
+    def client_id
+      connection.id
+    end
+
+    # The {Event} object that triggered this action.
+    # Find the current event name with event.name
+    # Access the data sent with the event with event.data
+    # Find the event's namespace with event.namespace
+    def event
+      @_event
+    end
+
+    # The current message that was passed from the client when the event was initiated. The
+    # message is typically a standard ruby Hash object. See the README for more information.
+    def message
+      @_event.data
+    end
+    alias_method :data, :message
+
+    # Trigger the success callback function attached to the client event that triggered
+    # this action. The object passed to this method will be passed as an argument to
+    # the callback function on the client.
+    def trigger_success(data=nil)
+      event.success = Event::SUCCEEDED
+      event.data = data
+      event.trigger
+    end
+
+    # Trigger the failure callback function attached to the client event that triggered
+    # this action. The object passed to this method will be passed as an argument to
+    # the callback function on the client.
+    def trigger_failure(data=nil)
+      event.success = Event::FAILED
+      event.data = data
+      event.trigger
+    end
+
+    def accept_channel(data=nil)
+      channel_name = event.data[:channel]
+      WebsocketRails[channel_name].subscribe connection
+      trigger_success data
+    end
+
+    def deny_channel(data=nil)
+      trigger_failure data
+    end
+
+    def stop_event_propagation!
+      event.propagate = false
+    end
+
+    # Sends a message to the client that initiated the current event being executed. Messages
+    # are serialized as JSON into a two element Array where the first element is the event
+    # and the second element is the message that was passed, typically a Hash.
+    #
+    # To send an event under a namespace, add the `:namespace => :target_namespace` option.
+    #
+    #   send_message :new_message, message_hash, :namespace => :product
+    #
+    # Nested namespaces can be passed as an array like the following:
+    #
+    #   send_message :new, message_hash, :namespace => [:products,:glasses]
+    #
+    # See the {EventMap} documentation for more on mapping namespaced actions.
+    def send_message(event_name, message, options={})
+      options.merge! :connection => connection, :data => message
+      event = Event.new( event_name, options )
+      @_dispatcher.send_message event 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_name, message, options={})
+      options.merge! :connection => connection, :data => message
+      event = Event.new( event_name, options )
+      @_dispatcher.broadcast_message event if @_dispatcher.respond_to?(:broadcast_message)
+    end
+
+    def request
+      connection.request
+    end
+
+    def action_name
+      @_action_name
+    end
+
+    # Provides access to the {DataStore} for the current controller. The {DataStore} provides convenience
+    # methods for keeping track of data associated with active connections. See it's documentation for
+    # more information.
+    def controller_store
+      @_controller_store
+    end
+
+    def connection_store
+      connection.data_store
+    end
+
+    def self.controller_name
+      self.name.underscore.gsub(/_controller$/,'')
+    end
+
+    def controller_name
+      self.class.controller_name
+    end
+
+    private
+
+    def delegate
+      connection.controller_delegate
+    end
+
+    def method_missing(method,*args,&block)
+      if delegate.respond_to? method
+        delegate.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    def trigger_finished
+      return if event.nil? || event.success
+      if WebsocketRails.config.trigger_success_by_default
+        event.success = Event::SUCCEEDED
+      else
+        event.success = Event::FINISHED_WITHOUT_RESULT
+      end
+      event.trigger
+    end
+
+  end
+end

data/lib/websocket_rails/channel.rb

@@ -0,0 +1,97 @@
+module WebsocketRails
+  class Channel
+
+    include Logging
+
+    delegate :config, :channel_tokens, :channel_manager, :filtered_channels, :to => WebsocketRails
+
+    attr_reader :name, :subscribers
+
+    def initialize(channel_name)
+      @subscribers = []
+      @name        = channel_name
+      @private     = false
+    end
+
+    def subscribe(connection)
+      info "#{connection} subscribed to channel #{@name}"
+      trigger 'subscriber_join', connection.user if config.broadcast_subscriber_events?
+      @subscribers << connection
+      send_token connection
+    end
+
+    def unsubscribe(connection)
+      return unless @subscribers.include? connection
+      info "#{connection} unsubscribed from channel #{@name}"
+      @subscribers.delete connection
+      trigger 'subscriber_part', connection.user if config.broadcast_subscriber_events?
+    end
+
+    def trigger(event_name,data={},options={})
+      options.merge! :channel => @name, :token => token
+      options[:data] = data
+
+      event = Event.new event_name, options
+
+      info "[#{@name}] #{event.data.inspect}"
+      send_data event
+    end
+
+    def trigger_event(event)
+      return if event.token != token
+      info "[#{@name}] #{event.data.inspect}"
+      send_data event
+    end
+
+    def make_private
+      unless config.keep_subscribers_when_private?
+        @subscribers.clear
+      end
+      @private = true
+    end
+
+    def filter_with(controller, catch_all=nil)
+      filtered_channels[@name] = catch_all.nil? ? controller : [controller, catch_all]
+    end
+
+    def is_private?
+      @private
+    end
+
+    def token
+      @token ||= channel_tokens[@name] ||= generate_unique_token
+    end
+
+    private
+
+    def generate_unique_token
+      begin
+        new_token = SecureRandom.uuid
+      end while channel_tokens.values.include?(new_token)
+
+      new_token
+    end
+
+    def send_token(connection)
+      options = {
+        :channel => @name,
+        :data => {:token => token},
+        :connection => connection
+      }
+      info 'sending token'
+      Event.new('websocket_rails.channel_token', options).trigger
+    end
+
+    def send_data(event)
+      return unless event.should_propagate?
+      if WebsocketRails.synchronize? && event.server_token.nil?
+        Synchronization.publish event
+      end
+
+      @subscribers.each do |subscriber|
+        subscriber.trigger event
+      end
+    end
+
+  end
+end

data/lib/websocket_rails/channel_manager.rb

@@ -0,0 +1,55 @@
+require 'redis-objects'
+
+module WebsocketRails
+
+  class << self
+
+    def channel_manager
+      @channel_manager ||= ChannelManager.new
+    end
+
+    def [](channel)
+      channel_manager[channel]
+    end
+
+    def channel_tokens
+      channel_manager.channel_tokens
+    end
+
+    def filtered_channels
+      channel_manager.filtered_channels
+    end
+
+  end
+
+  class ChannelManager
+
+    attr_reader :channels, :filtered_channels
+
+    def initialize
+      @channels = {}.with_indifferent_access
+      @filtered_channels = {}.with_indifferent_access
+    end
+
+    def channel_tokens
+      @channel_tokens ||= begin
+        if WebsocketRails.synchronize?
+          ::Redis::HashKey.new('websocket_rails.channel_tokens', Synchronization.redis)
+        else
+          {}
+        end
+      end
+    end
+
+    def [](channel)
+      @channels[channel] ||= Channel.new channel
+    end
+
+    def unsubscribe(connection)
+      @channels.each do |channel_name, channel|
+        channel.unsubscribe(connection)
+      end
+    end
+
+  end
+end