ably 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85089829c198d66df277d8b4c675497c3632ed88
-  data.tar.gz: c6a05542c8c35adce99763b651290cb3e5fbf472
+  metadata.gz: deb69100f880e16767da5cad8178d7ed8ec8202a
+  data.tar.gz: f9c6e5b632f1992657178b118c80e4b828de051c
 SHA512:
-  metadata.gz: b13264f6a68b29dcb4ccd0f7bc87af4df57cfb9d685bd7f87ebda5bef3c7679a437dd2ee5f967e0eb2385ab3659588784b32ae6f39520931723e1407d9471b2a
-  data.tar.gz: 5d5f15f00cce1ddced2188d2e3c5a8c3f1b36a719d281b54738eded944db6127e5546df65048118935d35ee6ea8b588ceab2cadb4f8ac66d0998a609e5aaba54
+  metadata.gz: d725527fdd9e8c517233bebdc87f3bd8775234c1cbf9f44a8ff7ce8c28de744fe4037f67fbdae26caae83428c7785116056f4289c60c342d9b7df7a533913b07
+  data.tar.gz: d2b8f496227bf4122e167426380213de6473f89c02385eadabd82d268fbe01b347fd9cf9b973f1dbce86b2b2e8beab0670221d8657367cef1ada68783367673e

data/README.md

@@ -187,7 +187,7 @@ token_details = client.auth.request_token
 token_details.token # => "xVLyHw.CLchevH3hF....MDh9ZC_Q"
 client = Ably::Rest.new(token: token_details.token)
 
-token = client.auth.create_token_request(token_params: { ttl: 3600 })
+token = client.auth.create_token_request(ttl: 3600)
 # => {"id"=>...,
 #     "clientId"=>nil,
 #     "ttl"=>3600,

data/Rakefile

@@ -16,7 +16,7 @@ begin
   namespace :doc do
     desc 'Generate Markdown Specification from the RSpec public API tests'
     task :spec do
-      ENV['TEST_LIMIT_PROTOCOLS'] = JSON.dump({ msgpack: 'JSON and MsgPack' })
+      ENV['PROTOCOL'] = 'json'
 
       rspec_task.rspec_opts = %w(
         --require ./spec/support/markdown_spec_formatter

data/lib/ably/auth.rb

@@ -43,11 +43,11 @@ module Ably
     # Creates an Auth object
     #
     # @param [Ably::Rest::Client] client  {Ably::Rest::Client} this Auth object uses
-    # @param [Hash] auth_options the authentication options used as a default future token requests
     # @param [Hash] token_params the token params used as a default for future token requests
+    # @param [Hash] auth_options the authentication options used as a default future token requests
     # @option (see #request_token)
     #
-    def initialize(client, auth_options, token_params)
+    def initialize(client, token_params, auth_options)
       unless auth_options.kind_of?(Hash)
         raise ArgumentError, 'Expected auth_options to be a Hash'
       end
@@ -87,8 +87,8 @@ module Ably
     #
     # In the event that a new token request is made, the provided options are used.
     #
-    # @param [Hash] auth_options the authentication options used for future token requests
     # @param [Hash] token_params the token params used for future token requests
+    # @param [Hash] auth_options the authentication options used for future token requests
     # @option auth_options [Boolean]   :force   obtains a new token even if the current token is valid
     # @option (see #request_token)
     #
@@ -100,12 +100,12 @@ module Ably
     #    token_details = client.auth.authorise
     #
     #    # will use token request from block to authorise if not already authorised
-    #    token_details = client.auth.authorise auth_callback: Proc.new do
+    #    token_details = client.auth.authorise {}, auth_callback: Proc.new do
     #      # create token_request object
     #      token_request
     #    end
     #
-    def authorise(auth_options = {}, token_params = {})
+    def authorise(token_params = {}, auth_options = {})
       ensure_valid_auth_attributes auth_options
 
       auth_options = auth_options.clone
@@ -120,7 +120,7 @@ module Ably
       token_params = (auth_options.delete(:token_params) || {}).merge(token_params)
       @token_params = @token_params.merge(token_params) # update defaults
 
-      @current_token_details = request_token(auth_options, token_params)
+      @current_token_details = request_token(token_params, auth_options)
     end
 
     # Request a {Ably::Models::TokenDetails} which can be used to make authenticated token based requests
@@ -143,15 +143,15 @@ module Ably
     #    token_details = client.auth.request_token
     #
     #    # token request with token params
-    #    client.auth.request_token token_params: { ttl: 1.hour }
+    #    client.auth.request_token ttl: 1.hour
     #
     #    # token request using auth block
-    #    token_details = client.auth.request_token auth_callback: Proc.new do
+    #    token_details = client.auth.request_token {}, auth_callback: Proc.new do
     #      # create token_request object
     #      token_request
     #    end
     #
-    def request_token(auth_options = {}, token_params = {})
+    def request_token(token_params = {}, auth_options = {})
       ensure_valid_auth_attributes auth_options
 
       token_params = (auth_options[:token_params] || {}).merge(token_params)
@@ -163,7 +163,7 @@ module Ably
       elsif auth_url = auth_options.delete(:auth_url)
         token_request_from_auth_url(auth_url, auth_options)
       else
-        create_token_request(auth_options, token_params)
+        create_token_request(token_params, auth_options)
       end
 
       case token_request
@@ -186,12 +186,6 @@ module Ably
 
     # Creates and signs a token request that can then subsequently be used by any client to request a token
     #
-    # @param [Hash] auth_options the authentication options for the token request
-    # @option auth_options [String]  :key           API key comprising the key name and key secret in a single string
-    # @option auth_options [String]  :client_id     client ID identifying this connection to other clients (will use +client_id+ specified when library was instanced if provided)
-    # @option auth_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 auth_options [Hash]    :token_params   convenience to pass in +token_params+ within the +auth_options+ argument, this helps avoid the following +authorise({key: key}, {ttl: 23})+ by allowing +authorise(key:key,token_params:{ttl:23})+
-    #
     # @param [Hash] token_params the token params used in the token request
     # @option token_params [String]  :client_id     A client ID to associate with this token. The generated token may be used to authenticate as this +client_id+
     # @option token_params [Integer] :ttl           validity time in seconds for the requested {Ably::Models::TokenDetails}.  Limits may apply, see {https://www.ably.io/documentation/other/authentication}
@@ -199,10 +193,16 @@ module Ably
     # @option token_params [Time]    :timestamp     the time of the request
     # @option token_params [String]  :nonce         an unquoted, unescaped random string of at least 16 characters
     #
+    # @param [Hash] auth_options the authentication options for the token request
+    # @option auth_options [String]  :key           API key comprising the key name and key secret in a single string
+    # @option auth_options [String]  :client_id     client ID identifying this connection to other clients (will use +client_id+ specified when library was instanced if provided)
+    # @option auth_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 auth_options [Hash]    :token_params  convenience to pass in +token_params+ within the +auth_options+ argument, especially useful when setting default token_params in the client constructor
+    #
     # @return [Models::TokenRequest]
     #
     # @example
-    #    client.auth.create_token_request(id: 'asd.asd', token_params: { ttl: 3600 })
+    #    client.auth.create_token_request({ ttl: 3600 }, { id: 'asd.asd' })
     #    #<Ably::Models::TokenRequest:0x007fd5d919df78
     #    #  @hash={
     #    #   :id=>"asds.adsa",
@@ -214,7 +214,7 @@ module Ably
     #    #   :mac=>"881oZHeFo6oMim7....uE56a8gUxHw="
     #    #  }
     #    #>>
-    def create_token_request(auth_options = {}, token_params = {})
+    def create_token_request(token_params = {}, auth_options = {})
       ensure_valid_auth_attributes auth_options
 
       auth_options = auth_options.clone
@@ -401,7 +401,11 @@ module Ably
 
     # Returns the current token if it exists or authorises and retrieves a token
     def token_auth_string
-      if token
+      # If a TokenDetails object has been issued by this library
+      # then that Token will take precedence
+      if @current_token_details
+        authorise.token
+      elsif token # token string was configured in the options
         token
       else
         authorise.token

data/lib/ably/models/token_details.rb

@@ -34,7 +34,7 @@ module Ably::Models
     # @param attributes
     # @option attributes [String]       :token      token used to authenticate requests
     # @option attributes [String]       :key_name   API key name used to create this token
-    # @option attributes [Time,Integer] :issued  Time the token was issued as Time or Integer in milliseconds
+    # @option attributes [Time,Integer] :issued     Time the token was issued as Time or Integer in milliseconds
     # @option attributes [Time,Integer] :expires    Time the token expires as Time or Integer in milliseconds
     # @option attributes [String]       :capability JSON stringified capabilities assigned to this token
     # @option attributes [String]       :client_id  client ID assigned to this token
@@ -52,31 +52,31 @@ module Ably::Models
     # @!attribute [r] token
     # @return [String] Token used to authenticate requests
     def token
-      hash.fetch(:token)
+      hash[: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.fetch(:key_name)
+      hash[:key_name]
     end
 
     # @!attribute [r] issued
     # @return [Time] Time the token was issued
     def issued
-      as_time_from_epoch(hash.fetch(:issued), granularity: :ms)
+      as_time_from_epoch(hash[:issued], granularity: :ms, allow_nil: :true)
     end
 
     # @!attribute [r] expires
     # @return [Time] Time the token expires
     def expires
-      as_time_from_epoch(hash.fetch(:expires), granularity: :ms)
+      as_time_from_epoch(hash[:expires], granularity: :ms, allow_nil: :true)
     end
 
     # @!attribute [r] capability
     # @return [Hash] Capabilities assigned to this token
     def capability
-      JSON.parse(hash.fetch(:capability))
+      JSON.parse(hash.fetch(:capability)) if hash.fetch(:capability)
     end
 
     # @!attribute [r] client_id
@@ -86,9 +86,11 @@ module Ably::Models
     end
 
     # 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
     #
     # @return [Boolean]
     def expired?
+      return false if !expires
       expires < Time.now + TOKEN_EXPIRY_BUFFER
     end
 

data/lib/ably/modules/conversions.rb

@@ -6,6 +6,8 @@ module Ably::Modules
 
     private
     def as_since_epoch(time, options = {})
+      return nil if options[:allow_nil] && !time
+
       granularity = options.fetch(:granularity, :ms)
 
       case time
@@ -19,6 +21,8 @@ module Ably::Modules
     end
 
     def as_time_from_epoch(time, options = {})
+      return nil if options[:allow_nil] && !time
+
       granularity = options.fetch(:granularity, :ms)
 
       case time

data/lib/ably/modules/state_emitter.rb

@@ -142,7 +142,7 @@ module Ably::Modules
     def deferrable_for_state_change_to(target_state)
       Ably::Util::SafeDeferrable.new(logger).tap do |deferrable|
         fail_proc = Proc.new do |state_change|
-          deferrable.fail self, state_change.reason
+          deferrable.fail state_change.reason
         end
         once_or_if(target_state, else: fail_proc) do
           yield self if block_given?

data/lib/ably/modules/uses_state_machine.rb

@@ -86,13 +86,20 @@ module Ably::Modules
     module ClassMethods
       def emits_klass
         @emits_klass ||= if @emits_klass_name
-          Object.const_get @emits_klass_name
+          get_const(@emits_klass_name)
         end
       end
 
       def ensure_state_machine_emits(klass)
         @emits_klass_name = klass
       end
+
+      def get_const(klass_name)
+        klass_names = klass_name.split('::')
+        klass_names.inject(Kernel) do |klass, name|
+          klass.const_get(name)
+        end
+      end
     end
   end
 end

data/lib/ably/realtime/auth.rb

@@ -65,9 +65,9 @@ module Ably
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def authorise(auth_options = {}, token_params = {}, &success_callback)
+      def authorise(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          auth_sync.authorise(auth_options, token_params)
+          auth_sync.authorise(token_params, auth_options)
         end
       end
 
@@ -76,8 +76,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenDetails]
       #
-      def authorise_sync(auth_options = {}, token_params = {})
-        auth_sync.authorise(auth_options, token_params)
+      def authorise_sync(token_params = {}, auth_options = {})
+        auth_sync.authorise(token_params, auth_options)
       end
 
       # def_delegator :auth_sync, :request_token, :request_token_sync
@@ -100,9 +100,9 @@ module Ably
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def request_token(auth_options = {}, token_params = {}, &success_callback)
+      def request_token(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          request_token_sync(auth_options, token_params)
+          request_token_sync(token_params, auth_options)
         end
       end
 
@@ -111,8 +111,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenDetails]
       #
-      def request_token_sync(auth_options = {}, token_params = {})
-        auth_sync.request_token(auth_options, token_params)
+      def request_token_sync(token_params = {}, auth_options = {})
+        auth_sync.request_token(token_params, auth_options)
       end
 
       # Creates and signs a token request that can then subsequently be used by any client to request a token
@@ -124,12 +124,12 @@ module Ably
       # @yield [Models::TokenRequest]
       #
       # @example
-      #   client.auth.create_token_request(id: 'asd.asd', ttl: 3600) do |token_request|
+      #   client.auth.create_token_request({ ttl: 3600 }, id: 'asd.asd') do |token_request|
       #     token_request #=> Ably::Models::TokenRequest
       #   end
-      def create_token_request(auth_options = {}, token_params = {}, &success_callback)
+      def create_token_request(token_params = {}, auth_options = {}, &success_callback)
         async_wrap(success_callback) do
-          create_token_request_sync(auth_options, token_params)
+          create_token_request_sync(token_params, auth_options)
         end
       end
 
@@ -138,8 +138,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenRequest]
       #
-      def create_token_request_sync(auth_options = {}, token_params = {})
-        auth_sync.create_token_request(auth_options, token_params)
+      def create_token_request_sync(token_params = {}, auth_options = {})
+        auth_sync.create_token_request(token_params, auth_options)
       end
 
       # Auth header string used in HTTP requests to Ably

data/lib/ably/realtime/channel.rb

@@ -134,7 +134,7 @@ module Ably
       #     puts "#{message.name} event received with #{message.data}"
       #   end
       #
-      #   channel.publish('click', 'body').errback do |message, error|
+      #   channel.publish('click', 'body').errback do |error, message|
       #     puts "#{message.name} was not received, error #{error.message}"
       #   end
       #
@@ -155,7 +155,7 @@ module Ably
         end
 
         queue_messages(messages).tap do |deferrable|
-          deferrable.callback &success_block if block_given?
+          deferrable.callback(&success_block) if block_given?
         end
       end
 

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

@@ -77,10 +77,10 @@ module Ably::Realtime
       def nack_messages(protocol_message, error)
         (protocol_message.messages + protocol_message.presence).each do |message|
           logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
-          message.fail message, error
+          message.fail error
         end
         logger.debug "Calling NACK failure callbacks for #{protocol_message.class.name} - #{protocol_message.to_json}"
-        protocol_message.fail protocol_message, error
+        protocol_message.fail error
       end
 
       def drop_pending_queue_from_ack(ack_protocol_message)
@@ -146,7 +146,7 @@ module Ably::Realtime
         end
 
         connection.unsafe_on(:failed) do |error|
-          if can_transition_to?(:failed)
+          if can_transition_to?(:failed) && !channel.detached?
             channel.transition_state_machine :failed, reason: Ably::Exceptions::ConnectionFailed.new('Connection failed', nil, 80002, error)
           end
         end

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

@@ -22,8 +22,9 @@ module Ably::Realtime
 
       transition :from => :initialized,  :to => [:attaching]
       transition :from => :attaching,    :to => [:attached, :detaching, :failed]
-      transition :from => :attached,     :to => [:detaching, :failed]
+      transition :from => :attached,     :to => [:detaching, :detached, :failed]
       transition :from => :detaching,    :to => [:detached, :attaching, :failed]
+      transition :from => :detached,     :to => [:attaching, :attached, :failed]
       transition :from => :failed,       :to => [:attaching]
 
       after_transition do |channel, transition|

data/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -68,7 +68,13 @@ module Ably::Realtime
 
           when ACTION.Connect
           when ACTION.Connected
-            connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message unless connection.connected?
+            if connection.disconnected? || connection.closing? || connection.closed? || connection.failed?
+              logger.debug "Incoming CONNECTED ProtocolMessage discarded as connection has moved on and is in state: #{connection.state}"
+            elsif connection.connected?
+              logger.error "CONNECTED ProtocolMessage should not have been received when the connection is in the CONNECTED state"
+            else
+              connection.transition_state_machine :connected, reason: protocol_message.error, protocol_message: protocol_message
+            end
 
           when ACTION.Disconnect, ACTION.Disconnected
             connection.transition_state_machine :disconnected, reason: protocol_message.error unless connection.disconnected?
@@ -163,17 +169,17 @@ module Ably::Realtime
       def nack_messages(messages, protocol_message)
         messages.each do |message|
           logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
-          message.fail message, protocol_message.error
+          message.fail protocol_message.error
         end
       end
 
       def drop_pending_queue_from_ack(ack_protocol_message)
         message_serial_up_to = ack_protocol_message.message_serial + ack_protocol_message.count - 1
-        connection.__pending_message_ack_queue__.drop_while do |protocol_message|
-          if protocol_message.message_serial <= message_serial_up_to
-            yield protocol_message
-            true
-          end
+
+        while !connection.__pending_message_ack_queue__.empty?
+          next_message = connection.__pending_message_ack_queue__.first
+          return if next_message.message_serial > message_serial_up_to
+          yield connection.__pending_message_ack_queue__.shift
         end
       end
 

data/lib/ably/realtime/client/outgoing_message_dispatcher.rb

@@ -44,6 +44,12 @@ module Ably::Realtime
 
         non_blocking_loop_while(condition) do
           protocol_message = outgoing_queue.shift
+
+          if (!connection.transport)
+            protocol_message.fail Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, 80003)
+            next
+          end
+
           current_transport_outgoing_message_bus.publish :protocol_message, protocol_message
 
           if protocol_message.ack_required?

data/lib/ably/realtime/connection.rb

@@ -119,7 +119,7 @@ module Ably
       # the failed state. Once closed, the library will not attempt to re-establish the
       # connection without a call to {Connection#connect}.
       #
-      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Closed state
+      # @yield block is called as soon as this connection is in the Closed state
       #
       # @return [EventMachine::Deferrable]
       #
@@ -134,7 +134,7 @@ module Ably
       # Causes the library to attempt connection.  If it was previously explicitly
       # closed by the user, or was closed as a result of an unrecoverable error, a new connection will be opened.
       #
-      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Connected state
+      # @yield block is called as soon as this connection is in the Connected state
       #
       # @return [EventMachine::Deferrable]
       #
@@ -190,7 +190,7 @@ module Ably
           EventMachine::HttpRequest.new(url).get.tap do |http|
             http.errback do
               yield false if block_given?
-              deferrable.fail "Unable to connect to #{url}"
+              deferrable.fail Ably::Exceptions::ConnectionFailed.new("Unable to connect to #{url}", nil, 80000)
             end
             http.callback do
               EventMachine.next_tick do
@@ -199,7 +199,7 @@ module Ably
                 if result
                   deferrable.succeed
                 else
-                  deferrable.fail "Unexpected response from #{url} (#{http.response_header.status})"
+                  deferrable.fail Ably::Exceptions::ConnectionFailed.new("Unexpected response from #{url} (#{http.response_header.status})", 400, 40000)
                 end
               end
             end