Method: Ably::Models::ProtocolMessage#messages

Defined in:: lib/submodules/ably-ruby/lib/ably/models/protocol_message.rb,
lib/submodules/ably-ruby/lib/ably/models/protocol_message.rb
#messages ⇒ `Array<Message>` (readonly)

Returns A Ably::Models::ProtocolMessage with a :message action contains one or more messages belonging to the channel.
Returns:
A Ably::Models::ProtocolMessage with a :message action contains one or more messages belonging to the channel
# File 'lib/submodules/ably-ruby/lib/ably/models/protocol_message.rb', line 36

class ProtocolMessage
  include Ably::Modules::ModelCommon
  include Ably::Modules::Encodeable
  include Ably::Modules::SafeDeferrable if defined?(Ably::Realtime)
  extend Ably::Modules::Enum

  # Actions which are sent by the Ably Realtime API
  #
  # The values correspond to the ints which the API
  # understands.
  ACTION = ruby_enum('ACTION',
    heartbeat:    0,
    ack:          1,
    nack:         2,
    connect:      3,
    connected:    4,
    disconnect:   5,
    disconnected: 6,
    close:        7,
    closed:       8,
    error:        9,
    attach:       10,
    attached:     11,
    detach:       12,
    detached:     13,
    presence:     14,
    message:      15,
    sync:         16,
    auth:         17
  )

  ATTACH_FLAGS_MAPPING = {
    resume: 32, # 2^5
    presence: 65536, # 2^16
    publish: 131072, # 2^17
    subscribe: 262144, # 2^18
    presence_subscribe: 524288, # 2^19
  }

  # Indicates this protocol message action will generate an ACK response such as :message or :presence
  # @api private
  def self.ack_required?(for_action)
    ACTION(for_action).match_any?(ACTION.Presence, ACTION.Message)
  end

  # {ProtocolMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying protocol message data
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [Logger]          :logger            An optional Logger to be used by {Ably::Modules::SafeDeferrable} if an exception is caught in a callback
  #
  def initialize(hash_object, options = {})
    @logger = options[:logger] # Logger expected for SafeDeferrable

    @raw_hash_object = hash_object
    @hash_object     = IdiomaticRubyWrapper(@raw_hash_object.clone)

    raise ArgumentError, 'Invalid ProtocolMessage, action cannot be nil' if @hash_object[:action].nil?
    @hash_object[:action] = ACTION(@hash_object[:action]).to_i unless @hash_object[:action].kind_of?(Integer)

    @hash_object.freeze
  end

  %w(id channel channel_serial connection_id).each do |attribute|
    define_method attribute do
      attributes[attribute.to_sym]
    end
  end

  def id!
    raise RuntimeError, 'ProtocolMessage #id is nil' unless id
    id
  end

  def action
    ACTION(attributes[:action])
  rescue KeyError
    raise KeyError, "Action '#{attributes[:action]}' is not supported by ProtocolMessage"
  end

  def error
    @error ||= ErrorInfo.new(attributes[:error]) if attributes[:error]
  end

  def timestamp
    as_time_from_epoch(attributes[:timestamp]) if attributes[:timestamp]
  end

  def message_serial
    Integer(attributes[:msg_serial])
  rescue TypeError
    raise TypeError, "msg_serial '#{attributes[:msg_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
  end

  def count
    [1, attributes[:count].to_i].max
  end

  # @api private
  def has_message_serial?
    message_serial && true
  rescue TypeError
    false
  end

  def has_channel_serial?
    channel_serial && true
  rescue TypeError
    false
  end

  def messages
    @messages ||=
      Array(attributes[:messages]).map do |message|
        Ably::Models.Message(message, protocol_message: self)
      end
  end

  # @api private
  def add_message(message)
    messages << message
  end

  def presence
    @presence ||=
      Array(attributes[:presence]).map do |message|
        Ably::Models.PresenceMessage(message, protocol_message: self)
      end
  end

  def message_size
    presence.map(&:size).sum + messages.map(&:size).sum
  end

  def params
    @params ||= attributes[:params].to_h
  end

  def flags
    Integer(attributes[:flags])
  rescue TypeError
    0
  end

  # @api private
  def has_presence_flag?
    flags & 1 == 1
  end

  # @api private
  def has_backlog_flag?
    flags & 2 == 2 # 2^1
  end

  # @api private
  def has_channel_resumed_flag?
    flags & 4 == 4 # 2^2
  end

  # @api private
  def has_local_presence_flag?
    flags & 8 == 8 # 2^3
  end

  # @api private
  def has_transient_flag?
    flags & 16 == 16 # 2^4
  end

  # @api private
  def has_attach_resume_flag?
    flags & ATTACH_FLAGS_MAPPING[:resume] == ATTACH_FLAGS_MAPPING[:resume] # 2^5
  end

  # @api private
  def has_attach_presence_flag?
    flags & ATTACH_FLAGS_MAPPING[:presence] == ATTACH_FLAGS_MAPPING[:presence] # 2^16
  end

  # @api private
  def has_attach_publish_flag?
    flags & ATTACH_FLAGS_MAPPING[:publish] == ATTACH_FLAGS_MAPPING[:publish] # 2^17
  end

  # @api private
  def has_attach_subscribe_flag?
    flags & ATTACH_FLAGS_MAPPING[:subscribe] == ATTACH_FLAGS_MAPPING[:subscribe] # 2^18
  end

  # @api private
  def has_attach_presence_subscribe_flag?
    flags & ATTACH_FLAGS_MAPPING[:presence_subscribe] == ATTACH_FLAGS_MAPPING[:presence_subscribe] # 2^19
  end

  def connection_details
    @connection_details ||= Ably::Models::ConnectionDetails(attributes[:connection_details])
  end

  def auth
    @auth ||= Ably::Models::AuthDetails(attributes[:auth])
  end

  # Indicates this protocol message will generate an ACK response when sent
  # Examples of protocol messages required ACK include :message and :presence
  # @api private
  def ack_required?
    self.class.ack_required?(action)
  end

  def attributes
    @hash_object
  end

  # Return a JSON ready object from the underlying #attributes using Ably naming conventions for keys
  def as_json(*args)
    raise TypeError, ':action is missing, cannot generate a valid Hash for ProtocolMessage' unless action

    attributes.dup.tap do |hash_object|
      hash_object['action']   = action.to_i
      hash_object['messages'] = messages.map(&:as_json) unless messages.empty?
      hash_object['presence'] = presence.map(&:as_json) unless presence.empty?
    end.as_json
  end

  def to_s
    json_hash = as_json

    # Decode any binary data to before converting to a JSON string representation
    %w(messages presence).each do |message_type|
      if json_hash[message_type] && !json_hash[message_type].empty?
        json_hash[message_type].each do |message|
          decode_binary_data_before_to_json message
        end
      end
    end

    json_hash.to_json
  end

  # True if the ProtocolMessage appears to be invalid, however this is not a guarantee
  # Used for validating incoming protocol messages, so no need to add unnecessary checks
  # @return [Boolean]
  # @api private
  def invalid?
    action_enum = action rescue nil
    !action_enum
  end

  # @!attribute [r] logger
  # @api private
  attr_reader :logger
end
Method: Ably::Models::ProtocolMessage#messages

#messages ⇒ Array<Message> (readonly)

#messages ⇒ `Array<Message>` (readonly)
