ably 0.8.8 → 0.8.9

data/lib/ably/models/presence_message.rb

@@ -34,7 +34,7 @@ module Ably::Models
   #                    Therefore, the `encoding` attribute should always be nil unless an Ably library decoding error has occurred.
   # @!attribute [r] timestamp
   #   @return [Time] Timestamp when the message was received by the Ably the realtime service
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class PresenceMessage
@@ -54,17 +54,17 @@ module Ably::Models
 
     # {PresenceMessage} initializer
     #
-    # @param  hash_object [Hash]            object with the underlying presence message details
+    # @param  attributes  [Hash]            object with the underlying presence message key value attributes
     # @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 = {})
+    def initialize(attributes, options = {})
       @logger           = options[:logger] # Logger expected for SafeDeferrable
       @protocol_message = options[:protocol_message]
-      @raw_hash_object  = hash_object
+      @raw_hash_object  = attributes
 
-      set_hash_object hash_object
+      set_attributes_object attributes
 
       ensure_utf_8 :client_id,     client_id,     allow_nil: true
       ensure_utf_8 :connection_id, connection_id, allow_nil: true
@@ -73,16 +73,16 @@ module Ably::Models
 
     %w( client_id data encoding ).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def id
-      hash.fetch(:id) { "#{protocol_message.id!}:#{protocol_message_index}" }
+      attributes.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? }
+      attributes.fetch(:connection_id) { protocol_message.connection_id if assigned_to_protocol_message? }
     end
 
     def member_key
@@ -90,24 +90,24 @@ module Ably::Models
     end
 
     def timestamp
-      if hash[:timestamp]
-        as_time_from_epoch(hash[:timestamp])
+      if attributes[:timestamp]
+        as_time_from_epoch(attributes[:timestamp])
       else
         protocol_message.timestamp
       end
     end
 
     def action
-      ACTION(hash[:action])
+      ACTION(attributes[:action])
     end
 
-    def hash
-      @hash_object
+    def attributes
+      @attributes
     end
 
-    # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
+    # Return a JSON ready object from the underlying #attributes using Ably naming conventions for keys
     def as_json(*args)
-      hash.dup.tap do |presence_message|
+      attributes.dup.tap do |presence_message|
         presence_message['action'] = action.to_i
       end.as_json.reject { |key, val| val.nil? }
     rescue KeyError
@@ -151,8 +151,8 @@ module Ably::Models
       protocol_message.presence.index(self)
     end
 
-    def set_hash_object(hash)
-      @hash_object = IdiomaticRubyWrapper(hash.clone.freeze, stop_at: [:data])
+    def set_attributes_object(new_attributes)
+      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data])
     end
 
     def logger

data/lib/ably/models/protocol_message.rb

@@ -32,7 +32,7 @@ module Ably::Models
   #   @return [Array<PresenceMessage>] A {ProtocolMessage} with a `:presence` action contains one or more presence updates belonging to the channel
   # @!attribute [r] flags
   #   @return [Integer] Flags indicating special ProtocolMessage states
-  # @!attribute [r] hash
+  # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
   class ProtocolMessage
@@ -66,6 +66,7 @@ module Ably::Models
     )
 
     # Indicates this protocol message action will generate an ACK response such as :message or :presence
+    # @api private
     def self.ack_required?(for_action)
       [ACTION.Presence, ACTION.Message].include?(ACTION(for_action))
     end
@@ -90,14 +91,14 @@ module Ably::Models
 
     %w(id channel channel_serial connection_id).each do |attribute|
       define_method attribute do
-        hash[attribute.to_sym]
+        attributes[attribute.to_sym]
       end
     end
 
     def connection_key
       # connection_key in connection details takes precedence over connection_key on the ProtocolMessage
       # connection_key in the ProtocolMessage will be deprecated in future protocol versions > 0.8
-      connection_details.connection_key || hash[:connection_key]
+      connection_details.connection_key || attributes[:connection_key]
     end
 
     def id!
@@ -106,41 +107,43 @@ module Ably::Models
     end
 
     def action
-      ACTION(hash[:action])
+      ACTION(attributes[:action])
     rescue KeyError
-      raise KeyError, "Action '#{hash[:action]}' is not supported by ProtocolMessage"
+      raise KeyError, "Action '#{attributes[:action]}' is not supported by ProtocolMessage"
     end
 
     def error
-      @error ||= ErrorInfo.new(hash[:error]) if hash[:error]
+      @error ||= ErrorInfo.new(attributes[:error]) if attributes[:error]
     end
 
     def timestamp
-      as_time_from_epoch(hash[:timestamp]) if hash[:timestamp]
+      as_time_from_epoch(attributes[:timestamp]) if attributes[:timestamp]
     end
 
     def message_serial
-      Integer(hash[:msg_serial])
+      Integer(attributes[:msg_serial])
     rescue TypeError
-      raise TypeError, "msg_serial '#{hash[:msg_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
+      raise TypeError, "msg_serial '#{attributes[:msg_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
     end
 
     def connection_serial
-      Integer(hash[:connection_serial])
+      Integer(attributes[:connection_serial])
     rescue TypeError
-      raise TypeError, "connection_serial '#{hash[:connection_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
+      raise TypeError, "connection_serial '#{attributes[:connection_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
     end
 
     def count
-      [1, hash[:count].to_i].max
+      [1, attributes[:count].to_i].max
     end
 
+    # @api private
     def has_message_serial?
       message_serial && true
     rescue TypeError
       false
     end
 
+    # @api private
     def has_connection_serial?
       connection_serial && true
     rescue TypeError
@@ -155,58 +158,62 @@ module Ably::Models
       end
     end
 
+    # @api private
     def has_serial?
       has_connection_serial? || has_message_serial?
     end
 
     def messages
       @messages ||=
-        Array(hash[:messages]).map do |message|
+        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(hash[:presence]).map do |message|
+        Array(attributes[:presence]).map do |message|
           Ably::Models.PresenceMessage(message, protocol_message: self)
         end
     end
 
     def flags
-      Integer(hash[:flags])
+      Integer(attributes[:flags])
     rescue TypeError
       0
     end
 
+    # @api private
     def has_presence_flag?
       flags & 1 == 1
     end
 
     def connection_details
-      @connection_details ||= Ably::Models::ConnectionDetails(hash[:connection_details])
+      @connection_details ||= Ably::Models::ConnectionDetails(attributes[:connection_details])
     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 hash
+    def attributes
       @hash_object
     end
 
-    # Return a JSON ready object from the underlying #hash using Ably naming conventions for keys
+    # 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
       raise TypeError, ':msg_serial or :connection_serial is missing, cannot generate a valid Hash for ProtocolMessage' if ack_required? && !has_serial?
 
-      hash.dup.tap do |hash_object|
+      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?

data/lib/ably/models/stats.rb

@@ -117,61 +117,61 @@ module Ably::Models
     #
     def initialize(hash_object)
       @raw_hash_object  = hash_object
-      set_hash_object hash_object
+      set_attributes_object hash_object
     end
 
     # Aggregates inbound and outbound messages
     # @return {Stats::MessageTypes}
     def all
-      @all ||= Stats::MessageTypes.new(hash[:all])
+      @all ||= Stats::MessageTypes.new(attributes[:all])
     end
 
     # All inbound messages i.e. received by Ably from clients
     # @return {Stats::MessageTraffic}
     def inbound
-      @inbound ||= Stats::MessageTraffic.new(hash[:inbound])
+      @inbound ||= Stats::MessageTraffic.new(attributes[:inbound])
     end
 
     # All outbound messages i.e. sent from Ably to clients
     # @return {Stats::MessageTraffic}
     def outbound
-      @outbound ||= Stats::MessageTraffic.new(hash[:outbound])
+      @outbound ||= Stats::MessageTraffic.new(attributes[:outbound])
     end
 
     # Messages persisted for later retrieval via the history API
     # @return {Stats::MessageTypes}
     def persisted
-      @persisted ||= Stats::MessageTypes.new(hash[:persisted])
+      @persisted ||= Stats::MessageTypes.new(attributes[:persisted])
     end
 
     # Breakdown of connection stats data for different (TLS vs non-TLS) connection types
     # @return {Stats::ConnectionTypes}
     def connections
-      @connections ||= Stats::ConnectionTypes.new(hash[:connections])
+      @connections ||= Stats::ConnectionTypes.new(attributes[:connections])
     end
 
     # Breakdown of channels stats
     # @return {Stats::ResourceCount}
     def channels
-      @channels ||= Stats::ResourceCount.new(hash[:channels])
+      @channels ||= Stats::ResourceCount.new(attributes[:channels])
     end
 
     # Breakdown of API requests received via the REST API
     # @return {Stats::RequestCount}
     def api_requests
-      @api_requests ||= Stats::RequestCount.new(hash[:api_requests])
+      @api_requests ||= Stats::RequestCount.new(attributes[:api_requests])
     end
 
     # Breakdown of Token requests received via the REST API
     # @return {Stats::RequestCount}
     def token_requests
-      @token_requests ||= Stats::RequestCount.new(hash[:token_requests])
+      @token_requests ||= Stats::RequestCount.new(attributes[:token_requests])
     end
 
     # @!attribute [r] interval_id
     # @return [String] The interval that this statistic applies to, see {GRANULARITY} and {INTERVAL_FORMAT_STRING}
     def interval_id
-      hash.fetch(:interval_id)
+      attributes.fetch(:interval_id)
     end
 
     # @!attribute [r] interval_time
@@ -186,12 +186,12 @@ module Ably::Models
       self.class.granularity_from_interval_id(interval_id)
     end
 
-    def hash
-      @hash_object
+    def attributes
+      @attributes
     end
 
     def as_json(*args)
-      hash.as_json(*args).reject { |key, val| val.nil? }
+      attributes.as_json(*args).reject { |key, val| val.nil? }
     end
 
     private
@@ -199,8 +199,8 @@ module Ably::Models
       @raw_hash_object
     end
 
-    def set_hash_object(hash)
-      @hash_object = IdiomaticRubyWrapper(hash.clone.freeze)
+    def set_attributes_object(new_attributes)
+      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze)
     end
   end
 end

data/lib/ably/models/token_details.rb

@@ -16,7 +16,7 @@ module Ably::Models
   # TokenDetails is a class providing details of the token string and the token's associated metadata,
   # constructed from the response from Ably when request in a token via the REST API.
   #
-  # Ruby {Time} objects are supported in place of Ably ms since epoch time fields.  However, if a numeric is provided
+  # Ruby {http://ruby-doc.org/core/Time.html Time} objects are supported in place of Ably ms since epoch time fields.  However, if a numeric is provided
   # it must always be expressed in milliseconds as the Ably API always uses milliseconds for time fields.
   #
   class TokenDetails
@@ -38,46 +38,48 @@ module Ably::Models
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
 
       %w(issued expires).map(&:to_sym).each do |time_attribute|
-        hash[time_attribute] = (hash[time_attribute].to_f * 1000).round if hash[time_attribute].kind_of?(Time)
+        if self.attributes[time_attribute].kind_of?(Time)
+          self.attributes[time_attribute] = (self.attributes[time_attribute].to_f * 1000).round
+        end
       end
 
-      hash.freeze
+      self.attributes.freeze
     end
 
     # @!attribute [r] token
     # @return [String] Token used to authenticate requests
     def token
-      hash[:token]
+      attributes[:token]
     end
 
     # @!attribute [r] key_name
     # @return [String] API key name used to create this token.  An API key is made up of an API key name and secret delimited by a +:+
     def key_name
-      hash[:key_name]
+      attributes[:key_name]
     end
 
     # @!attribute [r] issued
     # @return [Time] Time the token was issued
     def issued
-      as_time_from_epoch(hash[:issued], granularity: :ms, allow_nil: :true)
+      as_time_from_epoch(attributes[:issued], granularity: :ms, allow_nil: :true)
     end
 
     # @!attribute [r] expires
     # @return [Time] Time the token expires
     def expires
-      as_time_from_epoch(hash[:expires], granularity: :ms, allow_nil: :true)
+      as_time_from_epoch(attributes[:expires], granularity: :ms, allow_nil: :true)
     end
 
     # @!attribute [r] capability
     # @return [Hash] Capabilities assigned to this token
     def capability
-      JSON.parse(hash.fetch(:capability)) if hash.has_key?(:capability)
+      JSON.parse(attributes.fetch(:capability)) if attributes.has_key?(:capability)
     end
 
     # @!attribute [r] client_id
     # @return [String] Optional client ID assigned to this token
     def client_id
-      hash[:client_id]
+      attributes[:client_id]
     end
 
     # Returns true if token is expired or about to expire
@@ -93,12 +95,12 @@ module Ably::Models
     # @return [Boolean]
     # @api private
     def from_token_string?
-      hash.keys == [:token]
+      attributes.keys == [:token]
     end
 
-    # @!attribute [r] hash
+    # @!attribute [r] attributes
     # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
-    def hash
+    def attributes
       @hash_object
     end
 

data/lib/ably/models/token_request.rb

@@ -16,7 +16,7 @@ module Ably::Models
 
   # TokenRequest is a class that stores the attributes of a token request
   #
-  # Ruby {Time} objects are supported in place of Ably ms since epoch time fields.  However, if a numeric is provided
+  # Ruby {http://ruby-doc.org/core/Time.html Time} objects are supported in place of Ably ms since epoch time fields.  However, if a numeric is provided
   # it must always be expressed in milliseconds as the Ably API always uses milliseconds for time fields.
   #
   class TokenRequest
@@ -24,7 +24,7 @@ module Ably::Models
 
     # @param attributes
     # @option attributes [Integer]      :ttl        requested time to live for the token in milliseconds
-    # @option attributes [Time,Integer] :timestamp  the timestamp of this request in milliseconds or as a {Time}
+    # @option attributes [Time,Integer] :timestamp  the timestamp of this request in milliseconds or as a {http://ruby-doc.org/core/Time.html Time}
     # @option attributes [String]       :key_name   API key name of the key against which this request is made
     # @option attributes [String]       :capability JSON stringified capability of the token
     # @option attributes [String]       :client_id  client ID to associate with this token
@@ -33,14 +33,16 @@ module Ably::Models
     #
     def initialize(attributes = {})
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
-      hash[:timestamp] = (hash[:timestamp].to_f * 1000).round if hash[:timestamp].kind_of?(Time)
-      hash.freeze
+      if self.attributes[:timestamp].kind_of?(Time)
+        self.attributes[:timestamp] = (self.attributes[:timestamp].to_f * 1000).round
+      end
+      self.attributes.freeze
     end
 
     # @!attribute [r] key_name
     # @return [String] API key name of the key against which this request is made.  An API key is made up of an API key name and secret delimited by a +:+
     def key_name
-      hash.fetch(:key_name)
+      attributes.fetch(:key_name)
     end
 
     # @!attribute [r] ttl
@@ -49,7 +51,7 @@ module Ably::Models
     #                   settings and the attributes of the issuing key.
     #                   TTL when sent to Ably is in milliseconds.
     def ttl
-      hash.fetch(:ttl) / 1000
+      attributes.fetch(:ttl) / 1000
     end
 
     # @!attribute [r] capability
@@ -57,14 +59,14 @@ module Ably::Models
     #                the capability of the returned token will be the intersection of
     #                this capability with the capability of the issuing key.
     def capability
-      JSON.parse(hash.fetch(:capability))
+      JSON.parse(attributes.fetch(:capability))
     end
 
     # @!attribute [r] client_id
     # @return [String] the client ID to associate with this token. The generated token
     #                  may be used to authenticate as this clientId.
     def client_id
-      hash[:client_id]
+      attributes[:client_id]
     end
 
     # @!attribute [r] timestamp
@@ -73,7 +75,7 @@ module Ably::Models
     #                token requests from being replayed.
     #                Timestamp when sent to Ably is in milliseconds.
     def timestamp
-      as_time_from_epoch(hash.fetch(:timestamp), granularity: :ms)
+      as_time_from_epoch(attributes.fetch(:timestamp), granularity: :ms)
     end
 
     # @!attribute [r] nonce
@@ -81,26 +83,26 @@ module Ably::Models
     #                   uniqueness of this request. Any subsequent request using the
     #                   same nonce will be rejected.
     def nonce
-      hash.fetch(:nonce)
+      attributes.fetch(:nonce)
     end
 
     # @!attribute [r] mac
     # @return [String]  the Message Authentication Code for this request. See the
     #                   {https://www.ably.io/documentation Ably Authentication documentation} for more details.
     def mac
-      hash.fetch(:mac)
+      attributes.fetch(:mac)
     end
 
     # Requests that the token is always persisted
     # @api private
     #
     def persisted
-      hash.fetch(:persisted)
+      attributes.fetch(:persisted)
     end
 
-    # @!attribute [r] hash
+    # @!attribute [r] attributes
     # @return [Hash] the token request Hash object ruby'fied to use symbolized keys
-    def hash
+    def attributes
       @hash_object
     end
   end