ably-rest 0.8.6 → 0.8.9

data/lib/submodules/ably-ruby/lib/ably/models/message_encoders/cipher.rb

@@ -4,7 +4,7 @@ require 'ably/util/crypto'
 
 module Ably::Models::MessageEncoders
   # Cipher Encoder & Decoder that automatically encrypts & decrypts messages using Ably::Util::Crypto
-  # when a channel has option encrypted: true.
+  # when a channel has the +:cipher+ channel option configured
   #
   class Cipher < Base
     ENCODING_ID = 'cipher'
@@ -20,16 +20,17 @@ module Ably::Models::MessageEncoders
 
       if channel_configured_for_encryption?(channel_options)
         add_encoding_to_message 'utf-8', message unless is_binary?(message) || is_utf8_encoded?(message)
-
         crypto = crypto_for(channel_options)
         message[:data] = crypto.encrypt(message[:data])
-        add_encoding_to_message "#{ENCODING_ID}+#{crypto.cipher_type.downcase}", message
+        add_encoding_to_message "#{ENCODING_ID}+#{crypto.cipher_params.cipher_type.downcase}", message
       end
     rescue ArgumentError => e
       raise Ably::Exceptions::CipherError.new(e.message, nil, 92005)
     rescue RuntimeError => e
       if e.message.match(/unsupported cipher algorithm/i)
         raise Ably::Exceptions::CipherError.new(e.message, nil, 92004)
+      else
+        raise e
       end
     end
 
@@ -40,8 +41,8 @@ module Ably::Models::MessageEncoders
         end
 
         crypto = crypto_for(channel_options)
-        unless crypto.cipher_type == cipher_algorithm(message).upcase
-          raise Ably::Exceptions::CipherError.new("Cipher algorithm #{crypto.cipher_type} does not match message cipher algorithm of #{cipher_algorithm(message).upcase}", nil, 92002)
+        unless crypto.cipher_params.cipher_type == cipher_algorithm(message).upcase
+          raise Ably::Exceptions::CipherError.new("Cipher algorithm #{crypto.cipher_params.cipher_type} does not match message cipher algorithm of #{cipher_algorithm(message).upcase}", nil, 92002)
         end
 
         message[:data] = crypto.decrypt(message[:data])
@@ -61,11 +62,11 @@ module Ably::Models::MessageEncoders
     end
 
     def crypto_for(channel_options)
-      @cryptos[channel_options.fetch(:cipher_params, :default)] ||= Ably::Util::Crypto.new(channel_options.fetch(:cipher_params, {}))
+      @cryptos[channel_options.to_s] ||= Ably::Util::Crypto.new(channel_options.fetch(:cipher, {}))
     end
 
     def channel_configured_for_encryption?(channel_options)
-      channel_options.fetch(:encrypted, false)
+      channel_options[:cipher]
     end
 
     def is_cipher_encoded?(message)
@@ -73,11 +74,11 @@ module Ably::Models::MessageEncoders
     end
 
     def cipher_algorithm(message)
-      current_encoding_part(message).to_s[/^#{ENCODING_ID}\+([\w_-]+)$/, 1]
+      current_encoding_part(message).to_s[/^#{ENCODING_ID}\+([\w-]+)$/, 1]
     end
 
     def already_encrypted?(message)
-      message.fetch(:encoding, '').to_s.match(%r{(^|/)#{ENCODING_ID}\+([\w_-]+)($|/)})
+      message.fetch(:encoding, '').to_s.match(%r{(^|/)#{ENCODING_ID}\+([\w-]+)($|/)})
     end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/models/paginated_result.rb

@@ -95,7 +95,33 @@ module Ably::Models
     end
 
     private
-    attr_reader :http_response, :base_url, :client, :coerce_into, :raw_body, :each_block, :make_async
+    def http_response
+      @http_response
+    end
+
+    def base_url
+      @base_url
+    end
+
+    def client
+      @client
+    end
+
+    def coerce_into
+      @coerce_into
+    end
+
+    def raw_body
+      @raw_body
+    end
+
+    def each_block
+      @each_block
+    end
+
+    def make_async
+      @make_async
+    end
 
     def coerce_items_into(items, type_string)
       items.map do |item|

data/lib/submodules/ably-ruby/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
@@ -143,14 +143,16 @@ module Ably::Models
     end
 
     private
-    attr_reader :raw_hash_object
+    def raw_hash_object
+      @raw_hash_object
+    end
 
     def protocol_message_index
       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/submodules/ably-ruby/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/submodules/ably-ruby/lib/ably/models/{stat.rb → stats.rb}

@@ -82,7 +82,7 @@ module Ably::Models
       def from_interval_id(interval_id)
         raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)
 
-        format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
+        format = INTERVAL_FORMAT_STRING.find { |fmt| expected_length(fmt) == interval_id.length }
         raise ArgumentError, 'Interval ID is an invalid length' unless format
 
         Time.strptime("#{interval_id} +0000", "#{format} %z").utc
@@ -99,7 +99,7 @@ module Ably::Models
       def granularity_from_interval_id(interval_id)
         raise ArgumentError, 'Interval ID must be a string' unless interval_id.kind_of?(String)
 
-        format = INTERVAL_FORMAT_STRING.find { |format| expected_length(format) == interval_id.length }
+        format = INTERVAL_FORMAT_STRING.find { |fmt| expected_length(fmt) == interval_id.length }
         raise ArgumentError, 'Interval ID is an invalid length' unless format
 
         GRANULARITY[INTERVAL_FORMAT_STRING.index(format)]
@@ -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}
+    # @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,19 +186,21 @@ 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
-    attr_reader :raw_hash_object
+    def raw_hash_object
+      @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