ably-rest 0.7.5 → 0.8.1

data/lib/submodules/ably-ruby/lib/ably/rest.rb

@@ -23,10 +23,6 @@ module Ably
     # @param (see Ably::Rest::Client#initialize)
     # @option options (see Ably::Rest::Client#initialize)
     #
-    # @yield (see Ably::Rest::Client#initialize)
-    # @yieldparam (see Ably::Rest::Client#initialize)
-    # @yieldreturn (see Ably::Rest::Client#initialize)
-    #
     # @return [Ably::Rest::Client]
     #
     # @example
@@ -34,10 +30,10 @@ module Ably
     #    client = Ably::Rest.new('key.id:secret')
     #
     #    # create a new client authenticating with basic auth and a client_id
-    #    client = Ably::Rest.new(api_key: 'key.id:secret', client_id: 'john')
+    #    client = Ably::Rest.new(key: 'key.id:secret', client_id: 'john')
     #
-    def self.new(options, &token_request_block)
-      Ably::Rest::Client.new(options, &token_request_block)
+    def self.new(options)
+      Ably::Rest::Client.new(options)
     end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/rest/channel.rb

@@ -20,7 +20,7 @@ module Ably
       # @param name [String] The name of the channel
       # @param channel_options [Hash] Channel options, currently reserved for Encryption options
       # @option channel_options [Boolean]  :encrypted       setting this to true for this channel will encrypt & decrypt all messages automatically
-      # @option channel_options [Hash]     :cipher_params   A hash of options to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of `cipher_params` options
+      # @option channel_options [Hash]     :cipher_params   A hash of options to configure the encryption. *:key* is required, all other options are optional.  See {Ably::Util::Crypto#initialize} for a list of +cipher_params+ options
       #
       def initialize(client, name, channel_options = {})
         ensure_utf_8 :name, name
@@ -52,19 +52,22 @@ module Ably
         [201, 204].include?(response.status)
       end
 
-      # Return the message history of the channel
+      # Return the message   of the channel
       #
-      # @param [Hash] options the options for the message history request
-      # @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 messages to retrieve up to 10,000
-      # @option options [Symbol]       :by         `:message`, `:bundle` or `:hour`. Defaults to `:message`
+      # @param [Hash] options   the options for the message history request
+      # @option options [Integer,Time] :start      Ensure earliest time or millisecond since epoch for any messages retrieved is +:start+
+      # @option options [Integer,Time] :end        Ensure latest time or millisecond since epoch for any messages retrieved is +:end+
+      # @option options [Symbol]       :direction  +:forwards+ or +:backwards+, defaults to +:backwards+
+      # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
+      #
+      # @return [Ably::Models::PaginatedResource<Ably::Models::Message>] First {Ably::Models::PaginatedResource page} of {Ably::Models::Message} objects accessible with {Ably::Models::PaginatedResource#items #items}.
       #
-      # @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
+        options = {
+          :direction => :backwards,
+          :limit     => 100
+        }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -70,18 +70,16 @@ module Ably
       # @param [Hash,String] options an options Hash used to configure the client and the authentication, or String with an API key or Token ID
       # @option options (see Ably::Auth#authorise)
       # @option options [Boolean]                 :tls                 TLS is used by default, providing a value of false disables TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
-      # @option options [String]                  :api_key             API key comprising the key ID and key secret in a single string
-      # @option options [Boolean]                 :use_token_auth      Will force Basic Auth if set to false, and TOken auth if set to true
+      # @option options [String]                  :key                 API key comprising the key name and key secret in a single string
+      # @option options [String]                  :token               Token string or {Models::TokenDetails} used to authenticate requests
+      # @option options [String]                  :token_details       {Models::TokenDetails} used to authenticate requests
+      # @option options [Boolean]                 :use_token_auth      Will force Basic Auth if set to false, and Token auth if set to true
       # @option options [String]                  :environment         Specify 'sandbox' when testing the client library against an alternate Ably environment
       # @option options [Symbol]                  :protocol            Protocol used to communicate with Ably, :json and :msgpack currently supported. Defaults to :msgpack
       # @option options [Boolean]                 :use_binary_protocol Protocol used to communicate with Ably, defaults to true and uses MessagePack protocol.  This option will overide :protocol option
       # @option options [Logger::Severity,Symbol] :log_level           Log level for the standard Logger that outputs to STDOUT.  Defaults to Logger::ERROR, 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
       #
-      # @yield (see Ably::Auth#authorise)
-      # @yieldparam (see Ably::Auth#authorise)
-      # @yieldreturn (see Ably::Auth#authorise)
-      #
       # @return [Ably::Rest::Client]
       #
       # @example
@@ -89,17 +87,17 @@ module Ably
       #    client = Ably::Rest::Client.new('key.id:secret')
       #
       #    # create a new client and configure a client ID used for presence
-      #    client = Ably::Rest::Client.new(api_key: 'key.id:secret', client_id: 'john')
+      #    client = Ably::Rest::Client.new(key: 'key.id:secret', client_id: 'john')
       #
-      def initialize(options, &token_request_block)
+      def initialize(options)
         raise ArgumentError, 'Options Hash is expected' if options.nil?
 
         options = options.clone
         if options.kind_of?(String)
           options = if options.match(/^[\w]{2,}\.[\w]{2,}:[\w]{2,}$/)
-            { api_key:  options }
+            { key: options }
           else
-            { token_id: options }
+            { token: options }
           end
         end
 
@@ -127,7 +125,7 @@ module Ably
         raise ArgumentError, 'Protocol is invalid.  Must be either :msgpack or :json' unless [:msgpack, :json].include?(@protocol)
 
         @options  = options.freeze
-        @auth     = Auth.new(self, options, &token_request_block)
+        @auth     = Auth.new(self, options)
         @channels = Ably::Rest::Channels.new(self)
         @encoders = []
 
@@ -146,24 +144,25 @@ module Ably
       # Retrieve the Stats for the application
       #
       # @param [Hash] options the options for the stats request
-      # @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 stats to retrieve up to 10,000
-      # @option options [Symbol]       :by         `:minute`, `:hour`, `:day` or `:month`. Defaults to `:minute`
+      # @option options [Integer,Time] :start      Ensure earliest time or millisecond since epoch for any stats retrieved is +:start+
+      # @option options [Integer,Time] :end        Ensure latest time or millisecond since epoch for any stats retrieved is +:end+
+      # @option options [Symbol]       :direction  +:forwards+ or +:backwards+, defaults to +:backwards+
+      # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
+      # @option options [Symbol]       :unit       `:minute`, `:hour`, `:day` or `:month`. Defaults to `:minute`
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::Stat>] An Array of Stats
+      # @return [Ably::Models::PaginatedResource<Ably::Models::Stats>] An Array of Stats
       #
       def stats(options = {})
         options = {
-          :direction => :forwards,
-          :by        => :minute
+          :direction => :backwards,
+          :unit      => :minute,
+          :limit     => 100
         }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 
         paginated_options = {
-          coerce_into: 'Ably::Models::Stat'
+          coerce_into: 'Ably::Models::Stats'
         }
 
         url = '/stats'

data/lib/submodules/ably-ruby/lib/ably/rest/presence.rb

@@ -23,15 +23,14 @@ module Ably
       # Obtain the set of members currently present for a channel
       #
       # @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
+      # @option options [Integer]      :limit      Maximum number of members to retrieve up to 1,000, defaults to 100
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResource page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResource#items #items}.
       #
       def get(options = {})
-        options = options.dup
+        options = options = {
+          :limit     => 100
+        }.merge(options)
 
         paginated_options = {
           coerce_into: 'Ably::Models::PresenceMessage',
@@ -50,16 +49,19 @@ module Ably
       # Return the presence messages history for the channel
       #
       # @param [Hash] options the options for the message history request
-      # @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 presence messages to retrieve up to 10,000
+      # @option options [Integer,Time] :start      Ensure earliest time or millisecond since epoch for any presence messages retrieved is +:start+
+      # @option options [Integer,Time] :end        Ensure latest time or millisecond since epoch for any presence messages retrieved is +:end+
+      # @option options [Symbol]       :direction  +:forwards+ or +:backwards+, defaults to +:backwards+
+      # @option options [Integer]      :limit      Maximum number of messages to retrieve up to 1,000, defaults to 100
       #
-      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] An Array of {Ably::Models::PresenceMessage} objects that supports paging (#next_page, #first_page)
+      # @return [Ably::Models::PaginatedResource<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResource page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResource#items #items}.
       #
       def history(options = {})
         url = "#{base_path}/history"
-        options = options.dup
+        options = options = {
+          :direction => :backwards,
+          :limit     => 100
+        }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
 

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.7.5'
+  VERSION = '0.8.1'
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_history_spec.rb

@@ -3,10 +3,11 @@ require 'spec_helper'
 
 describe Ably::Realtime::Channel, '#history', :event_machine do
   vary_by_protocol do
-    let(:default_options) { options.merge(api_key: api_key, environment: environment, protocol: protocol) }
+    let(:default_options) { options.merge(key: api_key, environment: environment, protocol: protocol) }
 
     let(:client)       { Ably::Realtime::Client.new(default_options) }
     let(:channel)      { client.channel(channel_name) }
+    let(:rest_channel) { client.rest_client.channel(channel_name) }
 
     let(:client2)      { Ably::Realtime::Client.new(default_options) }
     let(:channel2)     { client2.channel(channel_name) }
@@ -21,20 +22,20 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
       channel.publish('event', payload) do |message|
         history = channel.history
         expect(history).to be_a(Ably::Util::SafeDeferrable)
-        history.callback do |messages|
-          expect(messages.count).to eql(1)
-          expect(messages).to be_a(Ably::Models::PaginatedResource)
+        history.callback do |page|
+          expect(page.items.count).to eql(1)
+          expect(page).to be_a(Ably::Models::PaginatedResource)
           stop_reactor
         end
       end
     end
 
     context 'with a single client publishing and receiving' do
-      it 'retrieves real-time history' do
+      it 'retrieves realtime history' do
         channel.publish('event', payload) do |message|
-          channel.history do |history|
-            expect(history.length).to eql(1)
-            expect(history[0].data).to eql(payload)
+          channel.history do |page|
+            expect(page.items.length).to eql(1)
+            expect(page.items[0].data).to eql(payload)
             stop_reactor
           end
         end
@@ -42,15 +43,15 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
     end
 
     context 'with two clients publishing messages on the same channel' do
-      it 'retrieves real-time history on both channels' do
+      it 'retrieves realtime history on both channels' do
         channel.publish('event', payload) do |message|
           channel2.publish('event', payload) do |message|
-            channel.history do |history|
-              expect(history.length).to eql(2)
-              expect(history.map(&:data).uniq).to eql([payload])
+            channel.history do |page|
+              expect(page.items.length).to eql(2)
+              expect(page.items.map(&:data).uniq).to eql([payload])
 
-              channel2.history do |history_2|
-                expect(history_2.length).to eql(2)
+              channel2.history do |page_2|
+                expect(page_2.items.length).to eql(2)
                 stop_reactor
               end
             end
@@ -65,18 +66,18 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
       let(:limit)           { 15 }
 
       def ensure_message_history_direction_and_paging_is_correct(direction)
-        channel.history(direction: direction, limit: limit) do |history|
-          expect(history.length).to eql(limit)
+        channel.history(direction: direction, limit: limit) do |history_page|
+          expect(history_page.items.length).to eql(limit)
           limit.times do |index|
-            expect(history[index].data).to eql("history#{index}")
+            expect(history_page.items[index].data).to eql("history#{index}")
           end
 
-          history.next_page do |history|
-            expect(history.length).to eql(limit)
+          history_page.next do |next_page|
+            expect(next_page.items.length).to eql(limit)
             limit.times do |index|
-              expect(history[index].data).to eql("history#{index + limit}")
+              expect(next_page.items[index].data).to eql("history#{index + limit}")
             end
-            expect(history.last_page?).to eql(true)
+            expect(next_page).to be_last
 
             stop_reactor
           end
@@ -141,8 +142,8 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
           channel.subscribe('event') do |message|
             messages << message
             if messages.count == batches * messages_per_batch
-              channel.history do |history|
-                expect(history.map(&:id).sort).to eql(messages.map(&:id).sort)
+              channel.history do |page|
+                expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
                 stop_reactor
               end
             end
@@ -150,5 +151,55 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         end
       end
     end
+
+    context 'with option until_attach: true' do
+      let(:event) { random_str }
+      let(:message_before_attach) { random_str }
+      let(:message_after_attach) { random_str }
+
+      it 'retrieves all messages before channel was attached' do
+        rest_channel.publish event, message_before_attach
+
+        channel.attach do
+          channel.publish(event, message_after_attach) do
+            channel.history(until_attach: true) do |messages|
+              expect(messages.items.count).to eql(1)
+              expect(messages.items.first.data).to eql(message_before_attach)
+              stop_reactor
+            end
+          end
+        end
+      end
+
+      context 'and two pages of messages' do
+        it 'retrieves two pages of messages before channel was attached' do
+          10.times { rest_channel.publish event, message_before_attach }
+
+          channel.attach do
+            10.times { rest_channel.publish event, message_after_attach }
+
+            EventMachine.add_timer(0.5) do
+              channel.history(until_attach: true, limit: 5) do |messages|
+                expect(messages.items.count).to eql(5)
+                expect(messages.items.map(&:data).uniq.first).to eql(message_before_attach)
+
+                messages.next do |next_page_messages|
+                  expect(next_page_messages.items.count).to eql(5)
+                  expect(next_page_messages.items.map(&:data).uniq.first).to eql(message_before_attach)
+                  expect(next_page_messages).to be_last
+
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it 'raises an exception unless state is attached' do
+        expect { channel.history(until_attach: true) }.to raise_error(ArgumentError, /not attached/)
+        stop_reactor
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 describe Ably::Realtime::Channel, :event_machine do
   vary_by_protocol do
-    let(:default_options) { { api_key: api_key, environment: environment, protocol: protocol } }
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
     let(:client_options)  { default_options }
 
     let(:client)       { Ably::Realtime::Client.new(client_options) }
@@ -158,7 +158,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
       context 'failure as a result of insufficient key permissions' do
         let(:restricted_client) do
-          Ably::Realtime::Client.new(default_options.merge(api_key: restricted_api_key, log_level: :fatal))
+          Ably::Realtime::Client.new(default_options.merge(key: restricted_api_key, log_level: :fatal))
         end
         let(:restricted_channel) { restricted_client.channel("cannot_subscribe") }
 
@@ -202,7 +202,7 @@ describe Ably::Realtime::Channel, :event_machine do
             restricted_channel.once(:failed) do
               restricted_client.close do
                 # A direct call to #authorise is synchronous
-                restricted_client.auth.authorise(api_key: api_key)
+                restricted_client.auth.authorise(key: api_key)
 
                 restricted_client.connect do
                   restricted_channel.once(:attached) do

data/lib/submodules/ably-ruby/spec/acceptance/realtime/client_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 describe Ably::Realtime::Client, :event_machine do
   vary_by_protocol do
     let(:default_options) do
-      { api_key: api_key, environment: environment, protocol: protocol }
+      { key: api_key, environment: environment, protocol: protocol }
     end
 
     let(:client_options) { default_options }
@@ -15,11 +15,11 @@ describe Ably::Realtime::Client, :event_machine do
 
     context 'initialization' do
       context 'basic auth' do
-        it 'is enabled by default with a provided :api_key option' do
+        it 'is enabled by default with a provided :key option' do
           connection.on(:connected) do
-            expect(auth_params[:key_id]).to_not be_nil
+            expect(auth_params[:key]).to_not be_nil
             expect(auth_params[:access_token]).to be_nil
-            expect(subject.auth.current_token).to be_nil
+            expect(subject.auth.current_token_details).to be_nil
             stop_reactor
           end
         end
@@ -44,26 +44,26 @@ describe Ably::Realtime::Client, :event_machine do
         [true, false].each do |tls_enabled|
           context "with TLS #{tls_enabled ? 'enabled' : 'disabled'}" do
             let(:capability)      { { :foo => ["publish"] } }
-            let(:token)           { Ably::Realtime::Client.new(default_options).auth.request_token(capability: capability) }
-            let(:client_options)  { default_options.merge(token_id: token.id) }
+            let(:token_details)   { Ably::Realtime::Client.new(default_options).auth.request_token(capability: capability) }
+            let(:client_options)  { default_options.merge(token: token_details.token) }
 
-            context 'and a pre-generated Token provided with the :token_id option' do
+            context 'and a pre-generated Token provided with the :token option' do
               it 'connects using token auth' do
                 connection.on(:connected) do
                   expect(auth_params[:access_token]).to_not be_nil
-                  expect(auth_params[:key_id]).to be_nil
-                  expect(subject.auth.current_token).to be_nil
+                  expect(auth_params[:key]).to be_nil
+                  expect(subject.auth.current_token_details).to be_nil
                   stop_reactor
                 end
               end
             end
 
-            context 'with valid :api_key and :use_token_auth option set to true' do
+            context 'with valid :key and :use_token_auth option set to true' do
               let(:client_options)  { default_options.merge(use_token_auth: true) }
 
               it 'automatically authorises on connect and generates a token' do
                 connection.on(:connected) do
-                  expect(subject.auth.current_token).to_not be_nil
+                  expect(subject.auth.current_token_details).to_not be_nil
                   expect(auth_params[:access_token]).to_not be_nil
                   stop_reactor
                 end
@@ -79,7 +79,7 @@ describe Ably::Realtime::Client, :event_machine do
                   connection.on(:connected) do
                     expect(connection.state).to eq(:connected)
                     expect(auth_params[:access_token]).to_not be_nil
-                    expect(auth_params[:key_id]).to be_nil
+                    expect(auth_params[:key]).to be_nil
                     stop_reactor
                   end
                 end
@@ -88,27 +88,27 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
 
-        context 'with token_request_block' do
+        context 'with a Proc for the :auth_callback option' do
           let(:client_id) { random_str }
           let(:auth)      { subject.auth }
 
           subject do
-            Ably::Realtime::Client.new(client_options) do
+            Ably::Realtime::Client.new(client_options.merge(auth_callback: Proc.new do
               @block_called = true
               auth.create_token_request(client_id: client_id)
-            end
+            end))
           end
 
-          it 'calls the block' do
+          it 'calls the Proc' do
             connection.on(:connected) do
               expect(@block_called).to eql(true)
               stop_reactor
             end
           end
 
-          it 'uses the token request when requesting a new token' do
+          it 'uses the token request returned from the callback when requesting a new token' do
             connection.on(:connected) do
-              expect(auth.current_token.client_id).to eql(client_id)
+              expect(auth.current_token_details.client_id).to eql(client_id)
               stop_reactor
             end
           end