ably 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da8f27b90ddc5d18cefb088124f42507675fba7e
-  data.tar.gz: d4079770ea27bc17d35eb4791b1f05820a940877
+  metadata.gz: ea2c608bdda1c7910a086adf11b7d32854df487c
+  data.tar.gz: d490375a690b51efbe14ebc765ec7786b114a658
 SHA512:
-  metadata.gz: 7a2413536347bdd4da0c993ddf3c9926f6639be60c84945e627e7a4127b8b6360d1ae77e55ed6132c71d8138b87323ff83087ba5cb57f5ef1a6ed2c9572ec322
-  data.tar.gz: 4562af003c001e631344c160685b91f2e7f7018a11cb32e2c2572a8c949939a6b3ab16a8b25a0957077f2b96a7b07e71b7d8ef4b93420b10bf76859987bbfc28
+  metadata.gz: 7d3801488036052b450c6e81cc824e5c223432c697642e3aebe0d8f27c77c2eb1784d84693b5d232110dc9080bd285b6f828094bb383e88d436069922b264bc3
+  data.tar.gz: 272c272b9beb386d6ae7ca33fd8ee4868cd7ff4d4e0fdd8951a5df65df3af465d586fd5a79325e509b49b7e17f88ca1ce9a5e757f06d976449fd322ecda88912

data/lib/ably.rb

@@ -1,10 +1,13 @@
-require "ably/modules/conversions"
-require "ably/modules/http_helpers"
+%w(modules models).each do |namespace|
+  Dir.glob(File.expand_path("ably/#{namespace}/*.rb", File.dirname(__FILE__))).each do |file|
+    require file
+  end
+end
 
 require "ably/auth"
 require "ably/exceptions"
-require "ably/rest"
 require "ably/realtime"
+require "ably/rest"
 require "ably/token"
 require "ably/version"
 

data/lib/ably/auth.rb

@@ -26,6 +26,7 @@ module Ably
   #   @return [Hash] {Ably::Auth} options configured for this client
 
   class Auth
+    include Ably::Modules::Conversions
     include Ably::Modules::HttpHelpers
 
     attr_reader :options, :current_token
@@ -37,7 +38,7 @@ module Ably
     # @param [Hash] auth_options          see {Ably::Rest::Client#initialize}
     # @yield [auth_options]               see {Ably::Rest::Client#initialize}
     def initialize(client, auth_options, &auth_block)
-      auth_options = auth_options.dup
+      auth_options = auth_options.clone
 
       @client        = client
       @options       = auth_options
@@ -160,9 +161,12 @@ module Ably
         create_token_request(token_options)
       end
 
+      token_request = IdiomaticRubyWrapper(token_request)
+
       response = client.post("/keys/#{token_request.fetch(:id)}/requestToken", token_request, send_auth_header: false)
+      body = IdiomaticRubyWrapper(response.body)
 
-      Ably::Token.new(response.body.fetch(:access_token))
+      Ably::Token.new(body.fetch(:access_token))
     end
 
     # Creates and signs a token request that can then subsequently be used by any client to request a token
@@ -192,7 +196,7 @@ module Ably
     def create_token_request(options = {})
       token_attributes   = %w(id client_id ttl timestamp capability nonce)
 
-      token_options      = options.dup
+      token_options      = options.clone
       request_key_id     = token_options.delete(:key_id) || key_id
       request_key_secret = token_options.delete(:key_secret) || key_secret
 

data/lib/ably/models/idiomatic_ruby_wrapper.rb

@@ -0,0 +1,204 @@
+require 'logger'
+
+module Ably::Models
+  # Wraps JSON objects returned by Ably service to appear as Idiomatic Ruby Hashes with symbol keys
+  # It recursively wraps containing Hashes, but will stop wrapping at arrays, any other non Hash object, or any key matching the `:stops_at` options
+  # It also provides methods matching the symbolic keys for convenience
+  #
+  # @example
+  # ruby_hash = IdiomaticRubyWrapper.new({ 'keyValue' => 'true' })
+  # # or recommended to avoid wrapping wrapped objects
+  # ruby_hash = IdiomaticRubyWrapper({ 'keyValue' => 'true' })
+
+  # ruby_hash[:key_value] # => 'true'
+  # ruby_hash.key_value # => 'true'
+  # ruby_hash[:key_value] = 'new_value'
+  # ruby_hash.key_value # => 'new_value'
+  #
+  # ruby_hash[:none] # => nil
+  # ruby_hash.none # => nil
+  #
+  # @note It is recommended you include {Ably::Modules::Conversions Ably::Modules::Conversions} so that you can use the object creation syntax `IdiomaticRubyWrappers(hash_or_another_idiomatic_ruby_wrapper)`
+  #
+  # @!attribute [r] stop_at
+  #   @return [Array<Symbol,String>] array of keys that this wrapper should stop wrapping at to preserve the underlying JSON hash as is
+  #
+  class IdiomaticRubyWrapper
+    include Enumerable
+
+    attr_reader :stop_at
+
+    # Creates an IdiomaticRubyWrapper around the mixed case JSON object
+    #
+    # @attribute [Hash] mixedCaseJsonObject mixed case JSON object
+    # @attribute [Array<Symbol,String>] stop_at array of keys that this wrapper should stop wrapping at to preserve the underlying JSON hash as is
+    #
+    def initialize(mixedCaseJsonObject, stop_at: [])
+      if mixedCaseJsonObject.kind_of?(IdiomaticRubyWrapper)
+        $stderr.puts "<IdiomaticRubyWrapper#initialize> WARNING: Wrapping a IdiomaticRubyWrapper with another IdiomaticRubyWrapper"
+      end
+
+      @json = mixedCaseJsonObject
+      @stop_at = Array(stop_at).each_with_object({}) do |key, hash|
+        hash[convert_to_snake_case_symbol(key)] = true
+      end.freeze
+    end
+
+    def [](key)
+      value = json[source_key_for(key)]
+      if stop_at?(key) || !value.kind_of?(Hash)
+        value
+      else
+        IdiomaticRubyWrapper.new(value, stop_at: stop_at)
+      end
+    end
+
+    def []=(key, value)
+      json[source_key_for(key)] = value
+    end
+
+    def fetch(key, default = nil, &missing_block)
+      if has_key?(key)
+        self[key]
+      else
+        if default
+          default
+        elsif block_given?
+          yield key
+        else
+          raise KeyError, "key not found: #{key}"
+        end
+      end
+    end
+
+    def size
+      json.size
+    end
+
+    def keys
+      map { |key, value| key }
+    end
+
+    def values
+      map { |key, value| value }
+    end
+
+    def has_key?(key)
+      json.has_key?(source_key_for(key))
+    end
+
+    # Method ensuring this {IdiomaticRubyWrapper} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
+    def each(&block)
+      json.each do |key, value|
+        key = convert_to_snake_case_symbol(key)
+        value = self[key]
+        if block_given?
+          block.call key, value
+        else
+          yield key, value
+        end
+      end
+    end
+
+    # Compare object based on Hash equivalent
+    def ==(other)
+      return false unless other.kind_of?(self.class) || other.kind_of?(Hash)
+
+      other = other.to_hash if other.kind_of?(self.class)
+      to_hash == other
+    end
+
+    def method_missing(method_sym, *arguments)
+      key = method_sym.to_s.gsub(%r{=$}, '')
+      return super if !has_key?(key)
+
+      if method_sym.to_s.match(%r{=$})
+        raise ArgumentError, "Cannot set #{method_sym} with more than one argument" unless arguments.length == 1
+        self[key] = arguments.first
+      else
+        raise ArgumentError, "Cannot pass an argument to #{method_sym} when retrieving its value" unless arguments.empty?
+        self[method_sym]
+      end
+    end
+
+    # Access to the raw JSON object provided to the constructer of this wrapper
+    def json
+      @json
+    end
+
+    # Converts the current wrapped mixedCase object to a JSON string
+    # using the provided mixedCase syntax
+    def to_json(*args)
+      json.to_json
+    end
+
+    # Generate a symbolized Hash object representing the underlying JSON in a Ruby friendly format
+    def to_hash
+      each_with_object({}) do |key_val, hash|
+        key, val = key_val
+        hash[key] = val
+      end
+    end
+
+    # Method to create a duplicate of the underlying JSON object
+    # Useful when underlying JSON is frozen
+    def dup
+      Ably::Models::IdiomaticRubyWrapper.new(json.dup)
+    end
+
+    private
+    def stop_at?(key)
+      @stop_at.has_key?(key)
+    end
+
+    # We assume by default all keys are interchangeable between :this_format and 'thisFormat'
+    # However, this method will find other fallback formats such as CamelCase or :symbols if a matching
+    # key is not found in mixedCase.
+    def source_key_for(symbolized_key)
+      format_preferences = [
+        -> (key_sym) { convert_to_mixed_case(key_sym) },
+        -> (key_sym) { key_sym.to_sym },
+        -> (key_sym) { key_sym.to_s },
+        -> (key_sym) { convert_to_mixed_case(key_sym).to_sym },
+        -> (key_sym) { convert_to_lower_case(key_sym) },
+        -> (key_sym) { convert_to_lower_case(key_sym).to_sym },
+        -> (key_sym) { convert_to_mixed_case(key_sym, force_camel: true) },
+        -> (key_sym) { convert_to_mixed_case(key_sym, force_camel: true).to_sym }
+      ]
+
+      preferred_format = format_preferences.detect do |format|
+        json.has_key?(format.call(symbolized_key))
+      end || format_preferences.first
+
+      preferred_format.call(symbolized_key)
+    end
+
+    # Convert key to mixedCase from mixed_case
+    def convert_to_mixed_case(key, force_camel: false)
+      key.to_s.
+        split('_').
+        each_with_index.map do |str, index|
+          if index > 0 || force_camel
+            str.capitalize
+          else
+            str
+          end
+        end.
+        join
+    end
+
+    # Convert key to :snake_case from snakeCase
+    def convert_to_snake_case_symbol(key)
+      key.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase.
+        to_sym
+    end
+
+    def convert_to_lower_case(key)
+      key.to_s.gsub('_', '')
+    end
+  end
+end

data/lib/ably/modules/conversions.rb

@@ -1,58 +1,47 @@
 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
+    # Returns object as {IdiomaticRubyWrapper}
+    def IdiomaticRubyWrapper(object, options = {})
+      case object
+      when Ably::Models::IdiomaticRubyWrapper
+        object
+      else
+        Ably::Models::IdiomaticRubyWrapper.new(object, options)
       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]
+    def as_since_epoch(time, granularity: :ms)
+      case time
+      when Time
+        time.to_f * multiplier_from_granularity(granularity)
+      when Numeric
+        time
+      else
+        raise ArgumentError, "time argument must be a Numeric or Time object"
+      end.to_i
     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
+    def as_time_from_epoch(time, granularity: :ms)
+      case time
+      when Numeric
+        Time.at(time / multiplier_from_granularity(granularity))
+      when Time
+        time
+      else
+        raise ArgumentError, "time argument must be a Numeric or Time object"
+      end
     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
+    def multiplier_from_granularity(granularity)
+      case granularity
+      when :ms # milliseconds
+        1_000.0
+      when :s # seconds
+        1.0
+      else
+        raise ArgumentError, "invalid granularity"
+      end
     end
   end
 end

data/lib/ably/realtime/channel.rb

@@ -1,6 +1,7 @@
 module Ably
   module Realtime
     class Channel
+      include Ably::Modules::Conversions
       include Callbacks
 
       STATES = {
@@ -52,7 +53,7 @@ module Ably
       end
 
       def publish(event, data)
-        queue << { name: event, data: data, timestamp: Time.now.to_i * 1000 }
+        queue << { name: event, data: data, timestamp: as_since_epoch(Time.now) }
 
         if attached?
           process_queue

data/lib/ably/realtime/connection.rb

@@ -1,6 +1,7 @@
 module Ably
   module Realtime
     class Connection < EventMachine::Connection
+      include Ably::Modules::Conversions
       include Callbacks
 
       def initialize(client)
@@ -41,7 +42,7 @@ module Ably
       # WebSocket::Driver interface
       def url
         URI(client.endpoint).tap do |endpoint|
-          endpoint.query = URI.encode_www_form(client.auth.auth_params.merge(timestamp: Time.now.to_i, binary: false))
+          endpoint.query = URI.encode_www_form(client.auth.auth_params.merge(timestamp: as_since_epoch(Time.now), binary: false))
         end.to_s
       end
 
@@ -52,17 +53,17 @@ module Ably
       private
       attr_reader :client, :driver, :message_serial
 
-      def add_message_serial_if_ack_required_to(data)
-        if Models::ProtocolMessage.ack_required?(data[:action])
-          add_message_serial_to(data) { yield }
+      def add_message_serial_if_ack_required_to(protocol_message)
+        if Models::ProtocolMessage.ack_required?(protocol_message[:action])
+          add_message_serial_to(protocol_message) { yield }
         else
           yield
         end
       end
 
-      def add_message_serial_to(data)
+      def add_message_serial_to(protocol_message)
         @message_serial += 1
-        data.merge!(msg_serial: @message_serial)
+        protocol_message[:msgSerial] = @message_serial
         yield
       rescue StandardError => e
         @message_serial -= 1

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

@@ -17,7 +17,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( message code status ).each do |attribute|

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

@@ -24,7 +24,7 @@ module Ably::Realtime::Models
     def initialize(json_object, protocol_message)
       @protocol_message = protocol_message
       @raw_json_object  = json_object
-      @json_object      = rubify(@raw_json_object, ignore: [:data]).freeze
+      @json_object      = IdiomaticRubyWrapper(@raw_json_object.clone.freeze, stop_at: [:data])
     end
 
     %w( name client_id ).each do |attribute|
@@ -42,7 +42,7 @@ module Ably::Realtime::Models
     end
 
     def sender_timestamp
-      Time.at(json[:timestamp] / 1000.0) if json[:timestamp]
+      as_time_from_epoch(json[:timestamp]) if json[:timestamp]
     end
 
     def ably_timestamp
@@ -56,14 +56,12 @@ module Ably::Realtime::Models
     def to_json_object
       raise RuntimeError, ":name is missing, cannot generate valid JSON for Message" unless name
 
-      json_object = json.dup.tap do |json_object|
-        json_object[:timestamp] = Time.now.to_i * 1000 unless sender_timestamp
+      json.dup.tap do |json_object|
+        json_object[:timestamp] = as_since_epoch(Time.now) unless sender_timestamp
       end
-
-      javify(json_object)
     end
 
-    def to_json
+    def to_json(*args)
       to_json_object.to_json
     end