Module: Messaging::Handle

Included in:
Controls::Handler::Anomaly::NoHandle::Example, Controls::Handler::BlockAndHandleMethod::Example, Controls::Handler::Example, Controls::Handler::HandleMethod::Example, Controls::Handler::SessionArgument::Anomaly::Positional::Example, Controls::Handler::SessionArgument::Anomaly::Positional::Optional::Example, Controls::Handler::SessionArgument::Anomaly::Required::Example, Controls::Handler::SessionArgument::Example, Controls::Handler::UnregisteredMessage::Example
Defined in:
lib/messaging/handle.rb,
lib/messaging/handle/defaults.rb

Defined Under Namespace

Modules: Build, Call, Defaults, HandleMacro, Info, MessageRegistry Classes: Error

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(cls) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/messaging/handle.rb', line 5

def self.included(cls)
  cls.class_exec do
    include Dependency
    include Virtual

    dependency :handler_logger, ::Log

    extend Build
    extend Call
    extend Info
    extend HandleMacro
    extend MessageRegistry

    virtual :configure

    attr_writer :strict
  end
end

Instance Method Details

#call(message_or_message_data, strict: nil) ⇒ Object 



144
145
146
147
148
149
150
 
# File 'lib/messaging/handle.rb', line 144

def call(message_or_message_data, strict: nil)
  if message_or_message_data.is_a? Message
    handle_message(message_or_message_data, strict: strict)
  else
    handle_message_data(message_or_message_data, strict: strict)
  end
end

#handle_message(message, strict: nil) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/messaging/handle.rb', line 152

def handle_message(message, strict: nil)
  strict ||= self.strict?

  handler_logger.trace(tags: [:handle, :message]) { "Handling message (Message class: #{message.class.name})" }
  handler_logger.trace(tags: [:data, :message]) { message.pretty_inspect }

  handler = self.class.handler(message)

  unless handler.nil?
    message_type = message.message_type

    handler_logger.debug(tag: :handle) { "Handling Message (Type: #{message_type}, Method: #{handler})" }
    public_send(handler, message)
  else
    if strict
      error_msg = "#{self.class.name} does not implement a handler for #{message.message_type}. Cannot handle the message."
      handler_logger.error(tag: :handle) { error_msg }
      raise Error, error_msg
    end
  end

  handler_logger.info(tags: [:handle, :message]) { "Handled message (Message class: #{message.class.name})" }
  handler_logger.info(tags: [:data, :message]) { message.pretty_inspect }

  message
end

#handle_message_data(message_data, strict: nil) ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/messaging/handle.rb', line 179

def handle_message_data(message_data, strict: nil)
  strict ||= self.strict?

  handler_logger.trace(tags: [:handle, :message_data]) { "Handling message data (Type: #{message_data.type})" }
  handler_logger.trace(tags: [:data, :message_data]) { message_data.pretty_inspect }

  message = nil

  handler = self.class.handler(message_data)

  unless handler.nil?
    message_type = message_data.type
    message_name = Messaging::Message::Info.canonize_name(message_type)
    message_class = self.class.message_registry.get(message_name)

    if message_class == nil
      error_msg = "No message class is registered (Message Type: #{message_type}, Handler: #{self.class.name})"
      handler_logger.error(tag: :handle) { error_msg }
      raise Error, error_msg
    end

    message = Message::Import.(message_data, message_class)

    message_type = message.message_type

    handler_logger.debug(tag: :handle) { "Handling Message (Type: #{message_type}, Method: #{handler})" }
    public_send(handler, message)
  else
    if respond_to?(:handle)
      message_type = message_data.type
      handler_logger.debug(tag: :handle) { "Handling Message Data (Type: #{message_type}, Method: handle" }

      handle(message_data)

      message = message_data
    else
      if strict
        error_msg = "#{self.class.name} does not implement `handle'. Cannot handle message data."
        handler_logger.error(tag: :handle) { error_msg }
        raise Error, error_msg
      end
    end
  end

  handler_logger.info(tags: [:handle, :message_data]) { "Handled message data (Type: #{message_data.type})" }
  handler_logger.info(tags: [:data, :message_data]) { message_data.pretty_inspect }

  message
end

#strict ⇒ Object Also known as: strict? 



139
140
141
 
# File 'lib/messaging/handle.rb', line 139

def strict
  @strict ||= Defaults.strict
end