Module: Messaging::Handle

Included in:

Controls::Handler::Anomaly::NoHandle::Example, Controls::Handler::BlockAndHandleMethod::Example, Controls::Handler::Example, Controls::Handler::HandleMethod::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

• .included(cls) ⇒ Object

Instance Method Summary

• #call(message_or_message_data, strict: nil) ⇒ Object
• #handle_message(message, strict: nil) ⇒ Object
• #handle_message_data(message_data, strict: nil) ⇒ Object
• #strict ⇒ Object (also: #strict?)

Class Method Details

.included(cls) ⇒ Object

# File 'lib/messaging/handle.rb', line 5

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

    def handler_logger
      @handler_logger ||= Log.get(self)
    end
    attr_writer :handler_logger

    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

# File 'lib/messaging/handle.rb', line 164

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

# File 'lib/messaging/handle.rb', line 172

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

  handler_logger.trace(tags: [:dispatch, :message]) { "Dispatching 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.trace(tag: [:handle, :message]) { "Handling Message (Type: #{message_type}, Method: #{handler})" }

    public_send(handler, message)

    handler_logger.info(tags: [:handle, :message]) { "Handled message (Message class: #{message.class.name})" }
    handler_logger.info(tags: [:data, :message]) { message.pretty_inspect }
  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

  message
end

#handle_message_data(message_data, strict: nil) ⇒ Object

# File 'lib/messaging/handle.rb', line 200

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

  handler_logger.trace(tags: [:dispatch, :message_data]) { "Dispatching 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.trace(tag: [:handle, :message_data]) { "Handling Message Data (Type: #{message_type}, Method: #{handler})" }

    public_send(handler, message)

    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 }
  else
    if respond_to?(:handle)
      message_type = message_data.type
      handler_logger.trace(tag: [:handle, :message_data]) { "Handling Message Data (Type: #{message_type}, Method: handle" }

      handle(message_data)

      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 = 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

  message
end

#strict ⇒ Object Also known as: strict?

# File 'lib/messaging/handle.rb', line 159

def strict
  @strict ||= Defaults.strict
end