Class: Ably::Models::PresenceMessage

Inherits:
Object
  • Object
show all
Extended by:
Ably::Modules::Enum
Includes:
Ably::Modules::Conversions, Ably::Modules::Encodeable, Ably::Modules::ModelCommon, Ably::Modules::SafeDeferrable
Defined in:
lib/ably/models/presence_message.rb

Overview

A class representing an individual presence message to be sent or received via the Ably Realtime service.

Constant Summary collapse

ACTION = 
ruby_enum('ACTION',
  :absent,
  :present,
  :enter,
  :leave,
  :update
)

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Ably::Modules::SafeDeferrable

#callback, #errback, #fail, #succeed

Methods included from Ably::Modules::ModelCommon

#==, #[], #to_json

Methods included from Ably::Modules::MessagePack

#to_msgpack

Methods included from Ably::Modules::Encodeable

#decode, #encode, #original_encoding

Constructor Details

#initialize(hash_object, options = {}) ⇒ PresenceMessage

Ably::Models::PresenceMessage initializer

Options Hash (options):



62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/ably/models/presence_message.rb', line 62

def initialize(hash_object, options = {})
  @logger           = options[:logger] # Logger expected for SafeDeferrable
  @protocol_message = options[:protocol_message]
  @raw_hash_object  = hash_object

  set_hash_object hash_object

  ensure_utf_8 :client_id,     client_id,     allow_nil: true
  ensure_utf_8 :connection_id, connection_id, allow_nil: true
  ensure_utf_8 :encoding,      encoding,      allow_nil: true
end

Instance Attribute Details

#action ⇒ ACTION (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#client_id ⇒ String (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#connection_id ⇒ String (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#data ⇒ Object (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#encoding ⇒ String (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#hash ⇒ Hash (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#member_key ⇒ String (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

#timestamp ⇒ Time (readonly) 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ably/models/presence_message.rb', line 40

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

  ACTION = ruby_enum('ACTION',
    :absent,
    :present,
    :enter,
    :leave,
    :update
  )

  # {PresenceMessage} initializer
  #
  # @param  hash_object [Hash]            object with the underlying presence message details
  # @param  [Hash]      options           an options Hash for this initializer
  # @option options     [ProtocolMessage] :protocol_message  An optional protocol message to assocate the presence message with
  # @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
    @protocol_message = options[:protocol_message]
    @raw_hash_object  = hash_object

    set_hash_object hash_object

    ensure_utf_8 :client_id,     client_id,     allow_nil: true
    ensure_utf_8 :connection_id, connection_id, allow_nil: true
    ensure_utf_8 :encoding,      encoding,      allow_nil: true
  end

  %w( client_id data encoding ).each do |attribute|
    define_method attribute do
      hash[attribute.to_sym]
    end
  end

  def id
    hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
  end

  def connection_id
    hash.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
  end

  def member_key
    "#{connection_id}:#{client_id}"
  end

  def timestamp
    if hash[:timestamp]
      as_time_from_epoch(hash[:timestamp])
    else
      protocol_message.timestamp
    end
  end

  def action
    ACTION(hash[:action])
  end

  def hash
    @hash_object
  end

  # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
  def as_json(*args)
    hash.dup.tap do |presence_message|
      presence_message['action'] = action.to_i
      decode_binary_data_before_to_json presence_message
    end.as_json
  rescue KeyError
    raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
  end

  # Assign this presence message to a ProtocolMessage before delivery to the Ably system
  # @api private
  def assign_to_protocol_message(protocol_message)
    @protocol_message = protocol_message
  end

  # True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably
  # @return [Boolean]
  # @api private
  def assigned_to_protocol_message?
    !!@protocol_message
  end

  # The optional ProtocolMessage this presence message is assigned to.  If ProtocolMessage is nil, an error will be raised.
  # @return [Ably::Models::ProtocolMessage]
  # @api private
  def protocol_message
    raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
    @protocol_message
  end

  private
  attr_reader :raw_hash_object

  def protocol_message_index
    protocol_message.presence.index(self)
  end

  def set_hash_object(hash)
    @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
  end

  def logger
    return logger if logger
    protocol_message.logger if protocol_message
  end
end

Instance Method Details

#as_json(*args) ⇒ Object

Return a JSON ready object from the underlying #hash using Ably naming conventions for keys



109
110
111
112
113
114
115
116
 
# File 'lib/ably/models/presence_message.rb', line 109

def as_json(*args)
  hash.dup.tap do |presence_message|
    presence_message['action'] = action.to_i
    decode_binary_data_before_to_json presence_message
  end.as_json
rescue KeyError
  raise KeyError, ':action is missing or invalid, cannot generate a valid Hash for ProtocolMessage'
end

#assign_to_protocol_message(protocol_message) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Assign this presence message to a ProtocolMessage before delivery to the Ably system



120
121
122
 
# File 'lib/ably/models/presence_message.rb', line 120

def assign_to_protocol_message(protocol_message)
  @protocol_message = protocol_message
end

#assigned_to_protocol_message? ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

True if this presence message is assigned to a ProtocolMessage for delivery to Ably, or received from Ably



127
128
129
 
# File 'lib/ably/models/presence_message.rb', line 127

def assigned_to_protocol_message?
  !!@protocol_message
end

#id ⇒ Object 



80
81
82
 
# File 'lib/ably/models/presence_message.rb', line 80

def id
  hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
end

#protocol_message ⇒ Ably::Models::ProtocolMessage

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The optional ProtocolMessage this presence message is assigned to. If ProtocolMessage is nil, an error will be raised.

Raises:

  • (RuntimeError) 


134
135
136
137
 
# File 'lib/ably/models/presence_message.rb', line 134

def protocol_message
  raise RuntimeError, 'Presence Message is not yet published with a ProtocolMessage. ProtocolMessage is nil' if @protocol_message.nil?
  @protocol_message
end