ably 1.1.8 → 1.2.2

data/lib/ably/models/message.rb

@@ -162,15 +162,15 @@ module Ably::Models
       @delta_extras ||= DeltaExtras.new(attributes[:extras][:delta]).freeze
     end
 
+    def protocol_message_index
+      protocol_message.messages.map(&:object_id).index(self.object_id)
+    end
+
     private
     def raw_hash_object
       @raw_hash_object
     end
 
-    def protocol_message_index
-      protocol_message.messages.map(&:object_id).index(self.object_id)
-    end
-
     def set_attributes_object(new_attributes)
       @attributes = IdiomaticRubyWrapper(new_attributes.clone, stop_at: [:data, :extras])
     end

data/lib/ably/models/protocol_message.rb

@@ -3,7 +3,7 @@ module Ably::Models
   # A ProtocolMessage always relates to a single channel only, but
   # can contain multiple individual Messages or PresenceMessages.
   # ProtocolMessages are serially numbered on a connection.
-  # See the {http://docs.ably.io/client-lib-development-guide/protocol/ Ably client library developer documentation}
+  # See the {http://ably.com/docs/client-lib-development-guide/protocol/ Ably client library developer documentation}
   # for further details on the members of a ProtocolMessage
   #
   # @!attribute [r] action
@@ -11,7 +11,7 @@ module Ably::Models
   # @!attribute [r] auth
   #   @return [Ably::Models::AuthDetails] Authentication details used to perform authentication upgrades over an existing transport
   # @!attribute [r] count
-  #   @return [Integer] The count field is used for ACK and NACK actions. See {http://docs.ably.io/client-lib-development-guide/protocol/#message-acknowledgement message acknowledgement protocol}
+  #   @return [Integer] The count field is used for ACK and NACK actions. See {http://ably.com/docs/client-lib-development-guide/protocol/#message-acknowledgement message acknowledgement protocol}
   # @!attribute [r] error
   #   @return [ErrorInfo] Contains error information
   # @!attribute [r] channel
@@ -66,6 +66,14 @@ module Ably::Models
       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)
@@ -185,6 +193,10 @@ module Ably::Models
       message_size <= connection_details.max_message_size
     end
 
+    def params
+      @params ||= attributes[:params].to_h
+    end
+
     def flags
       Integer(attributes[:flags])
     rescue TypeError
@@ -218,27 +230,27 @@ module Ably::Models
 
     # @api private
     def has_attach_resume_flag?
-      flags & 32 == 32 # 2^5
+      flags & ATTACH_FLAGS_MAPPING[:resume] == ATTACH_FLAGS_MAPPING[:resume] # 2^5
     end
 
     # @api private
     def has_attach_presence_flag?
-      flags & 65536 == 65536 # 2^16
+      flags & ATTACH_FLAGS_MAPPING[:presence] == ATTACH_FLAGS_MAPPING[:presence] # 2^16
     end
 
     # @api private
     def has_attach_publish_flag?
-      flags & 131072 == 131072 # 2^17
+      flags & ATTACH_FLAGS_MAPPING[:publish] == ATTACH_FLAGS_MAPPING[:publish] # 2^17
     end
 
     # @api private
     def has_attach_subscribe_flag?
-      flags & 262144 == 262144 # 2^18
+      flags & ATTACH_FLAGS_MAPPING[:subscribe] == ATTACH_FLAGS_MAPPING[:subscribe] # 2^18
     end
 
     # @api private
     def has_attach_presence_subscribe_flag?
-      flags & 524288 == 524288 # 2^19
+      flags & ATTACH_FLAGS_MAPPING[:presence_subscribe] == ATTACH_FLAGS_MAPPING[:presence_subscribe] # 2^19
     end
 
     def connection_details

data/lib/ably/models/token_details.rb

@@ -95,10 +95,15 @@ module Ably::Models
     # Returns true if token is expired or about to expire
     # For tokens that have not got an explicit expires attribute expired? will always return true
     #
+    # @param attributes [Hash]
+    # @option attributes [Time] :from   Sets a current time from which token expires
+    #
     # @return [Boolean]
-    def expired?
+    def expired?(attributes = {})
       return false if !expires
-      expires < Time.now + TOKEN_EXPIRY_BUFFER
+
+      from = attributes[:from] || Time.now
+      expires < from + TOKEN_EXPIRY_BUFFER
     end
 
     # True if the TokenDetails was created from an opaque string i.e. no metadata exists for this token

data/lib/ably/models/token_request.rb

@@ -98,7 +98,7 @@ module Ably::Models
 
     # @!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.
+    #                   {https://www.ably.com/docs Ably Authentication documentation} for more details.
     def mac
       attributes.fetch(:mac) { raise Ably::Exceptions::InvalidTokenRequest, 'MAC is missing' }
     end

data/lib/ably/modules/ably.rb

@@ -6,7 +6,7 @@
 module Ably
   # Fallback hosts to use when a connection to rest/realtime.ably.io is not possible due to
   # network failures either at the client, between the client and Ably, within an Ably data center, or at the IO domain registrar
-  # see https://docs.ably.io/client-lib-development-guide/features/#RSC15a
+  # see https://ably.com/docs/client-lib-development-guide/features/#RSC15a
   #
   FALLBACK_DOMAIN = 'ably-realtime.com'.freeze
   FALLBACK_IDS = %w(a b c d e).freeze

data/lib/ably/modules/channels_collection.rb

@@ -13,14 +13,21 @@ module Ably::Modules
     # Return a Channel for the given name
     #
     # @param name [String] The name of the channel
-    # @param channel_options [Hash] Channel options including the encryption options
+    # @param channel_options [Hash, Ably::Models::ChannelOptions] A hash of options or a {Ably::Models::ChannelOptions}
     #
     # @return [Channel]
     #
     def get(name, channel_options = {})
       if channels.has_key?(name)
         channels[name].tap do |channel|
-          channel.update_options channel_options if channel_options && !channel_options.empty?
+          if channel_options && !channel_options.empty?
+            if channel.respond_to?(:need_reattach?) && channel.need_reattach?
+              raise_implicit_options_update
+            else
+              warn_implicit_options_update
+              channel.options = channel_options
+            end
+          end
         end
       else
         channels[name] ||= channel_klass.new(client, name, channel_options)
@@ -70,6 +77,19 @@ module Ably::Modules
     end
 
     private
+
+    def raise_implicit_options_update
+      raise ArgumentError, "You are trying to indirectly update channel options which will trigger reattachment of the channel. Please use Channel#set_options directly if you wish to continue"
+    end
+
+    def warn_implicit_options_update
+      logger.warn { "Channels#get: Using this method to update channel options is deprecated and may be removed in a future version of ably-ruby. Please use Channel#setOptions instead" }
+    end
+
+    def logger
+      client.logger
+    end
+
     def client
       @client
     end

data/lib/ably/modules/conversions.rb

@@ -115,5 +115,39 @@ module Ably::Modules
 
       raise Ably::Exceptions::UnsupportedDataType.new('Invalid data payload', 400, Ably::Exceptions::Codes::INVALID_MESSAGE_DATA_OR_ENCODING)
     end
+
+    # Converts the name, data, attributes into the array of Message objects
+    #
+    # @return [Array<Ably::Models::Message>]
+    #
+    def build_messages(name, data = nil, attributes = {})
+      return [Ably::Models::Message(ensure_supported_name_and_payload(nil, data, attributes))] if name.nil?
+
+      Array(name).map do |item|
+        Ably::Models::Message(ensure_supported_name_and_payload(item, data, attributes))
+      end
+    end
+
+    # Ensures if the first argument (name) is a String, Hash or Ably::Models::Message object,
+    # second argument (data) should be a String, Hash, Array or nil (see ensure_supported_payload() method).
+    #
+    # @return [Hash]        Contains :name, :data and other attributes
+    #
+    # (RSL1a, RSL1b)
+    #
+    def ensure_supported_name_and_payload(name, data = nil, attributes = {})
+      return name.attributes.dup if name.kind_of?(Ably::Models::Message)
+
+      payload = data
+      if (hash = name).kind_of?(Hash)
+        name, payload = hash[:name], (hash[:data] || payload)
+        attributes.merge!(hash)
+      end
+
+      name = ensure_utf_8(:name, name, allow_nil: true)
+      ensure_supported_payload payload
+
+      attributes.merge({ name: name, data: payload })
+    end
   end
 end

data/lib/ably/realtime/auth.rb

@@ -2,10 +2,10 @@ require 'ably/auth'
 
 module Ably
   module Realtime
-    # Auth is responsible for authentication with {https://www.ably.io Ably} using basic or token authentication
+    # Auth is responsible for authentication with {https://www.ably.com Ably} using basic or token authentication
     # This {Ably::Realtime::Auth Realtime::Auth} class wraps the {Ably::Auth Synchronous Ably::Auth} class in an EventMachine friendly way using Deferrables for all IO.  See {Ably::Auth Ably::Auth} for more information
     #
-    # Find out more about Ably authentication at: https://www.ably.io/documentation/general/authentication/
+    # Find out more about Ably authentication at: https://www.ably.com/docs/general/authentication/
     #
     # @!attribute [r] client_id
     #   (see Ably::Auth#client_id)

data/lib/ably/realtime/channel/channel_manager.rb

@@ -38,6 +38,8 @@ module Ably::Realtime
         if attached_protocol_message
           update_presence_sync_state_following_attached attached_protocol_message
           channel.properties.set_attach_serial(attached_protocol_message.channel_serial)
+          channel.options.set_modes_from_flags(attached_protocol_message.flags)
+          channel.options.set_params(attached_protocol_message.params)
         end
       end
 
@@ -64,6 +66,7 @@ module Ably::Realtime
         end
 
         channel.properties.set_attach_serial(protocol_message.channel_serial)
+        channel.options.set_modes_from_flags(protocol_message.flags)
 
         if protocol_message.has_channel_resumed_flag?
           logger.debug { "ChannelManager: Additional resumed ATTACHED message received for #{channel.state} channel '#{channel.name}'" }
@@ -199,14 +202,21 @@ module Ably::Realtime
       end
 
       def send_attach_protocol_message
-        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Attach, :suspended # move to suspended
+        message_options = {}
+        message_options[:params] = channel.options.params if channel.options.params.any?
+        message_options[:flags] = channel.options.modes_to_flags if channel.options.modes
+        if channel.attach_resume
+          message_options[:flags] = message_options[:flags].to_i | Ably::Models::ProtocolMessage::ATTACH_FLAGS_MAPPING[:resume]
+        end
+
+        send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Attach, :suspended, message_options
       end
 
       def send_detach_protocol_message(previous_state)
         send_state_change_protocol_message Ably::Models::ProtocolMessage::ACTION.Detach, previous_state # return to previous state if failed
       end
 
-      def send_state_change_protocol_message(new_state, state_if_failed)
+      def send_state_change_protocol_message(new_state, state_if_failed, message_options = {})
         state_at_time_of_request = channel.state
         @pending_state_change_timer = EventMachine::Timer.new(realtime_request_timeout) do
           if channel.state == state_at_time_of_request
@@ -227,7 +237,8 @@ module Ably::Realtime
               next unless pending_state_change_timer
               connection.send_protocol_message(
                 action:  new_state.to_i,
-                channel: channel.name
+                channel: channel.name,
+                **message_options.to_h
               )
               resend_if_disconnected_and_connected.call
             end
@@ -237,7 +248,8 @@ module Ably::Realtime
 
         connection.send_protocol_message(
           action:  new_state.to_i,
-          channel: channel.name
+          channel: channel.name,
+          **message_options.to_h
         )
       end
 

data/lib/ably/realtime/channel/channel_state_machine.rb

@@ -42,6 +42,11 @@ module Ably::Realtime
 
       before_transition(to: [:attached]) do |channel, current_transition|
         channel.manager.attached current_transition.metadata.protocol_message
+        channel.attach_resume!
+      end
+
+      before_transition(to: [:detaching, :failed]) do |channel, _current_transition|
+        channel.reset_attach_resume!
       end
 
       after_transition(to: [:detaching]) do |channel, current_transition|

data/lib/ably/realtime/channel.rb

@@ -36,6 +36,7 @@ module Ably
       include Ably::Modules::MessageEmitter
       include Ably::Realtime::Channel::Publisher
       extend Ably::Modules::Enum
+      extend Forwardable
 
       # ChannelState
       # The permited states for this channel
@@ -92,17 +93,25 @@ module Ably
       # @api private
       attr_reader :manager
 
+      # Flag that specifies whether channel is resuming attachment(reattach) or is doing a 'clean attach' RTL4j1
+      # @return [Bolean]
+      # @api private
+      attr_reader :attach_resume
+
+      # ChannelOptions params attrribute (#RTL4k)
+      # return [Hash]
+      def_delegators :options, :params
+
       # Initialize a new Channel object
       #
       # @param  client [Ably::Rest::Client]
       # @param  name [String] The name of the channel
-      # @param  channel_options [Hash]     Channel options, currently reserved for Encryption options
-      # @option channel_options [Hash,Ably::Models::CipherParams]   :cipher   A hash of options or a {Ably::Models::CipherParams} to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of +:cipher+ options
+      # @param  channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
       #
       def initialize(client, name, channel_options = {})
         name = ensure_utf_8(:name, name)
 
-        update_options channel_options
+        @options       = Ably::Models::ChannelOptions(channel_options)
         @client        = client
         @name          = name
         @queue         = []
@@ -112,6 +121,7 @@ module Ably
         @manager       = ChannelManager.new(self, client.connection)
         @push          = PushChannel.new(self)
         @properties    = ChannelProperties.new(self)
+        @attach_resume = false
 
         setup_event_handlers
         setup_presence
@@ -129,23 +139,31 @@ module Ably
       # @return [Ably::Util::SafeDeferrable] Deferrable that supports both success (callback) and failure (errback) callbacks
       #
       # @example
-      #   # Publish a single message
+      #   # Publish a single message form
       #   channel.publish 'click', { x: 1, y: 2 }
       #
-      #   # Publish an array of message Hashes
+      #   # Publish a single message with single Hash form
+      #   message = { name: 'click', data: { x: 1, y: 2 } }
+      #   channel.publish message
+      #
+      #   # Publish an array of message Hashes form
       #   messages = [
-      #     { name: 'click', { x: 1, y: 2 } },
-      #     { name: 'click', { x: 2, y: 3 } }
+      #     { name: 'click', data: { x: 1, y: 2 } },
+      #     { name: 'click', data: { x: 2, y: 3 } }
       #   ]
       #   channel.publish messages
       #
-      #   # Publish an array of Ably::Models::Message objects
+      #   # Publish an array of Ably::Models::Message objects form
       #   messages = [
-      #     Ably::Models::Message(name: 'click', { x: 1, y: 2 })
-      #     Ably::Models::Message(name: 'click', { x: 2, y: 3 })
+      #     Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #     Ably::Models::Message(name: 'click', data: { x: 2, y: 3 })
       #   ]
       #   channel.publish messages
       #
+      #   # Publish an array of Ably::Models::Message objects form
+      #   message = Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #   channel.publish message
+      #
       #   channel.publish('click', 'body') do |message|
       #     puts "#{message.name} event received with #{message.data}"
       #   end
@@ -165,13 +183,7 @@ module Ably
           return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
         end
 
-        messages = if name.kind_of?(Enumerable)
-          name
-        else
-          name = ensure_utf_8(:name, name, allow_nil: true)
-          ensure_supported_payload data
-          [{ name: name, data: data }.merge(attributes)]
-        end
+        messages = build_messages(name, data, attributes) # (RSL1a, RSL1b)
 
         if messages.length > Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE
           error = Ably::Exceptions::InvalidRequest.new("It is not possible to publish more than #{Realtime::Connection::MAX_PROTOCOL_MESSAGE_BATCH_SIZE} messages with a single publish request.")
@@ -309,6 +321,16 @@ module Ably
         )
       end
 
+      # Sets or updates the stored channel options. (#RTL16)
+      # @param channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
+      # @return [Ably::Models::ChannelOptions]
+      def set_options(channel_options)
+        @options = Ably::Models::ChannelOptions(channel_options)
+
+        manager.request_reattach if need_reattach?
+      end
+      alias options= set_options
+
       # @api private
       def set_channel_error_reason(error)
         @error_reason = error
@@ -319,24 +341,32 @@ module Ably
         @error_reason = nil
       end
 
-      # @api private
-      def update_options(channel_options)
-        @options = channel_options.clone.freeze
-      end
-      alias set_options update_options # (RSL7)
-      alias options= update_options
-
       # Used by {Ably::Modules::StateEmitter} to debug state changes
       # @api private
       def logger
         client.logger
       end
 
+      # @api private
+      def attach_resume!
+        @attach_resume = true
+      end
+
+      # @api private
+      def reset_attach_resume!
+        @attach_resume = false
+      end
+
       # As we are using a state machine, do not allow change_state to be used
       # #transition_state_machine must be used instead
       private :change_state
 
+      def need_reattach?
+        !!(attaching? || attached?) && !!(options.modes || options.params)
+      end
+
       private
+
       def setup_event_handlers
         __incoming_msgbus__.subscribe(:message) do |message|
           message.decode(client.encoders, options) do |encode_error, error_message|

data/lib/ably/realtime/channels.rb

@@ -13,7 +13,7 @@ module Ably
       # Return a {Ably::Realtime::Channel} for the given name
       #
       # @param name [String] The name of the channel
-      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      # @param channel_options [Hash, Ably::Models::ChannelOptions] A hash of options or a {Ably::Models::ChannelOptions}
       # @return [Ably::Realtime::Channel}
       #
       def get(*args)

data/lib/ably/rest/channel.rb

@@ -28,21 +28,20 @@ module Ably
       #
       # @param client [Ably::Rest::Client]
       # @param name [String] The name of the channel
-      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
-      # @option channel_options [Hash,Ably::Models::CipherParams]   :cipher   A hash of options or a {Ably::Models::CipherParams} to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of +:cipher+ options
+      # @param channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
       #
       def initialize(client, name, channel_options = {})
         name = (ensure_utf_8 :name, name)
 
-        update_options channel_options
+        @options = Ably::Models::ChannelOptions(channel_options)
         @client  = client
         @name    = name
         @push    = PushChannel.new(self)
       end
 
-      # Publish one or more messages to the channel. Three overloaded forms
+      # Publish one or more messages to the channel. Five overloaded forms
       # @param name [String, Array<Ably::Models::Message|Hash>, Ably::Models::Message, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs, or a single Ably::Model::Message object
-      # @param data [String, ByteArray, Hash, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument, in which case an optional hash of query parameters
+      # @param data [String, Array, Hash, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument, in which case an optional hash of query parameters
       # @param attributes [Hash, nil]   Optional additional message attributes such as :extras, :id, :client_id or :connection_id, applied when name attribute is nil or a string (Deprecated, will be removed in 2.0 in favour of constructing a Message object)
       # @return [Boolean]  true if the message was published, otherwise false
       #
@@ -50,42 +49,33 @@ module Ably
       #   # Publish a single message with (name, data) form
       #   channel.publish 'click', { x: 1, y: 2 }
       #
-      #   # Publish an array of message Hashes
+      #   # Publish a single message with single Hash form
+      #   message = { name: 'click', data: { x: 1, y: 2 } }
+      #   channel.publish message
+      #
+      #   # Publish an array of message Hashes form
       #   messages = [
       #     { name: 'click', data: { x: 1, y: 2 } },
       #     { name: 'click', data: { x: 2, y: 3 } }
       #   ]
       #   channel.publish messages
       #
-      #   # Publish an array of Ably::Models::Message objects
+      #   # Publish an array of Ably::Models::Message objects form
       #   messages = [
-      #     Ably::Models::Message(name: 'click', { x: 1, y: 2 })
-      #     Ably::Models::Message(name: 'click', { x: 2, y: 3 })
+      #     Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #     Ably::Models::Message(name: 'click', data: { x: 2, y: 3 })
       #   ]
       #   channel.publish messages
       #
-      #   # Publish a single Ably::Models::Message object, with a query params
-      #   # specifying quickAck: true
-      #   message = Ably::Models::Message(name: 'click', { x: 1, y: 2 })
-      #   channel.publish message, quickAck: 'true'
+      #   # Publish a single Ably::Models::Message object form
+      #   message = Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #   channel.publish message
       #
-      def publish(first, second = nil, third = {})
-        messages, qs_params = if first.kind_of?(Enumerable)
-          # ([Message], qs_params) form
-          [first, second]
-        elsif first.kind_of?(Ably::Models::Message)
-          # (Message, qs_params) form
-          [[first], second]
-        else
-          # (name, data, attributes) form
-          first = ensure_utf_8(:name, first, allow_nil: true)
-          ensure_supported_payload second
-          # RSL1h - attributes as an extra method parameter is extra-spec but need to
-          # keep it for backcompat until version 2
-          [[{ name: first, data: second }.merge(third)], nil]
-        end
+      def publish(name, data = nil, attributes = {})
+        qs_params = nil
+        qs_params = data if name.kind_of?(Enumerable) || name.kind_of?(Ably::Models::Message)
 
-        messages.map! { |message| Ably::Models::Message(message.dup) }
+        messages = build_messages(name, data, attributes) # (RSL1a, RSL1b)
 
         if messages.sum(&:size) > (max_message_size = client.max_message_size || Ably::Rest::Client::MAX_MESSAGE_SIZE)
           raise Ably::Exceptions::MaxMessageSizeExceeded.new("Maximum message size exceeded #{max_message_size} bytes.")
@@ -163,14 +153,23 @@ module Ably
         @presence ||= Presence.new(client, self)
       end
 
-      # @api private
-      def update_options(channel_options)
-        @options = channel_options.clone.freeze
+      # Sets or updates the stored channel options. (#RSL7)
+      # @param channel_options [Hash, Ably::Models::ChannelOptions]  A hash of options or a {Ably::Models::ChannelOptions}
+      # @return [Ably::Models::ChannelOptions]
+      def set_options(channel_options)
+        @options = Ably::Models::ChannelOptions(channel_options)
+      end
+      alias options= set_options
+
+      # Makes GET request for channel details (#RSL8, #RSL8a)
+      #
+      # @return [Ably::Models::ChannelDetails]
+      def status
+        Ably::Models::ChannelDetails.new(client.get(base_path).body)
       end
-      alias set_options update_options # (RSL7)
-      alias options= update_options
 
       private
+
       def base_path
         "/channels/#{URI.encode_www_form_component(name)}"
       end

data/lib/ably/rest/client.rb

@@ -4,7 +4,7 @@ require 'logger'
 require 'uri'
 
 require 'typhoeus'
-require 'typhoeus/adapters/faraday'
+require 'faraday/typhoeus'
 
 require 'ably/rest/middleware/exceptions'
 
@@ -55,7 +55,7 @@ module Ably
       # @return [Symbol]
       attr_reader :protocol
 
-      # Client agent i.e. `example-gem/1.2.0 ably-ruby/1.1.5 ruby/1.9.3`
+      # Client agent i.e. `example-gem/1.2.0 ably-ruby/1.1.5 ruby/3.1.1`
       # @return [String]
       attr_reader :agent
 
@@ -139,7 +139,7 @@ module Ably
       # @option options [Symbol]                  :protocol            (:msgpack) Protocol used to communicate with Ably, :json and :msgpack currently supported
       # @option options [Boolean]                 :use_binary_protocol (true) When true will use the MessagePack binary protocol, when false it will use JSON encoding. This option will overide :protocol option
       # @option options [Logger::Severity,Symbol] :log_level           (Logger::WARN) Log level for the standard Logger that outputs to STDOUT. Can be set to :fatal (Logger::FATAL), :error (Logger::ERROR), :warn (Logger::WARN), :info (Logger::INFO), :debug (Logger::DEBUG) or :none
-      # @option options [Logger]                  :logger              A custom logger can be used however it must adhere to the Ruby Logger interface, see http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html
+      # @option options [Logger]                  :logger              A custom logger can be used however it must adhere to the Ruby Logger interface, see http://www.ruby-doc.org/stdlib-3.1.1/libdoc/logger/rdoc/Logger.html
       # @option options [String]                  :client_id           client ID identifying this connection to other clients
       # @option options [String]                  :auth_url            a URL to be used to GET or POST a set of token request params, to obtain a signed token request
       # @option options [Hash]                    :auth_headers        a set of application-specific headers to be added to any request made to the +auth_url+
@@ -147,7 +147,7 @@ module Ably
       # @option options [Symbol]                  :auth_method         (:get) HTTP method to use with +auth_url+, must be either +:get+ or +:post+
       # @option options [Proc]                    :auth_callback       when provided, the Proc will be called with the token params hash as the first argument, whenever a new token is required.
       #                                                                The Proc should return a token string, {Ably::Models::TokenDetails} or JSON equivalent, {Ably::Models::TokenRequest} or JSON equivalent
-      # @option options [Boolean]                 :query_time          when true will query the {https://www.ably.io Ably} system for the current time instead of using the local time
+      # @option options [Boolean]                 :query_time          when true will query the {https://www.ably.com Ably} system for the current time instead of using the local time
       # @option options [Hash]                    :default_token_params   convenience to pass in +token_params+ that will be used as a default for all token requests. See {Auth#create_token_request}
       #
       # @option options [Integer]                 :http_open_timeout       (4 seconds) timeout in seconds for opening an HTTP connection for all HTTP requests
@@ -199,10 +199,13 @@ module Ably
         @custom_tls_port     = options.delete(:tls_port)
         @add_request_ids     = options.delete(:add_request_ids)
         @log_retries_as_info = options.delete(:log_retries_as_info)
-        @idempotent_rest_publishing = options.delete(:idempotent_rest_publishing) || Ably.major_minor_version_numeric > 1.1
         @max_message_size    = options.delete(:max_message_size) || MAX_MESSAGE_SIZE
         @max_frame_size      = options.delete(:max_frame_size) || MAX_FRAME_SIZE
 
+        if (@idempotent_rest_publishing = options.delete(:idempotent_rest_publishing)).nil?
+          @idempotent_rest_publishing = Ably::PROTOCOL_VERSION.to_f > 1.1
+        end
+
         if options[:fallback_hosts_use_default] && options[:fallback_hosts]
           raise ArgumentError, "fallback_hosts_use_default cannot be set to try when fallback_hosts is also provided"
         end

data/lib/ably/rest/middleware/encoder.rb

@@ -5,7 +5,7 @@ module Ably
   module Rest
     module Middleware
       # Encode the body of the message according to the mime type
-      class Encoder < ::Faraday::Response::Middleware
+      class Encoder < Faraday::Middleware
         CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
 
         def call(env)

data/lib/ably/rest/middleware/exceptions.rb

@@ -6,7 +6,7 @@ module Ably
     module Middleware
       # HTTP exceptions raised by Ably due to an error status code
       # Ably returns JSON/Msgpack error codes and messages so include this if possible in the exception messages
-      class Exceptions < Faraday::Response::Middleware
+      class Exceptions < Faraday::Middleware
         def on_complete(env)
           if env.status >= 400
             error_status_code = env.status