ably 0.8.15 → 1.0.0

data/lib/ably/models/auth_details.rb

@@ -0,0 +1,42 @@
+module Ably::Models
+  # Convert auth details attributes to a {AuthDetails} object
+  #
+  # @param attributes (see #initialize)
+  #
+  # @return [AuthDetails]
+  def self.AuthDetails(attributes)
+    case attributes
+    when AuthDetails
+      return attributes
+    else
+      AuthDetails.new(attributes || {})
+    end
+  end
+
+  # AuthDetails are included in an +AUTH+ {Ably::Models::ProtocolMessage#auth} attribute
+  # to provide the realtime service with new token authentication details following a re-auth workflow
+  #
+  class AuthDetails
+    include Ably::Modules::ModelCommon
+
+    # @param attributes [Hash]
+    # @option attributes [String]    :access_token     token string
+    #
+    def initialize(attributes = {})
+      @hash_object = IdiomaticRubyWrapper(attributes.clone)
+      self.attributes.freeze
+    end
+
+    %w(access_token).each do |attribute|
+      define_method attribute do
+        attributes[attribute.to_sym]
+      end
+    end
+
+    # @!attribute [r] attributes
+    # @return [Hash] Access the token details Hash object ruby'fied to use symbolized keys
+    def attributes
+      @hash_object
+    end
+  end
+end

data/lib/ably/models/channel_state_change.rb

@@ -8,31 +8,45 @@ module Ably::Models
   #   @return [Connection::STATE] Previous channel state
   # @!attribute [r] reason
   #   @return [Ably::Models::ErrorInfo] Object describing the reason for a state change when not initiated by the consumer of the client library
+  # @!attribute [r] resumed
+  #   @return [Boolean] True when a channel is resumed, false when continuity on the channel is no longer provided indicating that the developer is now responsible for recovering lost messages on this channel through other means, such as using the hisory API
   #
   class ChannelStateChange
     include Ably::Modules::ModelCommon
 
     def initialize(hash_object)
-      unless (hash_object.keys - [:current, :previous, :reason, :protocol_message]).empty?
-        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :reason'
+      unless (hash_object.keys - [:current, :previous, :event, :reason, :resumed, :protocol_message]).empty?
+        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :event, :reason, :resumed'
       end
 
       @hash_object = {
         current: hash_object.fetch(:current),
         previous: hash_object.fetch(:previous),
+        event: hash_object[:event],
         reason: hash_object[:reason],
-        protocol_message: hash_object[:protocol_message]
+        protocol_message: hash_object[:protocol_message],
+        resumed: hash_object[:resumed]
       }
     rescue KeyError => e
       raise ArgumentError, e
     end
 
-    %w(current previous reason protocol_message).each do |attribute|
+    %w(current previous event reason).each do |attribute|
       define_method attribute do
         @hash_object[attribute.to_sym]
       end
     end
 
+    def resumed
+      !!@hash_object[:resumed]
+    end
+    alias_method :resumed?, :resumed
+
+    # @api private
+    def protocol_message
+      @hash_object[:protocol_message]
+    end
+
     def to_s
       "ChannelStateChange: current state #{current}, previous state #{previous}"
     end

data/lib/ably/models/connection_details.rb

@@ -27,18 +27,21 @@ module Ably::Models
     # @option attributes [Integer]   :max_message_size      maximum individual message size in bytes
     # @option attributes [Integer]   :max_frame_size        maximum size for a single frame of data sent to Ably. This restriction applies to a {Ably::Models::ProtocolMessage} sent over a realtime connection, or the total body size for a REST request
     # @option attributes [Integer]   :max_inbound_rate      maximum allowable number of requests per second from a client
+    # @option attributes [Integer]   :max_idle_interval     is the maximum length of time in seconds that the server will allow no activity to occur in the server->client direction. After such a period of inactivity, the server will send a @HEARTBEAT@ or transport-level ping to the client. If the value is 0, the server will allow arbitrarily-long levels of inactivity.
     # @option attributes [Integer]   :connection_state_ttl  duration in seconds that Ably will persist the connection state when a Realtime client is abruptly disconnected
     # @option attributes [String]    :server_id             unique identifier of the Ably server where the connection is established
     #
     def initialize(attributes = {})
       @hash_object = IdiomaticRubyWrapper(attributes.clone)
-      if self.attributes[:connection_state_ttl]
-        self.attributes[:connection_state_ttl] = (self.attributes[:connection_state_ttl].to_f / 1000).round
+      [:connection_state_ttl, :max_idle_interval].each do |duration_field|
+        if self.attributes[duration_field]
+          self.attributes[duration_field] = (self.attributes[duration_field].to_f / 1000).round
+        end
       end
       self.attributes.freeze
     end
 
-    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl server_id).each do |attribute|
+    %w(client_id connection_key max_message_size max_frame_size max_inbound_rate connection_state_ttl max_idle_interval server_id).each do |attribute|
       define_method attribute do
         attributes[attribute.to_sym]
       end

data/lib/ably/models/connection_state_change.rb

@@ -15,13 +15,14 @@ module Ably::Models
     include Ably::Modules::ModelCommon
 
     def initialize(hash_object)
-      unless (hash_object.keys - [:current, :previous, :retry_in, :reason, :protocol_message]).empty?
-        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :retry_in, :reason'
+      unless (hash_object.keys - [:current, :previous, :event, :retry_in, :reason, :protocol_message]).empty?
+        raise ArgumentError, 'Invalid attributes, expecting :current, :previous, :event, :retry_in, :reason'
       end
 
       @hash_object = {
         current: hash_object.fetch(:current),
         previous: hash_object.fetch(:previous),
+        event: hash_object[:event],
         retry_in: hash_object[:retry_in],
         reason: hash_object[:reason],
         protocol_message: hash_object[:protocol_message]
@@ -30,7 +31,7 @@ module Ably::Models
       raise ArgumentError, e
     end
 
-    %w(current previous retry_in reason protocol_message).each do |attribute|
+    %w(current previous event retry_in reason protocol_message).each do |attribute|
       define_method attribute do
         @hash_object[attribute.to_sym]
       end

data/lib/ably/models/error_info.rb

@@ -11,7 +11,7 @@ module Ably::Models
   # @!attribute [r] attributes
   #   @return [Hash] Access the protocol message Hash object ruby'fied to use symbolized keys
   #
-  class ErrorInfo
+  class ErrorInfo < Ably::Exceptions::BaseAblyException
     include Ably::Modules::ModelCommon
 
     def initialize(hash_object)

data/lib/ably/models/message.rb

@@ -1,3 +1,5 @@
+require 'ably/models/message_encoders/base'
+
 module Ably::Models
   # Convert messsage argument to a {Message} object and associate with a protocol message if provided
   #
@@ -43,6 +45,9 @@ module Ably::Models
     include Ably::Modules::ModelCommon
     include Ably::Modules::SafeDeferrable if defined?(Ably::Realtime)
 
+    # Statically register a default set of encoders for this class
+    Ably::Models::MessageEncoders.register_default_encoders self
+
     # {Message} initializer
     #
     # @param  attributes [Hash]             object with the underlying message detail key value attributes
@@ -119,6 +124,17 @@ module Ably::Models
       @protocol_message
     end
 
+    # Contains any arbitrary key value pairs which may also contain other primitive JSON types, JSON-encodable objects or JSON-encodable arrays.
+    # The extras field is provided to contain message metadata and/or ancillary payloads in support of specific functionality, e.g. push
+    # @api private
+    def extras
+      attributes[:extras].tap do |val|
+        unless val.kind_of?(IdiomaticRubyWrapper) || val.kind_of?(Array) || val.kind_of?(Hash) || val.nil?
+          raise ArgumentError, "extras contains an unsupported type #{val.class}"
+        end
+      end
+    end
+
     private
     def raw_hash_object
       @raw_hash_object
@@ -129,7 +145,7 @@ module Ably::Models
     end
 
     def set_attributes_object(new_attributes)
-      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data])
+      @attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data, :extras])
     end
 
     def logger

data/lib/ably/models/message_encoders/base.rb

@@ -7,98 +7,119 @@ require 'ably/modules/conversions'
 # of the message is defined as 'json'.
 # Encrypted messages are encoded & decoded by the Cipher encoder.
 #
-module Ably::Models::MessageEncoders
-  extend Ably::Modules::Conversions
+module Ably
+  module Models
+    module MessageEncoders
+      extend Ably::Modules::Conversions
 
-  # Base interface for an Ably Encoder
-  #
-  class Base
-    attr_reader :client
+      # Base interface for an Ably Encoder
+      #
+      class Base
+        attr_reader :client, :options
 
-    def initialize(client)
-      @client = client
-    end
+        def initialize(client, options = {})
+          @client = client
+          @options = options
+        end
 
-    # #encode is called once before a message is sent to Ably
-    #
-    # It is the responsibility of the #encode method to detect the intended encoding and modify the :data & :encoding properties of the message object.
-    #
-    # @param [Hash] message          the message as a Hash object received directly from Ably.
-    #                                The message contains properties :name, :data, :encoding, :timestamp, and optionally :id and :client_id.
-    #                                This #encode method should modify the message Hash if any encoding action is to be taken
-    # @param [Hash] channel_options  the options used to initialize the channel that this message was received on
-    #
-    # @return [void]
-    def encode(message, channel_options)
-      raise "Not yet implemented"
-    end
+        # #encode is called once before a message is sent to Ably
+        #
+        # It is the responsibility of the #encode method to detect the intended encoding and modify the :data & :encoding properties of the message object.
+        #
+        # @param [Hash] message          the message as a Hash object received directly from Ably.
+        #                                The message contains properties :name, :data, :encoding, :timestamp, and optionally :id and :client_id.
+        #                                This #encode method should modify the message Hash if any encoding action is to be taken
+        # @param [Hash] channel_options  the options used to initialize the channel that this message was received on
+        #
+        # @return [void]
+        def encode(message, channel_options)
+          raise "Not yet implemented"
+        end
 
-    # #decode is called once for every encoding step
-    # i.e. if message encoding arrives with 'utf-8/cipher+aes-128-cbc/base64'
-    #      the decoder will call #decode once for each encoding part such as 'base64', then 'cipher+aes-128-cbc', and finally 'utf-8'
-    #
-    # It is the responsibility of the #decode method to detect the current encoding part and modify the :data & :encoding properties of the message object.
-    #
-    # @param [Hash] message          the message as a Hash object received directly from Ably.
-    #                                The message contains properties :name, :data, :encoding, :timestamp, and optionally :id and :client_id.
-    #                                This #encode method should modify the message Hash if any decoding action is to be taken
-    # @param [Hash] channel_options  the options used to initialize the channel that this message was received on
-    #
-    # @return [void]
-    def decode(message, channel_options)
-      raise "Not yet implemented"
-    end
+        # #decode is called once for every encoding step
+        # i.e. if message encoding arrives with 'utf-8/cipher+aes-128-cbc/base64'
+        #      the decoder will call #decode once for each encoding part such as 'base64', then 'cipher+aes-128-cbc', and finally 'utf-8'
+        #
+        # It is the responsibility of the #decode method to detect the current encoding part and modify the :data & :encoding properties of the message object.
+        #
+        # @param [Hash] message          the message as a Hash object received directly from Ably.
+        #                                The message contains properties :name, :data, :encoding, :timestamp, and optionally :id and :client_id.
+        #                                This #encode method should modify the message Hash if any decoding action is to be taken
+        # @param [Hash] channel_options  the options used to initialize the channel that this message was received on
+        #
+        # @return [void]
+        def decode(message, channel_options)
+          raise "Not yet implemented"
+        end
 
-    # Add encoding to the message Hash.
-    # Ensures that encoding delimeter is used where required i.e utf-8/cipher+aes-128-cbc/base64
-    #
-    # @param [Hash]   message   the message as a Hash object received directly from Ably.
-    # @param [String] encoding  encoding to add to the current encoding
-    #
-    # @return [void]
-    def add_encoding_to_message(encoding, message)
-      message[:encoding] = [message[:encoding], encoding].compact.join('/')
-    end
+        # Add encoding to the message Hash.
+        # Ensures that encoding delimeter is used where required i.e utf-8/cipher+aes-128-cbc/base64
+        #
+        # @param [Hash]   message   the message as a Hash object received directly from Ably.
+        # @param [String] encoding  encoding to add to the current encoding
+        #
+        # @return [void]
+        def add_encoding_to_message(encoding, message)
+          message[:encoding] = [message[:encoding], encoding].compact.join('/')
+        end
 
-    # Returns the right most encoding form a meessage encoding, and nil if none exists
-    # i.e. current_encoding_part('utf-8/cipher+aes-128-cbc/base64') => 'base64'
-    #
-    # @return [String,nil]
-    def current_encoding_part(message)
-      if message[:encoding]
-        message[:encoding].split('/')[-1]
+        # Returns the right most encoding form a meessage encoding, and nil if none exists
+        # i.e. current_encoding_part('utf-8/cipher+aes-128-cbc/base64') => 'base64'
+        #
+        # @return [String,nil]
+        def current_encoding_part(message)
+          if message[:encoding]
+            message[:encoding].split('/')[-1]
+          end
+        end
+
+        # Strip the current encoding part within the message Hash.
+        #
+        # For example, calling this method on an :encoding value of 'utf-8/cipher+aes-128-cbc/base64' would update the attribute
+        # :encoding to 'utf-8/cipher+aes-128-cbc'
+        #
+        # @param [Hash]   message   the message as a Hash object received directly from Ably.
+        #
+        # @return [void]
+        def strip_current_encoding_part(message)
+          raise "Cannot strip encoding when there is no encoding for this message" unless message[:encoding]
+          message[:encoding] = message[:encoding].split('/')[0...-1].join('/')
+          message[:encoding] = nil if message[:encoding].empty?
+        end
+
+        # True of the message data payload is empty
+        #
+        # @param [Hash]   message   the message as a Hash object received directly from Ably.
+        #
+        # @return [Boolean]
+        def is_empty?(message)
+          message[:data].nil? || message[:data] == ''
+        end
       end
-    end
 
-    # Strip the current encoding part within the message Hash.
-    #
-    # For example, calling this method on an :encoding value of 'utf-8/cipher+aes-128-cbc/base64' would update the attribute
-    # :encoding to 'utf-8/cipher+aes-128-cbc'
-    #
-    # @param [Hash]   message   the message as a Hash object received directly from Ably.
-    #
-    # @return [void]
-    def strip_current_encoding_part(message)
-      raise "Cannot strip encoding when there is no encoding for this message" unless message[:encoding]
-      message[:encoding] = message[:encoding].split('/')[0...-1].join('/')
-      message[:encoding] = nil if message[:encoding].empty?
-    end
+      # @api private
+      def self.register_default_encoders(client, options = {})
+        binary_protocol = !!options[:binary_protocol]
+        client.register_encoder Ably::Models::MessageEncoders::Utf8
+        client.register_encoder Ably::Models::MessageEncoders::Json
+        client.register_encoder Ably::Models::MessageEncoders::Cipher
+        client.register_encoder Ably::Models::MessageEncoders::Base64, binary_protocol: binary_protocol
+      end
 
-    # True of the message data payload is empty
-    #
-    # @param [Hash]   message   the message as a Hash object received directly from Ably.
-    #
-    # @return [Boolean]
-    def is_empty?(message)
-      message[:data].nil? || message[:data] == ''
-    end
-  end
+      # @api private
+      def self.encoder_from(encoder, options)
+        encoder_klass = if encoder.kind_of?(String)
+          encoder.split('::').inject(Kernel) do |base, klass_name|
+            base.public_send(:const_get, klass_name)
+          end
+        else
+          encoder
+        end
 
-  def self.register_default_encoders(client)
-    client.register_encoder Ably::Models::MessageEncoders::Utf8
-    client.register_encoder Ably::Models::MessageEncoders::Json
-    client.register_encoder Ably::Models::MessageEncoders::Cipher
-    client.register_encoder Ably::Models::MessageEncoders::Base64
+        raise "Encoder must inherit from `Ably::Models::MessageEncoders::Base`" unless encoder_klass.ancestors.include?(Ably::Models::MessageEncoders::Base)
+        encoder_klass.new(self, options)
+      end
+    end
   end
 end
 

data/lib/ably/models/message_encoders/base64.rb

@@ -34,7 +34,7 @@ module Ably::Models::MessageEncoders
     end
 
     def transport_protocol_text?
-      !client.protocol_binary?
+      !options[:binary_protocol]
     end
   end
 end

data/lib/ably/models/presence_message.rb

@@ -52,6 +52,9 @@ module Ably::Models
       :update
     )
 
+    # Statically register a default set of encoders for this class
+    Ably::Models::MessageEncoders.register_default_encoders self
+
     # {PresenceMessage} initializer
     #
     # @param  attributes  [Hash]            object with the underlying presence message key value attributes
@@ -120,7 +123,6 @@ module Ably::Models
       end.to_json
     end
 
-
     # Assign this presence message to a ProtocolMessage before delivery to the Ably system
     # @api private
     def assign_to_protocol_message(protocol_message)
@@ -142,6 +144,19 @@ module Ably::Models
       @protocol_message
     end
 
+    # Create a static shallow clone of this object with the optional attributes to overide existing values
+    # Shallow clones have no dependency on the originating ProtocolMessage as all field values are stored as opposed to calculated
+    # Clones are useful when the original PresenceMessage needs to be mutated, such as storing in a PresenceMap with action :present
+    def shallow_clone(new_attributes = {})
+      new_attributes = IdiomaticRubyWrapper(new_attributes.clone.freeze, stop_at: [:data])
+
+      self.class.new(attributes.to_hash.merge(
+        id: new_attributes[:id] || id,
+        connection_id: new_attributes[:connection_id] || connection_id,
+        timestamp: new_attributes[:timestamp] || as_since_epoch(timestamp)
+      ).merge(new_attributes.to_hash))
+    end
+
     private
     def raw_hash_object
       @raw_hash_object