ably 0.2.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d814eac0ae04dc623743bbe5973e80a58662056d
-  data.tar.gz: 95426e76baeaee6fbc297031b83cc128e5bed688
+  metadata.gz: ee3e7490507273d4da5f34286db1f6ee1e0bc968
+  data.tar.gz: a1558974a048679f9572bb607ce4ea00746364ba
 SHA512:
-  metadata.gz: b660702de87dec06d7f982ea110d59310ba1f9a130be320bd2ec7a40f777b2e5452cfa4f97f6a08a0cf751646326f53196e7cf3a39c023ce55795583309ad4db
-  data.tar.gz: 8088bb09de07b180385a4e817827ef2d867ccb2c6645f55c68888bfaf932df7f2a7c2ec7392b3aa1471a5045beda59d0f93fa5775171ca99b1a1083b3fca2037
+  metadata.gz: f8b0da46c04457a191111f3c58a004d8f12dbeee12ad9f47836a86c836132d99b7e4675220644050c8c7ab1342e71c84d1477f5dc1256d593f7e028bbbe94298
+  data.tar.gz: da2d88e2cba687467a1b5cd79259cf6ec78cb00de7f9ae22f26641b154197dc3dfded91be3adddceed1e0e48b79ac53055af3b23c6dec3444adf4b039c31e42a

data/lib/ably/models/paginated_resource.rb

@@ -1,10 +1,11 @@
 module Ably::Models
-  # Wraps any Ably HTTP response that supports paging and automatically provides methdos to iterated through
+  # Wraps any Ably HTTP response that supports paging and automatically provides methods to iterate through
   # the array of resources using {#first_page}, {#next_page}, {#first_page?} and {#last_page?}
   #
   # Paging information is provided by Ably in the LINK HTTP headers
   class PaginatedResource
     include Enumerable
+    include Ably::Modules::AsyncWrapper
 
     # @param [Faraday::Response] http_response Initial HTTP response from an Ably request to a paged resource
     # @param [String] base_url Base URL for request that generated the http_response so that subsequent paged requests can be made
@@ -12,6 +13,8 @@ module Ably::Models
     # @param [Hash] options Options for this paged resource
     # @option options [Symbol,String] :coerce_into symbol or string representing class that should be used to create each item in the PaginatedResource
     #
+    # @yield [Object] block will be called for each resource object for the current page.  This is a useful way to apply a transformation to any page resources after they are retrieved
+    #
     # @return [PaginatedResource]
     def initialize(http_response, base_url, client, options = {}, &each_block)
       @http_response = http_response
@@ -20,6 +23,7 @@ module Ably::Models
       @coerce_into   = options[:coerce_into]
       @raw_body      = http_response.body
       @each_block    = each_block
+      @make_async    = options.fetch(:async_blocking_operations, false)
 
       @body = if @coerce_into
         http_response.body.map do |item|
@@ -34,19 +38,27 @@ module Ably::Models
       end if block_given?
     end
 
-    # Retrieve the first page of results
+    # Retrieve the first page of results.
+    # When used as part of the {Ably::Realtime} library, it will return a {EventMachine::Deferrable} object,
+    #   and allows an optional success callback block to be provided.
     #
-    # @return [PaginatedResource]
-    def first_page
-      PaginatedResource.new(client.get(pagination_url('first')), base_url, client, coerce_into: coerce_into, &each_block)
+    # @return [PaginatedResource,EventMachine::Deferrable]
+    def first_page(&success_callback)
+      async_wrap_if(make_async, success_callback) do
+        PaginatedResource.new(client.get(pagination_url('first')), base_url, client, pagination_options, &each_block)
+      end
     end
 
-    # Retrieve the next page of results
+    # Retrieve the next page of results.
+    # When used as part of the {Ably::Realtime} library, it will return a {EventMachine::Deferrable} object,
+    #   and allows an optional success callback block to be provided.
     #
-    # @return [PaginatedResource]
-    def next_page
-      raise Ably::Exceptions::InvalidPageError, 'There are no more pages' if supports_pagination? && last_page?
-      PaginatedResource.new(client.get(pagination_url('next')), base_url, client, coerce_into: coerce_into, &each_block)
+    # @return [PaginatedResource,EventMachine::Deferrable]
+    def next_page(&success_callback)
+      async_wrap_if(make_async, success_callback) do
+        raise Ably::Exceptions::InvalidPageError, 'There are no more pages' if supports_pagination? && last_page?
+        PaginatedResource.new(client.get(pagination_url('next')), base_url, client, pagination_options, &each_block)
+      end
     end
 
     # True if this is the last page in the paged resource set
@@ -84,7 +96,7 @@ module Ably::Models
     alias_method :count, :length
     alias_method :size,  :length
 
-    # Method ensuring this {PaginatedResource} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
+    # Method to allow {PaginatedResource} to be {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
     def each(&block)
       body.each do |item|
         if block_given?
@@ -95,7 +107,7 @@ module Ably::Models
       end
     end
 
-    # Last item in this page
+    # First item in this page
     def first
       body.first
     end
@@ -118,7 +130,7 @@ module Ably::Models
     end
 
     private
-    attr_reader :body, :http_response, :base_url, :client, :coerce_into, :raw_body, :each_block
+    attr_reader :body, :http_response, :base_url, :client, :coerce_into, :raw_body, :each_block, :make_async
 
     def pagination_headers
       link_regex = %r{<(?<url>[^>]+)>; rel="(?<rel>[^"]+)"}
@@ -146,5 +158,20 @@ module Ably::Models
         pagination_header[id]
       end
     end
+
+    def pagination_options
+      {
+        coerce_into: coerce_into,
+        async_blocking_operations: make_async
+      }
+    end
+
+    def async_wrap_if(is_realtime, success_callback, &operation)
+      if is_realtime
+        async_wrap success_callback, &operation
+      else
+        yield
+      end
+    end
   end
 end

data/lib/ably/modules/async_wrapper.rb

@@ -0,0 +1,60 @@
+module Ably::Modules
+  # Provides methods to convert synchronous operations into async operations through the use of
+  # {EventMachine#defer http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine#defer-class_method}.
+  # The async_wrap method can only be called from within an EventMachine reactor, and must be thread safe.
+  #
+  # @note using this AsyncWrapper should only be used for methods that are used less frequently and typically
+  #       not run with levels of concurrency due to the limited number of threads available to EventMachine by default.
+  #
+  # @example
+  #   class BlockingOperation
+  #     include Aby::Modules::AsyncWrapper
+  #
+  #     def operation(&success_callback)
+  #       async_wrap(success_callback) do
+  #         sleep 1
+  #         'slept'
+  #       end
+  #     end
+  #   end
+  #
+  #   blocking_object = BlockingOperation.new
+  #   deferrable = blocking_object.operation do |result|
+  #     puts "Done with result: #{result}"
+  #   end
+  #   puts "Starting"
+  #
+  #   # => 'Starting'
+  #   # => 'Done with result: slept'
+  #
+  module AsyncWrapper
+    private
+
+    # Will yield the provided block in a new thread and return an {EventMachine::Deferrable http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Deferrable}
+    #
+    # @yield [Object] operation block that is run in a thread
+    # @return [EventMachine::Deferrable]
+    #
+    def async_wrap(success_callback = nil, &operation)
+      raise ArgumentError, "Operation block is missing" unless block_given?
+
+      EventMachine::DefaultDeferrable.new.tap do |deferrable|
+        deferrable.callback &success_callback if success_callback
+
+        operation_with_exception_handling = proc do
+          begin
+            yield
+          rescue StandardError => e
+            deferrable.fail e
+          end
+        end
+
+        complete_callback = proc do |result|
+          deferrable.succeed result
+        end
+
+        EventMachine.defer operation_with_exception_handling, complete_callback
+      end
+    end
+  end
+end

data/lib/ably/realtime/channel.rb

@@ -36,6 +36,7 @@ module Ably
       include Ably::Modules::Conversions
       include Ably::Modules::EventEmitter
       include Ably::Modules::EventMachineHelpers
+      include Ably::Modules::AsyncWrapper
       extend Ably::Modules::Enum
 
       STATE = ruby_enum('STATE',
@@ -102,6 +103,8 @@ module Ably
       # @param name [String] The event name of the message to subscribe to if provided.  Defaults to all events.
       # @yield [Ably::Models::Message] For each message received, the block is called
       #
+      # @return [void]
+      #
       def subscribe(name = :all, &blk)
         attach unless attached? || attaching?
         subscriptions[message_name_key(name)] << blk
@@ -112,6 +115,8 @@ module Ably
       #
       # @param name [String] The event name of the message to subscribe to if provided.  Defaults to all events.
       #
+      # @return [void]
+      #
       def unsubscribe(name = :all, &blk)
         if message_name_key(name) == :all
           subscriptions.keys
@@ -174,8 +179,14 @@ module Ably
       #
       # @param (see Ably::Rest::Channel#history)
       # @option options (see Ably::Rest::Channel#history)
-      def history(options = {})
-        rest_channel.history(options)
+      #
+      # @yield [Ably::Models::PaginatedResource<Ably::Models::Message>] An Array of {Ably::Models::Message} objects that supports paging (#next_page, #first_page)
+      #
+      # @return [EventMachine::Deferrable]
+      def history(options = {}, &callback)
+        async_wrap(callback) do
+          rest_channel.history(options.merge(async_blocking_operations: true))
+        end
       end
 
       # @!attribute [r] __incoming_msgbus__

data/lib/ably/realtime/client.rb

@@ -23,6 +23,7 @@ module Ably
     # @!attribute [r] protocol_binary?
     #   (see Ably::Rest::Client#protocol_binary?)
     class Client
+      include Ably::Modules::AsyncWrapper
       extend Forwardable
 
       DOMAIN = 'realtime.ably.io'
@@ -66,20 +67,32 @@ module Ably
       # Return a {Ably::Realtime::Channel Realtime Channel} for the given name
       #
       # @param (see Ably::Realtime::Channels#get)
-      #
       # @return (see Ably::Realtime::Channels#get)
+      #
       def channel(name, channel_options = {})
         channels.get(name, channel_options)
       end
 
-      # (see Ably::Rest::Client#time)
-      def time
-        rest_client.time
+      # Retrieve the Ably service time
+      #
+      # @yield [Time] The time as reported by the Ably service
+      # @return [EventMachine::Deferrable]
+      #
+      def time(&success_callback)
+        async_wrap(success_callback) do
+          rest_client.time
+        end
       end
 
-      # (see Ably::Rest::Client#stats)
-      def stats(params = {})
-        rest_client.stats(params)
+      # Retrieve the stats for the application
+      #
+      # @yield [Array] An Array of hashes representing the stats
+      # @return [EventMachine::Deferrable]
+      #
+      def stats(params = {}, &success_callback)
+        async_wrap(success_callback) do
+          rest_client.stats(params)
+        end
       end
 
       # (see Ably::Realtime::Connection#close)
@@ -103,7 +116,7 @@ module Ably
       end
 
       # @!attribute [r] custom_socket_host
-      # @return [String,nil] Returns the custom socket host that is being used if it was provided with the option :ws_host when the {Client} was created
+      # @return [String,NilClass] Returns the custom socket host that is being used if it was provided with the option :ws_host when the {Client} was created
       def custom_socket_host
         @custom_socket_host
       end

data/lib/ably/realtime/presence.rb

@@ -2,6 +2,7 @@ module Ably::Realtime
   # Presence provides access to presence operations and state for the associated Channel
   class Presence
     include Ably::Modules::EventEmitter
+    include Ably::Modules::AsyncWrapper
     extend Ably::Modules::Enum
 
     STATE = ruby_enum('STATE',
@@ -14,12 +15,15 @@ module Ably::Realtime
     )
     include Ably::Modules::StateEmitter
 
-    # {Ably::Realtime::Channel} this Presence object is assoicated with
+    # {Ably::Realtime::Channel} this Presence object is associated with
+    # @return {Ably::Realtime::Channel}
     attr_reader :channel
 
     # A unique member identifier for this channel client, disambiguating situations where a given
     # client_id is present on multiple connections simultaneously.
-    # TODO: This does not work at present as no ACK is sent from the server with a memberId
+    #
+    # @note TODO: This does not work at present as no ACK is sent from the server with a memberId
+    # @return {String}
     attr_reader :member_id
 
     def initialize(channel)
@@ -36,13 +40,16 @@ module Ably::Realtime
 
     # Enter this client into this channel. This client will be added to the presence set
     # and presence subscribers will see an enter message for this client.
+    #
     # @param [Hash,String] options an options Hash to specify client data and/or client ID, or a String with the client data
     # @option options [String] :data      optional data (eg a status message) for this member
     # @option options [String] :client_id the optional id of the client.
     #                                     This option is provided to support connections from server instances that act on behalf of
     #                                     multiple client_ids. In order to be able to enter the channel with this method, the client
     #                                     library must have been instanced either with a key, or with a token bound to the wildcard clientId.
+    #
     # @yield [Ably::Realtime::Presence] On success, will call the block with the {Ably::Realtime::Presence}
+    #
     # @return [Ably::Models::PresenceMessage] Deferrable {Ably::Models::PresenceMessage} that supports both success (callback) and failure (errback) callbacks
     #
     def enter(options = {}, &blk)
@@ -71,6 +78,7 @@ module Ably::Realtime
 
     # Leave this client from this channel. This client will be removed from the presence
     # set and presence subscribers will see a leave message for this client.
+    #
     # @param (see Presence#enter)
     # @yield (see Presence#enter)
     # @return (see Presence#enter)
@@ -101,6 +109,7 @@ module Ably::Realtime
     # Update the presence data for this client. If the client is not already a member of
     # the presence set it will be added, and presence subscribers will see an enter or
     # update message for this client.
+    #
     # @param (see Presence#enter)
     # @yield (see Presence#enter)
     # @return (see Presence#enter)
@@ -120,9 +129,15 @@ module Ably::Realtime
 
     # Get the presence state for this Channel.
     # Optionally get a member's {Ably::Models::PresenceMessage} state by member_id
+    #
     # @return [Array<Ably::Models::PresenceMessage>, Ably::Models::PresenceMessage] members on the channel
-    def get()
-      members.map { |key, presence| presence }
+    #
+    def get(member_id = nil)
+      if member_id
+        members.find { |key, presence| presence.member_id == member_id }
+      else
+        members.map { |key, presence| presence }
+      end
     end
 
     # Subscribe to presence events on the associated Channel.
@@ -131,6 +146,8 @@ module Ably::Realtime
     # @param action [Ably::Models::PresenceMessage::ACTION] Optional, the state change action to subscribe to. Defaults to all presence actions
     # @yield [Ably::Models::PresenceMessage] For each presence state change event, the block is called
     #
+    # @return [void]
+    #
     def subscribe(action = :all, &blk)
       ensure_channel_attached do
         subscriptions[message_action_key(action)] << blk
@@ -142,6 +159,8 @@ module Ably::Realtime
     #
     # @param action [Ably::Models::PresenceMessage::ACTION] Optional, the state change action to subscribe to. Defaults to all presence actions
     #
+    # @return [void]
+    #
     def unsubscribe(action = :all, &blk)
       if message_action_key(action) == :all
         subscriptions.keys
@@ -158,8 +177,15 @@ module Ably::Realtime
     #
     # @param (see Ably::Rest::Presence#history)
     # @option options (see Ably::Rest::Presence#history)
-    def history(options = {})
-      rest_presence.history(options)
+    #
+    # @yield [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
+    #
+    # @return [EventMachine::Deferrable]
+    #
+    def history(options = {}, &callback)
+      async_wrap(callback) do
+        rest_presence.history(options.merge(async_blocking_operations: true))
+      end
     end
 
     # @!attribute [r] __incoming_msgbus__

data/lib/ably/rest/channel.rb

@@ -57,16 +57,22 @@ module Ably
       # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 10,000
       # @option options [Symbol]       :by         `:message`, `:bundle` or `:hour`. Defaults to `:message`
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::Message>] An Array of hashes representing the message history that supports paging (next, first)
+      # @return [Ably::Models::PaginatedResource<Ably::Models::Message>] An Array of {Ably::Models::Message} objects that supports paging (#next_page, #first_page)
       def history(options = {})
         url = "#{base_path}/messages"
+        options = options.dup
 
         merge_options = { live: true }  # TODO: Remove live param as all history should be live
         [:start, :end].each { |option| merge_options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 
+        paginated_options = {
+          coerce_into: 'Ably::Models::Message',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
         response = client.get(url, options.merge(merge_options))
 
-        Ably::Models::PaginatedResource.new(response, url, client, coerce_into: 'Ably::Models::Message') do |message|
+        Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |message|
           message.tap do |message|
             message.decode self
           end

data/lib/ably/rest/presence.rb

@@ -3,7 +3,13 @@ module Ably
     class Presence
       include Ably::Modules::Conversions
 
-      attr_reader :client, :channel
+      # {Ably::Rest::Client} for this Presence object
+      # @return {Ably::Rest::Client}
+      attr_reader :client
+
+      # {Ably::Rest::Channel} this Presence object is associated with
+      # @return {Ably::Rest::Channel}
+      attr_reader :channel
 
       # Initialize a new Presence object
       #
@@ -16,11 +22,25 @@ module Ably
 
       # Obtain the set of members currently present for a channel
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of presence-message Hash objects that supports paging (next, first)
+      # @param [Hash] options the options for the set of members present
+      # @option options [Integer,Time] :start      Time or millisecond since epoch
+      # @option options [Integer,Time] :end        Time or millisecond since epoch
+      # @option options [Symbol]       :direction  `:forwards` or `:backwards`
+      # @option options [Integer]      :limit      Maximum number of members to retrieve up to 10,000
+      #
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
       #
       def get(options = {})
+        options = options.dup
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
         response = client.get(base_path, options)
-        Ably::Models::PaginatedResource.new(response, base_path, client, coerce_into: 'Ably::Models::PresenceMessage') do |presence_message|
+
+        Ably::Models::PaginatedResource.new(response, base_path, client, paginated_options) do |presence_message|
           presence_message.tap do |message|
             message.decode self.channel
           end
@@ -35,17 +55,23 @@ module Ably
       # @option options [Symbol]       :direction  `:forwards` or `:backwards`
       # @option options [Integer]      :limit      Maximum number of presence messages to retrieve up to 10,000
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of presence-message Hash objects that supports paging (next, first)
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
       #
       def history(options = {})
         url = "#{base_path}/history"
+        options = options.dup
 
         merge_options = { live: true }  # TODO: Remove live param as all history should be live
         [:start, :end].each { |option| merge_options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
         response = client.get(url, options.merge(merge_options))
 
-        Ably::Models::PaginatedResource.new(response, url, client, coerce_into: 'Ably::Models::PresenceMessage') do |presence_message|
+        Ably::Models::PaginatedResource.new(response, url, client, paginated_options) do |presence_message|
           presence_message.tap do |message|
             message.decode self.channel
           end

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.2.0'
+  VERSION = '0.6.2'
 end

data/spec/acceptance/realtime/channel_history_spec.rb

@@ -4,7 +4,7 @@ require 'securerandom'
 describe Ably::Realtime::Channel do
   include RSpec::EventMachine
 
-  [:msgpack, :json].each do |protocol|
+  [:json].each do |protocol| # :msgpack,
     context "over #{protocol}" do
       let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
 
@@ -24,25 +24,36 @@ describe Ably::Realtime::Channel do
 
       let(:options) { { :protocol => :json } }
 
-      it 'retrieves real-time history' do
+      it 'returns a Deferrable' do
         run_reactor do
           channel.publish('event', payload) do |message|
-            history = channel.history
-            expect(history.length).to eql(1)
-            expect(history[0].data).to eql(payload)
+            expect(channel.history).to be_a(EventMachine::Deferrable)
             stop_reactor
           end
         end
       end
 
+      it 'retrieves real-time history' do
+        run_reactor do
+          channel.publish('event', payload) do |message|
+            channel.history do |history|
+              expect(history.length).to eql(1)
+              expect(history[0].data).to eql(payload)
+              stop_reactor
+            end
+          end
+        end
+      end
+
       it 'retrieves real-time history across two channels' do
         run_reactor do
           channel.publish('event', payload) do |message|
             channel2.publish('event', payload) do |message|
-              history = channel2.history
-              expect(history.length).to eql(2)
-              expect(history.map(&:data).uniq).to eql([payload])
-              stop_reactor
+              channel2.history do |history|
+                expect(history.length).to eql(2)
+                expect(history.map(&:data).uniq).to eql([payload])
+                stop_reactor
+              end
             end
           end
         end
@@ -53,21 +64,22 @@ describe Ably::Realtime::Channel do
         let(:limit) { 10 }
 
         def check_limited_history(direction)
-          history = channel.history(direction: direction, limit: limit)
-          expect(history.length).to eql(limit)
-          limit.times do |index|
-            expect(history[index].data).to eql("history#{index}")
-          end
+          channel.history(direction: direction, limit: limit) do |history|
+            expect(history.length).to eql(limit)
+            limit.times do |index|
+              expect(history[index].data).to eql("history#{index}")
+            end
 
-          history = history.next_page
+            history.next_page do |history|
+              expect(history.length).to eql(limit)
+              limit.times do |index|
+                expect(history[index].data).to eql("history#{index + limit}")
+              end
+              expect(history.last_page?).to eql(true)
 
-          expect(history.length).to eql(limit)
-          limit.times do |index|
-            expect(history[index].data).to eql("history#{index + limit}")
+              stop_reactor
+            end
           end
-          expect(history.last_page?).to eql(true)
-
-          stop_reactor
         end
 
         context 'as one ProtocolMessage' do

data/spec/acceptance/realtime/presence_history_spec.rb

@@ -24,17 +24,18 @@ describe 'Ably::Realtime::Presence Messages' do
         run_reactor do
           presence_client_one.enter(data: data) do
             presence_client_one.leave do
-              history = presence_client_one.history
-              expect(history.count).to eql(2)
+              presence_client_one.history do |history|
+                expect(history.count).to eql(2)
 
-              expect(history[1].action).to eq(:enter)
-              expect(history[1].client_id).to eq(client_one.client_id)
+                expect(history[1].action).to eq(:enter)
+                expect(history[1].client_id).to eq(client_one.client_id)
 
-              expect(history[0].action).to eq(:leave)
-              expect(history[0].client_id).to eq(client_one.client_id)
-              expect(history[0].data).to eql(data)
+                expect(history[0].action).to eq(:leave)
+                expect(history[0].client_id).to eq(client_one.client_id)
+                expect(history[0].data).to eql(data)
 
-              stop_reactor
+                stop_reactor
+              end
             end
           end
         end
@@ -43,11 +44,12 @@ describe 'Ably::Realtime::Presence Messages' do
       it 'ensures REST presence history message IDs match ProtocolMessage wrapped message IDs via Realtime' do
         run_reactor do
           presence_client_one.subscribe(:enter) do |message|
-            history = presence_client_one.history
-            expect(history.count).to eql(1)
+            presence_client_one.history do |history|
+              expect(history.count).to eql(1)
 
-            expect(history[0].id).to eql(message.id)
-            stop_reactor
+              expect(history[0].id).to eql(message.id)
+              stop_reactor
+            end
           end
 
           presence_client_one.enter(data: data)

data/spec/acceptance/realtime/stats_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'Ably::Realtime::Client stats' do
+  include RSpec::EventMachine
+
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:client) do
+        Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      end
+
+      describe 'fetching stats' do
+        it 'should return a Hash' do
+          run_reactor do
+            client.stats do |stats|
+              expect(stats).to be_a(Array)
+              stop_reactor
+            end
+          end
+        end
+
+        it 'should return a deferrable object' do
+          run_reactor do
+            expect(client.stats).to be_a(EventMachine::Deferrable)
+            stop_reactor
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/realtime/time_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'Ably::Realtime::Client time' do
+  include RSpec::EventMachine
+
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:client) do
+        Ably::Realtime::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      end
+
+      describe 'fetching the service time' do
+        it 'should return the service time as a Time object' do
+          run_reactor do
+            client.time do |time|
+              expect(time).to be_within(2).of(Time.now)
+              stop_reactor
+            end
+          end
+        end
+
+        it 'should return a deferrable object' do
+          run_reactor do
+            expect(client.time).to be_a(EventMachine::Deferrable)
+            stop_reactor
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/rest/presence_spec.rb

@@ -28,6 +28,8 @@ describe Ably::Rest::Presence do
             expect(presence_message.data).to eq(fixture[:data])
           end
         end
+
+        skip 'with options'
       end
 
       describe 'presence #history' do

data/spec/acceptance/rest/stats_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'securerandom'
 
-describe 'Ably::Rest Stats' do
+describe 'Ably::Rest::Client Stats' do
   [:json, :msgpack].each do |protocol|
     context "over #{protocol}" do
       describe 'fetching application stats' do

data/spec/acceptance/rest/time_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
-require 'securerandom'
 
-describe 'Ably::REST time' do
+describe 'Ably::REST::Client time' do
   [:msgpack, :json].each do |protocol|
     context "over #{protocol}" do
       let(:client) do
@@ -9,7 +8,7 @@ describe 'Ably::REST time' do
       end
 
       describe 'fetching the service time' do
-        it "should return the service time as a Time object" do
+        it 'should return the service time as a Time object' do
           expect(client.time).to be_within(2).of(Time.now)
         end
       end

data/spec/unit/models/paginated_resource_spec.rb

@@ -67,7 +67,7 @@ describe Ably::Models::PaginatedResource do
     end
   end
 
-  context 'with each block' do
+  context 'paged transformations' do
     let(:headers) do
       {
         'link' => [
@@ -93,23 +93,65 @@ describe Ably::Models::PaginatedResource do
       })
     end
 
-    subject do
-      paginated_resource_class.new(http_response, full_url, paged_client, paginated_resource_options) do |resource|
-        resource[:added_attribute_from_block] = "id:#{resource[:id]}"
-        resource
+    context 'with each block' do
+      subject do
+        paginated_resource_class.new(http_response, full_url, paged_client, paginated_resource_options) do |resource|
+          resource[:added_attribute_from_block] = "id:#{resource[:id]}"
+          resource
+        end
+      end
+
+      it 'calls the block for each resource after retrieving the resources' do
+        expect(subject[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
       end
-    end
 
-    it 'calls the block for each resource after retrieving the resources' do
-      expect(subject[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
+      it 'calls the block for each resource on second page after retrieving the resources' do
+        page_1_first_id = subject[0][:id]
+        next_page = subject.next_page
+
+        expect(next_page[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
+        expect(next_page[0][:id]).to_not eql(page_1_first_id)
+      end
     end
 
-    it 'calls the block for each resource on second page after retrieving the resources' do
-      page_1_first_id = subject[0][:id]
-      next_page = subject.next_page
+    context 'with option async_blocking_operations: true' do
+      include RSpec::EventMachine
+
+      subject do
+        paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
+      end
 
-      expect(next_page[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
-      expect(next_page[0][:id]).to_not eql(page_1_first_id)
+      context '#next_page' do
+        it 'returns a deferrable object' do
+          run_reactor do
+            expect(subject.next_page).to be_a(EventMachine::Deferrable)
+            stop_reactor
+          end
+        end
+
+        it 'allows a success callback block to be added' do
+          run_reactor do
+            subject.next_page do |paginated_resource|
+              expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context '#first_page' do
+        it 'calls the errback callback when first page headers are missing' do
+          run_reactor do
+            subject.next_page do |paginated_resource|
+              deferrable = subject.first_page
+              deferrable.errback do |error|
+                expect(error).to be_a(Ably::Exceptions::InvalidPageError)
+                stop_reactor
+              end
+            end
+          end
+        end
+      end
     end
   end
 

data/spec/unit/modules/async_wrapper_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Modules::AsyncWrapper do
+  include RSpec::EventMachine
+
+  let(:class_with_module) do
+    Class.new do
+      include Ably::Modules::AsyncWrapper
+
+      def operation(&success_callback)
+        async_wrap success_callback, &@block
+      end
+
+      def block=(block)
+        @block = block
+      end
+    end
+  end
+  let(:subject)    { class_with_module.new }
+  let(:result)     { SecureRandom.hex }
+  let(:sleep_time) { 0.1 }
+
+  before do
+    subject.block = block
+  end
+
+  context '#async_wrap blocking block' do
+    context 'returns result' do
+      let(:block) do
+        proc do
+          sleep sleep_time
+          result
+        end
+      end
+
+      it 'calls the success_callback block with result when provided' do
+        run_reactor do
+          subject.operation do |result|
+            expect(result).to eql(result)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'returns a deferrable that succeeds with result' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            expect(result).to eql(result)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'does not call the errback' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            expect(result).to eql(result)
+            EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+          end
+          deferrable.errback do |result|
+            raise 'Errback should not have been called'
+          end
+        end
+      end
+
+      it 'does not block EventMachine' do
+        run_reactor do
+          timers_called = 0
+          EventMachine.add_periodic_timer(sleep_time / 5) { timers_called += 1 }
+
+          subject.operation do |result|
+            expect(timers_called).to be >= 4
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'raises an Exception' do
+      let(:block) do
+        proc do
+          sleep sleep_time
+          raise RuntimeError, 'Intentional'
+        end
+      end
+
+      it 'calls the errback block of the deferrable' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.errback do |error|
+            expect(error).to be_a(RuntimeError)
+            expect(error.message).to match(/Intentional/)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'does not call the success_callback block' do
+        run_reactor do
+          subject.operation do |result|
+            raise 'Callback should not have been called'
+          end
+          EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+        end
+      end
+
+      it 'does not call the callback block of the deferrable' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            raise 'Callback should not have been called'
+          end
+          EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+        end
+      end
+    end
+  end
+end

data/spec/unit/realtime/client_spec.rb

@@ -16,16 +16,6 @@ describe Ably::Realtime::Client do
       subject
     end
 
-    specify '#time' do
-      expect(subject.rest_client).to receive(:time)
-      subject.time
-    end
-
-    specify '#stats' do
-      expect(subject.rest_client).to receive(:stats).with(options)
-      subject.stats options
-    end
-
     context 'for attribute' do
       [:environment, :use_tls?, :log_level].each do |attribute|
         specify "##{attribute}" do

data/spec/unit/realtime/presence_spec.rb

@@ -47,7 +47,9 @@ describe Ably::Realtime::Presence do
   context 'subscriptions' do
     let(:message_history) { Hash.new { |hash, key| hash[key] = 0 } }
     let(:presence_action) { Ably::Models::PresenceMessage::ACTION.Enter }
-    let(:message) { instance_double('Ably::Models::PresenceMessage', action: presence_action, member_id: SecureRandom.hex) }
+    let(:message) do
+      instance_double('Ably::Models::PresenceMessage', action: presence_action, member_id: SecureRandom.hex, decode: true)
+    end
 
     context '#subscribe' do
       specify 'to all presence state actions' do

data/spec/unit/realtime/websocket_transport_spec.rb

@@ -3,11 +3,12 @@ require 'support/protocol_msgbus_helper'
 
 describe Ably::Realtime::Connection::WebsocketTransport do
   let(:client_ignored) { double('Ably::Realtime::Client').as_null_object }
-  let(:connection) { instance_double('Ably::Realtime::Connection', client: client_ignored, id: nil) }
+  let(:connection)     { instance_double('Ably::Realtime::Connection', client: client_ignored, id: nil) }
+  let(:url)            { 'http://ably.io/' }
 
   let(:websocket_transport_without_eventmachine) do
     Ably::Realtime::Connection::WebsocketTransport.send(:allocate).tap do |websocket_transport|
-      websocket_transport.send(:initialize, connection)
+      websocket_transport.send(:initialize, connection, url)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ably
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Lewis Marshall
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -210,6 +210,7 @@ files:
 - lib/ably/models/presence_message.rb
 - lib/ably/models/protocol_message.rb
 - lib/ably/models/token.rb
+- lib/ably/modules/async_wrapper.rb
 - lib/ably/modules/channels_collection.rb
 - lib/ably/modules/conversions.rb
 - lib/ably/modules/encodeable.rb
@@ -253,6 +254,8 @@ files:
 - spec/acceptance/realtime/message_spec.rb
 - spec/acceptance/realtime/presence_history_spec.rb
 - spec/acceptance/realtime/presence_spec.rb
+- spec/acceptance/realtime/stats_spec.rb
+- spec/acceptance/realtime/time_spec.rb
 - spec/acceptance/rest/auth_spec.rb
 - spec/acceptance/rest/base_spec.rb
 - spec/acceptance/rest/channel_spec.rb
@@ -284,6 +287,7 @@ files:
 - spec/unit/models/presence_message_spec.rb
 - spec/unit/models/protocol_message_spec.rb
 - spec/unit/models/token_spec.rb
+- spec/unit/modules/async_wrapper_spec.rb
 - spec/unit/modules/conversions_spec.rb
 - spec/unit/modules/enum_spec.rb
 - spec/unit/modules/event_emitter_spec.rb
@@ -330,6 +334,8 @@ test_files:
 - spec/acceptance/realtime/message_spec.rb
 - spec/acceptance/realtime/presence_history_spec.rb
 - spec/acceptance/realtime/presence_spec.rb
+- spec/acceptance/realtime/stats_spec.rb
+- spec/acceptance/realtime/time_spec.rb
 - spec/acceptance/rest/auth_spec.rb
 - spec/acceptance/rest/base_spec.rb
 - spec/acceptance/rest/channel_spec.rb
@@ -361,6 +367,7 @@ test_files:
 - spec/unit/models/presence_message_spec.rb
 - spec/unit/models/protocol_message_spec.rb
 - spec/unit/models/token_spec.rb
+- spec/unit/modules/async_wrapper_spec.rb
 - spec/unit/modules/conversions_spec.rb
 - spec/unit/modules/enum_spec.rb
 - spec/unit/modules/event_emitter_spec.rb