ably 0.1.2 → 0.1.3

data/lib/ably/realtime/models/protocol_message.rb

@@ -79,7 +79,7 @@ module Ably::Realtime::Models
 
     def initialize(json_object)
       @raw_json_object = json_object
-      @json_object     = rubify(@raw_json_object).freeze
+      @json_object     = IdiomaticRubyWrapper(@raw_json_object.clone.freeze)
     end
 
     %w( action count
@@ -99,7 +99,7 @@ module Ably::Realtime::Models
     end
 
     def timestamp
-      Time.at(json[:timestamp] / 1000.0) if json[:timestamp]
+      as_time_from_epoch(json[:timestamp]) if json[:timestamp]
     end
 
     def message_serial
@@ -134,15 +134,13 @@ module Ably::Realtime::Models
       raise RuntimeError, ":action is missing, cannot generate valid JSON for ProtocolMessage" unless action_sym
       raise RuntimeError, ":msg_serial is missing, cannot generate valid JSON for ProtocolMessage" if ack_required? && !message_serial
 
-      json_object = json.dup.tap do |json_object|
+      json.dup.tap do |json_object|
         json_object[:messages] = messages.map(&:to_json_object) unless messages.empty?
         json_object[:presence] = presence.map(&:to_json_object) unless presence.empty?
       end
-
-      javify(json_object)
     end
 
-    def to_json
+    def to_json(*args)
       to_json_object.to_json
     end
   end

data/lib/ably/rest.rb

@@ -3,6 +3,7 @@ require "ably/rest/channels"
 require "ably/rest/client"
 require "ably/rest/models/message"
 require "ably/rest/models/paged_resource"
+require "ably/rest/models/presence_message"
 require "ably/rest/presence"
 
 module Ably

data/lib/ably/rest/channel.rb

@@ -3,17 +3,19 @@ module Ably
     # The Ably Realtime service organises the traffic within any application into named channels.
     # Channels are the "unit" of message distribution; clients attach to channels to subscribe to messages, and every message broadcast by the service is associated with a unique channel.
     class Channel
+      include Ably::Modules::Conversions
+
       attr_reader :client, :name, :options
 
       # Initialize a new Channel object
       #
       # @param client [Ably::Rest::Client]
       # @param name [String] The name of the channel
-      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      # @param channel_options [Hash] Channel options, currently reserved for future Encryption options
       def initialize(client, name, channel_options = {})
         @client  = client
         @name    = name
-        @options = channel_options.dup.freeze
+        @options = channel_options.clone.freeze
       end
 
       # Publish a message to the channel
@@ -35,17 +37,20 @@ module Ably
       # Return the message history of the channel
       #
       # @param [Hash] options the options for the message history request
-      # @option options [Integer]   :start      Time or millisecond since epoch
-      # @option options [Integer]   :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`
+      # @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`
       #
       # @return [Models::PagedResource<Models::Message>] An Array of hashes representing the message history that supports paging (next, first)
       def history(options = {})
         url = "#{base_path}/messages"
-        # TODO: Remove live param as all history should be live
-        response = client.get(url, options.merge(live: true))
+
+        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) }
+
+        response = client.get(url, options.merge(merge_options))
 
         Models::PagedResource.new(response, url, client, coerce_into: 'Ably::Rest::Models::Message')
       end

data/lib/ably/rest/client.rb

@@ -19,6 +19,7 @@ module Ably
     # @!attribute [r] environment
     #   @return [String] May contain 'sandbox' when testing the client library against an alternate Ably environment
     class Client
+      include Ably::Modules::Conversions
       include Ably::Modules::HttpHelpers
       extend Forwardable
 
@@ -50,7 +51,7 @@ module Ably
       #    client = Ably::Rest::Client.new(api_key: 'key.id:secret', client_id: 'john')
       #
       def initialize(options, &auth_block)
-        options = options.dup
+        options = options.clone
 
         if options.kind_of?(String)
           options = { api_key: options }
@@ -93,7 +94,7 @@ module Ably
       def time
         response = get('/time', {}, send_auth_header: false)
 
-        Time.at(response.body.first / 1000.0)
+        as_time_from_epoch(response.body.first)
       end
 
       # True if client is configured to use TLS for all Ably communication

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

@@ -5,7 +5,7 @@ module Ably
     module Middleware
       class ParseJson < Faraday::Response::Middleware
         def parse(body)
-          JSON.parse(body, symbolize_names: true)
+          JSON.parse(body)
         rescue JSON::ParserError => e
           raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response. #{e.message}"
         end

data/lib/ably/rest/models/message.rb

@@ -1,8 +1,10 @@
 module Ably::Rest::Models
   # A Message object encapsulates an individual message published in Ably retrieved via Rest
   class Message
+    include Ably::Modules::Conversions
+
     def initialize(message)
-      @message = message.dup.freeze
+      @message = IdiomaticRubyWrapper(message.clone.freeze)
     end
 
     # Event name
@@ -30,7 +32,7 @@ module Ably::Rest::Models
     #
     # @return [Time]
     def sender_timestamp
-      Time.at(json[:timestamp] / 1000.0) if json[:timestamp]
+      as_time_from_epoch(json[:timestamp]) if json[:timestamp]
     end
 
     # Unique message ID

data/lib/ably/rest/models/paged_resource.rb

@@ -10,7 +10,7 @@ module Ably::Rest::Models
     # @param [String] base_url Base URL for request that generated the http_response so that subsequent paged requests can be made
     # @param [Client] client {Ably::Client} used to make the request to Ably
     # @param [Hash] options Options for this paged resource
-    # @option options [Symbol] :coerce_into symbol representing class that should be used to represent each item in the PagedResource
+    # @option options [Symbol,String] :coerce_into symbol or string representing class that should be used to create each item in the PagedResource
     #
     # @return [PagedResource]
     def initialize(http_response, base_url, client, coerce_into: nil)
@@ -31,21 +31,22 @@ module Ably::Rest::Models
     # Retrieve the first page of results
     #
     # @return [PagedResource]
-    def first
+    def first_page
       PagedResource.new(client.get(pagination_url('first')), base_url, client, coerce_into: coerce_into)
     end
 
     # Retrieve the next page of results
     #
     # @return [PagedResource]
-    def next
+    def next_page
+      raise Ably::Exceptions::InvalidPageError, "There are no more pages" if supports_pagination? && last_page?
       PagedResource.new(client.get(pagination_url('next')), base_url, client, coerce_into: coerce_into)
     end
 
     # True if this is the last page in the paged resource set
     #
     # @return [Boolean]
-    def last?
+    def last_page?
       !supports_pagination? ||
         pagination_header('next').nil?
     end
@@ -53,7 +54,7 @@ module Ably::Rest::Models
     # True if this is the first page in the paged resource set
     #
     # @return [Boolean]
-    def first?
+    def first_page?
       !supports_pagination? ||
         pagination_header('first') == pagination_header('current')
     end
@@ -93,10 +94,14 @@ module Ably::Rest::Models
 
     def pagination_headers
       link_regex = %r{<(?<url>[^>]+)>; rel="(?<rel>[^"]+)"}
-      @pagination_headers ||= http_response.headers['link'].scan(link_regex).inject({}) do |hash, val_array|
-        url, rel = val_array
-        hash[rel] = url
-        hash
+      @pagination_headers ||= begin
+        # All `Link:` headers are concatenated by Faraday into a comma separated list
+        # Finding matching `<url>; rel="rel"` pairs
+        link_headers = http_response.headers['link'] || ''
+        link_headers.scan(link_regex).each_with_object({}) do |val_array, hash|
+          url, rel = val_array
+          hash[rel] = url
+        end
       end
     end
 
@@ -105,7 +110,7 @@ module Ably::Rest::Models
     end
 
     def pagination_url(id)
-      raise Ably::Exceptions::InvalidPageError, "Paging heading link #{id} does not exist" unless pagination_header(id)
+      raise Ably::Exceptions::InvalidPageError, "Paging header link #{id} does not exist" unless pagination_header(id)
 
       if pagination_header(id).match(%r{^\./})
         "#{base_url}#{pagination_header(id)[2..-1]}"

data/lib/ably/rest/models/presence_message.rb

@@ -0,0 +1,21 @@
+require 'delegate'
+
+module Ably::Rest::Models
+  # A placeholder class representing a presence message
+  class PresenceMessage < Delegator
+    include Ably::Modules::Conversions
+
+    def initialize(json_object)
+      super
+      @json_object = IdiomaticRubyWrapper(json_object.clone.freeze, stop_at: [:client_data])
+    end
+
+    def __getobj__
+      @json_object
+    end
+
+    def __setobj__(obj)
+      @json_object = obj
+    end
+  end
+end

data/lib/ably/rest/presence.rb

@@ -1,6 +1,8 @@
 module Ably
   module Rest
     class Presence
+      include Ably::Modules::Conversions
+
       attr_reader :client, :channel
 
       # Initialize a new Presence object
@@ -14,25 +16,32 @@ module Ably
 
       # Obtain the set of members currently present for a channel
       #
-      # @return [Models::PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
+      # @return [Models::PagedResource<Models::PresenceMessage>] An Array of presence-message Hash objects that supports paging (next, first)
+      #
       def get(options = {})
         response = client.get(base_path, options)
-        Models::PagedResource.new(response, base_path, client)
+        Models::PagedResource.new(response, base_path, client, coerce_into: 'Ably::Rest::Models::PresenceMessage')
       end
 
       # Return the presence messages history for the channel
       #
-      # Options:
-      #   - start:      Time or millisecond since epoch
-      #   - end:        Time or millisecond since epoch
-      #   - direction:  :forwards or :backwards (default is :backwards)
-      #   - limit:      Maximum number of messages to retrieve up to 10,000
+      # @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
+      #
+      # @return [Models::PagedResource<Models::PresenceMessage>] An Array of presence-message Hash objects that supports paging (next, first)
       #
-      # @return [Models::PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
       def history(options = {})
         url = "#{base_path}/history"
-        response = client.get(url, options)
-        Models::PagedResource.new(response, url, client)
+
+        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) }
+
+        response = client.get(url, options.merge(merge_options))
+
+        Models::PagedResource.new(response, url, client, coerce_into: 'Ably::Rest::Models::PresenceMessage')
       end
 
       private

data/lib/ably/token.rb

@@ -1,5 +1,7 @@
 module Ably
   class Token
+    include Ably::Modules::Conversions
+
     DEFAULTS = {
       capability: { "*" => ["*"] },
       ttl:        60 * 60 # 1 hour
@@ -8,7 +10,7 @@ module Ably
     TOKEN_EXPIRY_BUFFER = 5
 
     def initialize(attributes)
-      @attributes = attributes.dup.freeze
+      @attributes = attributes.clone.freeze
     end
 
     def id
@@ -20,11 +22,11 @@ module Ably
     end
 
     def issued_at
-      Time.at(attributes.fetch(:issued_at))
+      as_time_from_epoch(attributes.fetch(:issued_at), granularity: :s)
     end
 
     def expires_at
-      Time.at(attributes.fetch(:expires))
+      as_time_from_epoch(attributes.fetch(:expires), granularity: :s)
     end
 
     def capability

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/acceptance/rest/auth_spec.rb

@@ -425,9 +425,9 @@ describe "REST" do
           expect(token).to be_a(Ably::Token)
           capability_with_str_key = Ably::Token::DEFAULTS[:capability]
           capability = Hash[capability_with_str_key.keys.map(&:to_sym).zip(capability_with_str_key.values)]
-          expect(token.capability).to eql(capability)
+          expect(token.capability).to eq(capability)
           expect(token.expires_at.to_i).to be_within(2).of(Time.now.to_i + Ably::Token::DEFAULTS[:ttl])
-          expect(token.client_id).to eql(client_id)
+          expect(token.client_id).to eq(client_id)
         end
       end
     end

data/spec/acceptance/rest/channel_spec.rb

@@ -2,6 +2,8 @@ require "spec_helper"
 require "securerandom"
 
 describe "REST" do
+  include Ably::Modules::Conversions
+
   let(:client) do
     Ably::Rest::Client.new(api_key: api_key, environment: environment)
   end
@@ -45,25 +47,67 @@ describe "REST" do
 
     it "should return paged history" do
       page_1 = channel.history(limit: 1)
-      page_2 = page_1.next
-      page_3 = page_2.next
+      page_2 = page_1.next_page
+      page_3 = page_2.next_page
 
       all_items = [page_1[0], page_2[0], page_3[0]]
       expect(all_items.uniq).to eql(all_items)
 
       expect(page_1.size).to eql(1)
-      expect(page_1).to_not be_last
-      expect(page_1).to be_first
+      expect(page_1).to_not be_last_page
+      expect(page_1).to be_first_page
 
       # Page 2
       expect(page_2.size).to eql(1)
-      expect(page_2).to_not be_last
-      expect(page_2).to_not be_first
+      expect(page_2).to_not be_last_page
+      expect(page_2).to_not be_first_page
 
       # Page 3
       expect(page_3.size).to eql(1)
-      expect(page_3).to be_last
-      expect(page_3).to_not be_first
+      expect(page_3).to be_last_page
+      expect(page_3).to_not be_first_page
+    end
+  end
+
+  describe "options" do
+    let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
+    let(:channel) { client.channel(channel_name) }
+    let(:endpoint) do
+      client.endpoint.tap do |client_end_point|
+        client_end_point.user = key_id
+        client_end_point.password = key_secret
+      end
+    end
+
+    [:start, :end].each do |option|
+      describe ":{option}", webmock: true do
+        let!(:history_stub) {
+          stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?live=true&#{option}=#{milliseconds}").to_return(:body => '{}')
+        }
+
+        before do
+          channel.history(options)
+        end
+
+        context 'with milliseconds since epoch' do
+          let(:milliseconds) { as_since_epoch(Time.now) }
+          let(:options) { { option => milliseconds } }
+
+          specify 'are left unchanged' do
+            expect(history_stub).to have_been_requested
+          end
+        end
+
+        context 'with Time' do
+          let(:time) { Time.now }
+          let(:milliseconds) { as_since_epoch(time) }
+          let(:options) { { option => time } }
+
+          specify 'are left unchanged' do
+            expect(history_stub).to have_been_requested
+          end
+        end
+      end
     end
   end
 end

data/spec/acceptance/rest/presence_spec.rb

@@ -2,10 +2,18 @@ require "spec_helper"
 require "securerandom"
 
 describe "REST" do
+  include Ably::Modules::Conversions
+
   let(:client) do
     Ably::Rest::Client.new(api_key: api_key, environment: environment)
   end
 
+  let(:fixtures) do
+    TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
+      IdiomaticRubyWrapper(fixture, stop_at: [:client_data])
+    end
+  end
+
   describe "fetching presence" do
     let(:channel) { client.channel("persisted:presence_fixtures") }
     let(:presence) { channel.presence.get }
@@ -13,9 +21,65 @@ describe "REST" do
     it "should return current members on the channel" do
       expect(presence.size).to eql(4)
 
-      TestApp::APP_SPEC['channels'].first['presence'].each do |presence_hash|
-        presence_match = presence.find { |client| client['clientId'] == presence_hash['clientId'] }
-        expect(presence_match['clientData']).to eql(presence_hash['clientData'])
+      fixtures.each do |fixture|
+        presence_message = presence.find { |client| client[:client_id] == fixture[:client_id] }
+        expect(presence_message[:client_data]).to eq(fixture[:client_data])
+      end
+    end
+  end
+
+  describe "presence history" do
+    let(:channel) { client.channel("persisted:presence_fixtures") }
+    let(:history) { channel.presence.history }
+
+    it "should return recent presence activity" do
+      expect(history.size).to eql(4)
+
+      fixtures.each do |fixture|
+        presence_message = history.find { |client| client[:client_id] == fixture['clientId'] }
+        expect(presence_message[:client_data]).to eq(fixture[:client_data])
+      end
+    end
+  end
+
+  describe "options" do
+    let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
+    let(:presence) { client.channel(channel_name).presence }
+    let(:endpoint) do
+      client.endpoint.tap do |client_end_point|
+        client_end_point.user = key_id
+        client_end_point.password = key_secret
+      end
+    end
+
+    [:start, :end].each do |option|
+      describe ":{option}", webmock: true do
+        let!(:history_stub) {
+          stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true&#{option}=#{milliseconds}").to_return(:body => '{}')
+        }
+
+        before do
+          presence.history(options)
+        end
+
+        context 'with milliseconds since epoch' do
+          let(:milliseconds) { as_since_epoch(Time.now) }
+          let(:options) { { option => milliseconds } }
+
+          specify 'are left unchanged' do
+            expect(history_stub).to have_been_requested
+          end
+        end
+
+        context 'with Time' do
+          let(:time) { Time.now }
+          let(:milliseconds) { as_since_epoch(time) }
+          let(:options) { { option => time } }
+
+          specify 'are left unchanged' do
+            expect(history_stub).to have_been_requested
+          end
+        end
       end
     end
   end