ably 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b13770cd1f3131e42728090c7f7e7b28b56d02be
-  data.tar.gz: fe42558802cdccd07138ea9ce370e53091336988
+  metadata.gz: 5b99a13d28dd5bd7e6b1d35e6ad0d718e759fbb3
+  data.tar.gz: fa7e7aac5a7acf5cc74bfc1da6faf48913ef0f36
 SHA512:
-  metadata.gz: 8795d186ce87c181ac86919760afc845ff49531e2946554b39ca30b8057a82018f57c59d0b22cf7f66270734b83e5adc8c9b8ed1dffb2ec9aee58a78c45f6eed
-  data.tar.gz: 46837150a1ae0f22675d25656772cb50f08e34b9cbd0d472f0a2ff12c069fe2d7229ac45f1f6b900dd78e08d384716dba3da3ba0f5fd7fd0bff688c60a9fdeca
+  metadata.gz: 8d2771237651cc84bc83f3de5c6e5438f6e04f57b36432d4394995f5ed7deae8e097d397d149a13e23993116d1f1f2266de046e7c1cca42e36ae776a92a6b5b6
+  data.tar.gz: 9f12b4aef062743e6bbfd7b40388dd7582b42d9634efb062a66ea4a181f815d5c44473e97a48b6c9b3c6862bd07d1bcf12e2d366006da5925f20f9c7d1d8a35e

data/ably.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "faraday", "~> 0.9"
   spec.add_runtime_dependency "json"
   spec.add_runtime_dependency "websocket-driver"
+  spec.add_runtime_dependency "msgpack"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/lib/ably/auth.rb

@@ -1,9 +1,8 @@
-require "json"
-require "faraday"
-require "securerandom"
+require 'json'
+require 'faraday'
+require 'securerandom'
 
 require "ably/rest/middleware/external_exceptions"
-require "ably/rest/middleware/parse_json"
 
 module Ably
   # Auth is responsible for authentication with {https://ably.io Ably} using basic or token authentication
@@ -369,7 +368,7 @@ module Ably
       @connection_options ||= {
         builder: middleware,
         headers: {
-          accept:     "application/json",
+          accept:     client.mime_type,
           user_agent: user_agent
         },
         request: {
@@ -384,18 +383,15 @@ module Ably
     # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
     def middleware
       @middleware ||= Faraday::RackBuilder.new do |builder|
-        # Convert request params to "www-form-urlencoded"
-        builder.use Faraday::Request::UrlEncoded
-
-        # Parse JSON response bodies
-        builder.use Ably::Rest::Middleware::ParseJson
-
-        # Log HTTP requests if debug_http option set
-        builder.response :logger if @debug_http
+        setup_middleware builder
 
         # Raise exceptions if response code is invalid
         builder.use Ably::Rest::Middleware::ExternalExceptions
 
+
+        # Log HTTP requests if log level is DEBUG option set
+        builder.response :logger if client.log_level == Logger::DEBUG
+
         # Set Faraday's HTTP adapter
         builder.adapter Faraday.default_adapter
       end

data/lib/ably/models/idiomatic_ruby_wrapper.rb

@@ -1,30 +1,46 @@
 require 'logger'
 
+module Ably::Modules
+  module Conversions
+    private
+    # Creates or returns an {IdiomaticRubyWrapper} ensuring it never wraps itself
+    #
+    # @return {IdiomaticRubyWrapper}
+    def IdiomaticRubyWrapper(object, options = {})
+      case object
+      when Ably::Models::IdiomaticRubyWrapper
+        object
+      else
+        Ably::Models::IdiomaticRubyWrapper.new(object, options)
+      end
+    end
+  end
+end
+
 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 = IdiomaticRubyWrapper.new({ 'keyValue' => 'true' })
+  #   # or recommended to avoid wrapping wrapped objects
+  #   ruby_hash = IdiomaticRubyWrapper({ 'keyValue' => 'true' })
   #
-  # ruby_hash[:none] # => nil
-  # ruby_hash.none # => nil
+  #   ruby_hash[:key_value] # => 'true'
+  #   ruby_hash.key_value # => 'true'
+  #   ruby_hash[:key_value] = 'new_value'
+  #   ruby_hash.key_value # => 'new_value'
   #
-  # @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)`
+  #   ruby_hash[:none] # => nil
+  #   ruby_hash.none # => nil
   #
   # @!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
+    include Ably::Modules::Conversions
 
     attr_reader :stop_at
 
@@ -172,33 +188,5 @@ module Ably::Models
 
       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,16 +1,8 @@
 module Ably::Modules
   module Conversions
-    private
-    # Returns object as {IdiomaticRubyWrapper}
-    def IdiomaticRubyWrapper(object, options = {})
-      case object
-      when Ably::Models::IdiomaticRubyWrapper
-        object
-      else
-        Ably::Models::IdiomaticRubyWrapper.new(object, options)
-      end
-    end
+    extend self
 
+    private
     def as_since_epoch(time, granularity: :ms)
       case time
       when Time
@@ -43,5 +35,34 @@ module Ably::Modules
         raise ArgumentError, "invalid granularity"
       end
     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').
+        gsub(/([a-zA-Z])(\d)/,'\1_\2').
+        tr("-", "_").
+        downcase.
+        to_sym
+    end
+
+    def convert_to_lower_case(key)
+      key.to_s.gsub('_', '')
+    end
   end
 end

data/lib/ably/modules/enum.rb

@@ -0,0 +1,201 @@
+module Ably::Modules
+  # Enum brings Enum like functionality used in other languages to Ruby
+  #
+  # @example
+  #   class House
+  #     extend Ably::Moduels::Enum
+  #     CONSTRUCTION = ruby_enum('CONSTRUCTION',
+  #       :brick,
+  #       :steel,
+  #       :wood
+  #     )
+  #   end
+  #
+  #   House::CONSTRUCTION(:brick).to_i # => 0
+  #   House::CONSTRUCTION('Wood').to_i # => 2
+  #   House::CONSTRUCTION.Wood == :wood # => true
+  #
+  module Enum
+    private
+
+    class Base; end
+
+    # ruby_enum returns an Enum-like class that should be assigned to a constant in your class
+    # The first `enum_name` argument must match the constant name so that the coercion method is available
+    #
+    # @example
+    #   class House
+    #     extend Ably::Moduels::Enum
+    #     CONSTRUCTION = ruby_enum('CONSTRUCTION', :brick)
+    #   end
+    #
+    #   # ensures the following coercion method is available
+    #   House::CONSTRUCTION(:brick) # => CONSTRUCTION.Brick
+    #
+    def ruby_enum(enum_name, *values)
+      enum_class = Class.new(Enum::Base) do
+        include Conversions
+        extend Conversions
+
+        @enum_name = enum_name
+        @by_index  = {}
+        @by_symbol = {}
+
+        class << self
+          include Enumerable
+
+          def get(identifier)
+            case identifier
+            when Symbol
+              by_symbol.fetch(identifier)
+            when String
+              by_symbol.fetch(convert_to_snake_case_symbol(identifier))
+            when Numeric
+              by_index.fetch(identifier)
+            when ancestors.first
+              identifier
+            else
+              if identifier.class.ancestors.include?(Enum::Base)
+                by_symbol.fetch(identifier.to_sym)
+              else
+                raise KeyError, "Cannot find Enum matching identifier '#{identifier}' argument as it is an unacceptable type: #{identifier.class}"
+              end
+            end
+          end
+
+          def [](*args)
+            get(*args)
+          end
+
+          def to_s
+            name
+          end
+
+          def size
+            by_symbol.keys.length
+          end
+          alias_method :length, :size
+
+          # Method ensuring this {Enum} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
+          def each(&block)
+            by_symbol.each do |key, value|
+              yield value
+            end
+          end
+
+          # The name provided in the constructor for this Enum
+          def name
+            @enum_name
+          end
+
+          private
+          attr_reader :by_index, :by_symbol
+
+          # Define constants for each of the Enum values
+          # e.g. define_constants(:dog) creates Enum::Dog
+          def define_values(values)
+            raise RuntimeError, "#{name} Enum cannot be modified" if by_index.frozen?
+
+            # Allow another Enum to be used as a set of values
+            if values.length == 1 && klass = values.first
+              if klass.kind_of?(Class) && klass.ancestors.include?(Enum::Base)
+                values = values.first.map(&:to_sym)
+              end
+            end
+
+            values.map do |value|
+              # Convert any key => index_value pairs into array pairs
+              Array(value)
+            end.flatten(1).each_with_index do |name, index|
+              name, index = name if name.kind_of?(Array) # name is key => index_value pair
+              raise ArgumentError, "Index value '#{index}' is invalid" unless index.kind_of?(Numeric)
+
+              camel_name  = convert_to_mixed_case(name, force_camel: true)
+              name_symbol = convert_to_snake_case_symbol(name)
+              enum        = new(camel_name, name_symbol, index.to_i)
+
+              by_index[index.to_i]   = enum
+              by_symbol[name_symbol] = enum
+
+              define_singleton_method camel_name do
+                enum
+              end
+            end
+
+            by_index.freeze
+            by_symbol.freeze
+          end
+        end
+
+        def initialize(name, symbol, index)
+          @name   = name
+          @index  = index
+          @symbol = symbol
+        end
+
+        def to_s
+          "#{self.class}.#{name}"
+        end
+
+        def to_i
+          index
+        end
+
+        def to_sym
+          symbol
+        end
+
+        def to_json(*args)
+          %{"#{symbol}"}
+        end
+
+        # Allow comparison of Enum objects based on:
+        #
+        # * Other equivalent Enum objects
+        # * Symbol
+        # * String
+        # * Integer index of Enum
+        #
+        def ==(other)
+          case other
+          when Symbol
+            self.to_sym == convert_to_snake_case_symbol(other)
+          when String
+            self.to_sym == convert_to_snake_case_symbol(other)
+          when Numeric
+            self.to_i == other.to_i
+          when self.class
+            self.to_i == other.to_i
+          else
+            false
+          end
+        end
+
+        private
+        attr_reader :name, :index, :symbol
+
+        define_values values
+      end
+
+      # Convert any comparable object into this Enum
+      # @example
+      #   class Example
+      #     DOGS = ruby_enum('DOGS', :terrier, :labrador, :great_dane)
+      #   end
+      #
+      #   Example.DOGS(:great_dane) # => <DOGS.GreatDane>
+      #   Example.DOGS(0) # => <DOGS.Terrier>
+      #   Example.new.DOGS(0) # => <DOGS.Terrier>
+      #
+      define_singleton_method enum_name do |val|
+        enum_class.get(val)
+      end
+
+      define_method enum_name do |val|
+        enum_class.get(val)
+      end
+
+      enum_class
+    end
+  end
+end

data/lib/ably/modules/event_emitter.rb

@@ -0,0 +1,81 @@
+module Ably
+  module Modules
+    # EventEmitter provides methods to attach to public events and trigger events on any class instance
+    #
+    # EventEmitter are typically used for public interfaces, and as such, may be overriden in
+    # the classes to enforce `event` names match expected values.
+    #
+    # @example
+    #   class Example
+    #     include Modules::EventEmitter
+    #   end
+    #
+    #   event_emitter = Example.new
+    #   event_emitter.on(:signal) { |name| puts "Signal #{name} received" }
+    #   event_emitter.trigger :signal, "Test"
+    #   #=> "Signal Test received"
+    #
+    module EventEmitter
+      module ClassMethods
+        attr_reader :event_emitter_coerce_proc
+
+        # Configure included EventEmitter
+        #
+        # @param [Hash] options the options for the {EventEmitter}
+        # @option options [Proc] :coerce_into A lambda/Proc that is used to coerce the event names for all events. This is useful to ensure the event names conform to a naming or type convention.
+        #
+        # @example
+        #   configure_event_emitter coerce_into: Proc.new { |event| event.to_sym }
+        #
+        def configure_event_emitter(options = {})
+          @event_emitter_coerce_proc = options[:coerce_into]
+        end
+
+        # Ensure @event_emitter_coerce_proc option is passed down to any classes that inherit the class with callbacks
+        def inherited(subclass)
+          subclass.instance_variable_set('@event_emitter_coerce_proc', @event_emitter_coerce_proc)
+          super
+        end
+      end
+
+      # On receiving an event matching the event_name, call the provided block
+      def on(event_name, &block)
+        callbacks[callbacks_event_coerced(event_name)] << block
+      end
+
+      # Trigger an event with event_name that will in turn call all matching callbacks setup with `on`
+      def trigger(event_name, *args)
+        callbacks[callbacks_event_coerced(event_name)].each { |cb| cb.call(*args) }
+      end
+
+      # Remove all callbacks for event_name.
+      #
+      # If a block is provided, only callbacks matching that block signature will be removed.
+      # If block is not provided, all callbacks matching the event_name will be removed.
+      def off(event_name, &block)
+        if block_given?
+          callbacks[callbacks_event_coerced(event_name)].delete(block)
+        else
+          callbacks[callbacks_event_coerced(event_name)].clear
+        end
+      end
+
+      private
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def callbacks_event_coerced(event_name)
+        if self.class.event_emitter_coerce_proc
+          self.class.event_emitter_coerce_proc.call(event_name)
+        else
+          event_name
+        end
+      end
+    end
+  end
+end