Class: WebsocketRails::BaseController

Inherits:
Object
  • Object
show all
Includes:
AbstractController::Callbacks, Metal
Defined in:
lib/websocket_rails/base_controller.rb

Overview

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.

Direct Known Subclasses

InternalController

Defined Under Namespace

Modules: Metal

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Metal

#process_action, #response_body

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object (private) 



188
189
190
191
192
193
194
 
# File 'lib/websocket_rails/base_controller.rb', line 188

def method_missing(method,*args,&block)
  if delegate.respond_to? method
    delegate.send method, *args, &block
  else
    super
  end
end

Class Method Details

.controller_name ⇒ Object 



174
175
176
 
# File 'lib/websocket_rails/base_controller.rb', line 174

def self.controller_name
  self.name.underscore.gsub(/_controller$/,'')
end

.filter_for_channels(*channels) ⇒ Object

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



62
63
64
65
66
67
 
# File 'lib/websocket_rails/base_controller.rb', line 62

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

.inherited(controller) ⇒ Object

Tell Rails that BaseController and children can be reloaded when in the Development environment.



42
43
44
45
46
 
# File 'lib/websocket_rails/base_controller.rb', line 42

def self.inherited(controller)
  unless controller.name == "WebsocketRails::InternalController" || Rails.version =~/^4/
    unloadable controller
  end
end

Instance Method Details

#accept_channel(data = nil) ⇒ Object 



115
116
117
118
119
 
# File 'lib/websocket_rails/base_controller.rb', line 115

def accept_channel(data=nil)
  channel_name = event.data[:channel]
  WebsocketRails[channel_name].subscribe connection
  trigger_success data
end

#action_name ⇒ Object 



159
160
161
 
# File 'lib/websocket_rails/base_controller.rb', line 159

def action_name
  @_action_name
end

#broadcast_message(event_name, message, options = {}) ⇒ Object

Broadcasts a message to all connected clients. See #send_message for message passing details.



149
150
151
152
153
 
# File 'lib/websocket_rails/base_controller.rb', line 149

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

#client_id ⇒ Object

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.



78
79
80
 
# File 'lib/websocket_rails/base_controller.rb', line 78

def client_id
  connection.id
end

#connection ⇒ Object

Provides direct access to the connection object for the client that initiated the event that is currently being executed.



71
72
73
 
# File 'lib/websocket_rails/base_controller.rb', line 71

def connection
  @_event.connection
end

#connection_store ⇒ Object 



170
171
172
 
# File 'lib/websocket_rails/base_controller.rb', line 170

def connection_store
  connection.data_store
end

#controller_name ⇒ Object 



178
179
180
 
# File 'lib/websocket_rails/base_controller.rb', line 178

def controller_name
  self.class.controller_name
end

#controller_store ⇒ Object

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.



166
167
168
 
# File 'lib/websocket_rails/base_controller.rb', line 166

def controller_store
  @_controller_store
end

#deny_channel(data = nil) ⇒ Object 



121
122
123
 
# File 'lib/websocket_rails/base_controller.rb', line 121

def deny_channel(data=nil)
  trigger_failure data
end

#event ⇒ Object

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



86
87
88
 
# File 'lib/websocket_rails/base_controller.rb', line 86

def event
  @_event
end

#message ⇒ Object Also known as: data

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.



92
93
94
 
# File 'lib/websocket_rails/base_controller.rb', line 92

def message
  @_event.data
end

#request ⇒ Object 



155
156
157
 
# File 'lib/websocket_rails/base_controller.rb', line 155

def request
  connection.request
end

#send_message(event_name, message, options = {}) ⇒ Object

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.



142
143
144
145
146
 
# File 'lib/websocket_rails/base_controller.rb', line 142

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

#stop_event_propagation! ⇒ Object 



125
126
127
 
# File 'lib/websocket_rails/base_controller.rb', line 125

def stop_event_propagation!
  event.propagate = false
end

#trigger_failure(data = nil) ⇒ Object

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.



109
110
111
112
113
 
# File 'lib/websocket_rails/base_controller.rb', line 109

def trigger_failure(data=nil)
  event.success = false
  event.data = data
  event.trigger
end

#trigger_success(data = nil) ⇒ Object

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.



100
101
102
103
104
 
# File 'lib/websocket_rails/base_controller.rb', line 100

def trigger_success(data=nil)
  event.success = true
  event.data = data
  event.trigger
end