ably 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9ccb54c36b77720433fde71a6580424b91cbfc0
-  data.tar.gz: fb242c4a0ce0c6ddd96c217d9904ee5926fcf465
+  metadata.gz: da8f27b90ddc5d18cefb088124f42507675fba7e
+  data.tar.gz: d4079770ea27bc17d35eb4791b1f05820a940877
 SHA512:
-  metadata.gz: 9b681c12026a2fd84f3e5b71dfd901513a90f4c9cdb04ed9bef887543ce8d29a9ce1ef5e18e281090e7eae3940732146743948a8d17efa0fd0d09da0b03a6bc9
-  data.tar.gz: 116e3a2d88b423cd4af365656af2269467cc21601567897c3dd26efc0425c5d73e578a5d924021aa957661da1c417af527cc49dc8ef83ed4eeb82990e5dd6e7a
+  metadata.gz: 7a2413536347bdd4da0c993ddf3c9926f6639be60c84945e627e7a4127b8b6360d1ae77e55ed6132c71d8138b87323ff83087ba5cb57f5ef1a6ed2c9572ec322
+  data.tar.gz: 4562af003c001e631344c160685b91f2e7f7018a11cb32e2c2572a8c949939a6b3ab16a8b25a0957077f2b96a7b07e71b7d8ef4b93420b10bf76859987bbfc28

data/lib/ably.rb

@@ -1,8 +1,8 @@
-require "ably/support"
+require "ably/modules/conversions"
+require "ably/modules/http_helpers"
 
 require "ably/auth"
 require "ably/exceptions"
-require "ably/message"
 require "ably/rest"
 require "ably/realtime"
 require "ably/token"

data/lib/ably/auth.rb

@@ -26,7 +26,7 @@ module Ably
   #   @return [Hash] {Ably::Auth} options configured for this client
 
   class Auth
-    include Ably::Support
+    include Ably::Modules::HttpHelpers
 
     attr_reader :options, :current_token
     alias_method :auth_options, :options
@@ -84,7 +84,7 @@ module Ably
     # @option options [Integer] :ttl          validity time in seconds for the requested {Ably::Token}.  Limits may apply, see {http://docs.ably.io/other/authentication/}
     # @option options [Hash]    :capability   canonicalised representation of the resource paths and associated operations
     # @option options [Boolean] :query_time   when true will query the {https://ably.io Ably} system for the current time instead of using the local time
-    # @option options [Integer] :timestamp    the time of the of the request in seconds since the epoch
+    # @option options [Time]    :timestamp    the time of the of the request
     # @option options [String]  :nonce        an unquoted, unescaped random string of at least 16 characters
     # @option options [Boolean] :force        obtains a new token even if the current token is valid
     #
@@ -126,7 +126,7 @@ module Ably
     # @option options [Integer] :ttl          validity time in seconds for the requested {Ably::Token}.  Limits may apply, see {http://docs.ably.io/other/authentication/}
     # @option options [Hash]    :capability   canonicalised representation of the resource paths and associated operations
     # @option options [Boolean] :query_time   when true will query the {https://ably.io Ably} system for the current time instead of using the local time
-    # @option options [Integer] :timestamp    the time of the of the request in seconds since the epoch
+    # @option options [Time]    :timestamp    the time of the of the request
     # @option options [String]  :nonce        an unquoted, unescaped random string of at least 16 characters
     #
     # @yield [options] (optional) if an auth block is passed to this method, then this block will be called to create a new token request object
@@ -174,7 +174,7 @@ module Ably
     # @option options [Integer] :ttl        validity time in seconds for the requested {Ably::Token}.  Limits may apply, see {http://docs.ably.io/other/authentication/}
     # @option options [Hash]    :capability canonicalised representation of the resource paths and associated operations
     # @option options [Boolean] :query_time when true will query the {https://ably.io Ably} system for the current time instead of using the local time
-    # @option options [Integer] :timestamp  the time of the of the request in seconds since the epoch
+    # @option options [Time]    :timestamp  the time of the of the request
     # @option options [String]  :nonce      an unquoted, unescaped random string of at least 16 characters
     # @return [Hash]
     #
@@ -201,7 +201,7 @@ module Ably
       timestamp = if token_options[:query_time]
         client.time
       else
-        Time.now
+        token_options.delete(:timestamp) || Time.now
       end.to_i
 
       token_request = {
@@ -263,6 +263,17 @@ module Ably
       end
     end
 
+    # Auth params used in URI endpoint for Realtime connections
+    #
+    # @return [Hash] Auth params for a new Realtime connection
+    def auth_params
+      if using_token_auth?
+        token_auth_params
+      else
+        basic_auth_params
+      end
+    end
+
     # True if prerequisites for creating a new token request are present
     #
     # One of the following criterion must be met:
@@ -278,19 +289,40 @@ module Ably
     private
     attr_reader :auth_callback
 
+    # Basic Auth HTTP Authorization header value
     def basic_auth_header
       raise Ably::Exceptions::InsecureRequestError, "Cannot use Basic Auth over non-TLS connections" unless client.use_tls?
       "Basic #{encode64("#{api_key}")}"
     end
 
-    def token_auth_header
+    def token_auth_id
       current_token_id = if token_id
         token_id
       else
         authorise.id
       end
+    end
 
-      "Bearer #{encode64(current_token_id)}"
+    # Token Auth HTTP Authorization header value
+    def token_auth_header
+      "Bearer #{encode64(token_auth_id)}"
+    end
+
+    # Basic Auth params to authenticate the Realtime connection
+    def basic_auth_params
+      raise Ably::Exceptions::InsecureRequestError, "Cannot use Basic Auth over non-TLS connections" unless client.use_tls?
+      # TODO: Change to key_secret when API is updated
+      {
+        key_id: key_id,
+        key_value: key_secret
+      }
+    end
+
+    # Token Auth params to authenticate the Realtime connection
+    def token_auth_params
+      {
+        access_token: token_auth_id
+      }
     end
 
     # Sign the request params using the secret

data/lib/ably/modules/conversions.rb

@@ -0,0 +1,58 @@
+module Ably::Modules
+  module Conversions
+    private
+    # Take a Hash object and make it more Ruby like converting all keys
+    # into symbols with snake_case notation
+    def rubify(*args)
+      convert_hash_recursively(*args) do |key|
+        convert_to_snake_case(key).to_sym
+      end
+    end
+
+    # Take a Hash object and make it more Java like converting all keys
+    # into strings with mixedCase notation
+    def javify(*args)
+      convert_hash_recursively(*args) do |key|
+        convert_to_mixed_case(key).to_s
+      end
+    end
+
+    def convert_hash_recursively(hash, ignore: [], &processing_block)
+      raise ArgumentError, "Processing block is missing" unless block_given?
+
+      return hash unless hash.kind_of?(Hash)
+
+      Hash[hash.map do |key, val|
+        key_sym       = yield(key)
+        converted_val = if ignore.include?(key_sym)
+          val
+        else
+          convert_hash_recursively(val, ignore: ignore, &processing_block)
+        end
+
+        [key_sym, converted_val]
+      end]
+    end
+
+    def convert_to_mixed_case(string_like)
+      string_like.to_s.
+        split('_').
+        each_with_index.map do |str, index|
+          if index > 0
+            str.capitalize
+          else
+            str
+          end
+        end.
+        join
+    end
+
+    def convert_to_snake_case(string_like)
+      string_like.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/ably/{support.rb → modules/http_helpers.rb}

@@ -1,7 +1,7 @@
-require "base64"
+require 'base64'
 
-module Ably
-  module Support
+module Ably::Modules
+  module HttpHelpers
     protected
     def encode64(text)
       Base64.encode64(text).gsub("\n", '')

data/lib/ably/realtime.rb

@@ -6,31 +6,13 @@ require "ably/realtime/channel"
 require "ably/realtime/client"
 require "ably/realtime/connection"
 
+require "ably/realtime/models/shared"
+require "ably/realtime/models/error_info"
+require "ably/realtime/models/message"
+require "ably/realtime/models/protocol_message"
+
 module Ably
   module Realtime
-    # Actions which are sent by the Ably Realtime API
-    #
-    # The values correspond to the ints which the API
-    # understands.
-    ACTIONS = {
-      heartbeat:    0,
-      ack:          1,
-      nack:         2,
-      connect:      3,
-      connected:    4,
-      disconnect:   5,
-      disconnected: 6,
-      close:        7,
-      closed:       8,
-      error:        9,
-      attach:       10,
-      attached:     11,
-      detach:       12,
-      detached:     13,
-      presence:     14,
-      message:      15
-    }
-
     def self.new(*args)
       Ably::Realtime::Client.new(*args)
     end

data/lib/ably/realtime/channel.rb

@@ -3,49 +3,93 @@ module Ably
     class Channel
       include Callbacks
 
+      STATES = {
+        initialised: 1,
+        attaching:   2,
+        attached:    3,
+        detaching:   4,
+        detached:    5,
+        failed:      6
+      }.freeze
+
       attr_reader :client, :name
 
+      # Retrieve a state symbol by the integer value
+      def self.state_sym_for(state_int)
+        @states_index_by_int ||= STATES.invert.freeze
+        @states_index_by_int[state_int]
+      end
+
       def initialize(client, name)
-        @state         = :initialised
-        @client        = client
-        @name          = name
-        @subscriptions = Hash.new { |hash, key| hash[key] = [] }
+        @client          = client
+        @name            = name
+        @subscriptions   = Hash.new { |hash, key| hash[key] = [] }
+        @queue           = []
 
-        on(:message) do |message|
-          event = message[:name]
+        set_state :initialised
 
+        on(:message) do |message|
           @subscriptions[:all].each { |cb| cb.call(message) }
-          @subscriptions[event].each { |cb| cb.call(message) }
+          @subscriptions[message.name].each { |cb| cb.call(message) }
+        end
+
+        on(:attached) do
+          set_state :attached
+          process_queue
         end
       end
 
+      # Current Channel state, will always be one of {STATES}
+      #
+      # @return [Symbol] state
+      def state
+        self.class.state_sym_for(@state)
+      end
+
+      def state?(check_state)
+        check_state = STATES.fetch(check_state) if check_state.kind_of?(Symbol)
+        @state == check_state
+      end
+
       def publish(event, data)
-        message = { name: event, data: data }
+        queue << { name: event, data: data, timestamp: Time.now.to_i * 1000 }
 
         if attached?
-          client.send_message(name, message)
+          process_queue
         else
-          on(:attached) { client.send_message(name, message) }
           attach
         end
       end
 
       def subscribe(event = :all, &blk)
+        event = event.to_s unless event == :all
+        attach unless attached?
         @subscriptions[event] << blk
       end
 
-      private
-      def attached?
-        @state == :attached
-      end
-
       def attach
-        unless @state == :attaching
-          @state = :attaching
+        unless state?(:attaching)
+          set_state :attaching
           client.attach_to_channel(name)
-          on(:attached) { @state = :attached }
         end
       end
+
+      def attached?
+        state?(:attached)
+      end
+
+      private
+      attr_reader :queue
+
+      def set_state(new_state)
+        new_state = STATES.fetch(new_state) if new_state.kind_of?(Symbol)
+        raise ArgumentError, "#{new_state} is not a valid state" unless STATES.values.include?(new_state)
+        @state = new_state
+      end
+
+      def process_queue
+        client.send_messages(name, queue.shift(100)) until queue.empty?
+      end
     end
   end
 end

data/lib/ably/realtime/client.rb

@@ -1,31 +1,71 @@
 module Ably
   module Realtime
-    # A client for the Ably Realtime API
+    # Client for the Ably Realtime API
+    #
+    # @!attribute [r] auth
+    #   (see Ably::Rest::Client#auth)
+    # @!attribute [r] client_id
+    #   (see Ably::Rest::Client#client_id)
+    # @!attribute [r] auth_options
+    #   (see Ably::Rest::Client#auth_options)
+    # @!attribute [r] tls
+    #   (see Ably::Rest::Client#tls)
+    # @!attribute [r] environment
+    #   (see Ably::Rest::Client#environment)
     class Client
       include Callbacks
+      extend Forwardable
 
-      DOMAIN = "staging-realtime.ably.io"
+      DOMAIN = 'realtime.ably.io'
 
+      attr_reader :channels, :auth
+      def_delegators :auth, :client_id, :auth_options
+      def_delegators :@rest_client, :tls, :environment, :use_tls?
+
+      # Creates a {Ably::Realtime::Client Realtime Client} and configures the {Ably::Auth} object for the connection.
+      #
+      # @param (see Ably::Rest::Client#initialize)
+      # @option options (see Ably::Rest::Client#initialize)
+      # @option options [Boolean] :queue_messages If false, this disables the default behaviour whereby the library queues messages on a connection in the disconnected or connecting states
+      # @option options [Boolean] :echo_messages  If false, prevents messages originating from this connection being echoed back on the same connection
+      # @option options [String]  :recover        This option allows a connection to inherit the state of a previous connection that may have existed under an different instance of the Realtime library.
+      # @option options [Boolean] :debug_http     Send HTTP & websocket debugging information for all messages/requests sent and received to STDOUT
+      #
+      # @yield (see Ably::Rest::Client#initialize)
+      # @yieldparam (see Ably::Rest::Client#initialize)
+      # @yieldreturn (see Ably::Rest::Client#initialize)
+      #
+      # @return [Ably::Realtime::Client]
+      #
+      # @example
+      #    # create a new client authenticating with basic auth
+      #    client = Ably::Realtime::Client.new('key.id:secret')
+      #
+      #    # create a new client and configure a client ID used for presence
+      #    client = Ably::Realtime::Client.new(api_key: 'key.id:secret', client_id: 'john')
+      #
       def initialize(options)
-        @rest_client = Ably::Rest::Client.new(options)
+        @rest_client    = Ably::Rest::Client.new(options)
+        @auth           = @rest_client.auth
+        @message_serial = 0
 
-        on(:attached) do |data|
-          channel = channel(data[:channel])
+        on(:attached) do |protocol_message|
+          channel = channel(protocol_message.channel)
 
           channel.trigger(:attached)
         end
 
-        on(:message) do |data|
-          channel = channel(data[:channel])
+        on(:message) do |protocol_message|
+          channel = channel(protocol_message.channel)
 
-          data[:messages].each do |message|
+          protocol_message.messages.each do |message|
             channel.trigger(:message, message)
           end
         end
       end
 
       def token
-        @token ||= @rest_client.request_token
+        @token ||= rest_client.request_token
       end
 
       # Return a Realtime Channel for the given name
@@ -37,34 +77,34 @@ module Ably
         @channels[name] ||= Ably::Realtime::Channel.new(self, name)
       end
 
-      def send_message(channel_name, message)
+      def send_messages(channel_name, messages)
         payload = {
-          action:   ACTIONS[:message],
+          action:   Models::ProtocolMessage.action!(:message),
           channel:  channel_name,
-          messages: [message]
-        }.to_json
+          messages: messages
+        }
+
+        payload.merge!(clientId: client_id) unless client_id.nil?
 
         connection.send(payload)
       end
 
       def attach_to_channel(channel_name)
         payload = {
-          action: ACTIONS[:attach],
+          action:  Models::ProtocolMessage.action!(:attach),
           channel: channel_name
-        }.to_json
+        }
 
         connection.send(payload)
       end
 
-      def use_tls?
-        @rest_client.use_tls?
-      end
-
+      # Default Ably Realtime endpoint used for all requests
+      #
+      # @return [URI::Generic]
       def endpoint
-        @endpoint ||= URI::Generic.build(
+        URI::Generic.build(
           scheme: use_tls? ? "wss" : "ws",
-          host:   DOMAIN,
-          query:  "access_token=#{token.id}&binary=false&timestamp=#{Time.now.to_i}"
+          host:   [environment, DOMAIN].compact.join('-')
         )
       end
 
@@ -76,6 +116,20 @@ module Ably
           EventMachine.connect(host, port, Connection, self)
         end
       end
+
+      # When true, will send HTTP & websocket debugging information for all messages/requests sent and received to STDOUT
+      #
+      # @return [Boolean]
+      def debug_http?
+        rest_client.debug_http?
+      end
+
+      def log_http(message)
+        $stdout.puts "#{Time.now.strftime('%H:%M:%S')} #{message}" if debug_http?
+      end
+
+      private
+      attr_reader :rest_client
     end
   end
 end