ably-pubsub-core 0.0.1.pre

data/lib/ably/models/device_push_details.rb

@@ -0,0 +1,94 @@
+module Ably::Modules
+  module Conversions
+    private
+    # Convert device_push_details argument to a {Ably::Models::DevicePushDetails} object
+    #
+    # @param device_push_details [Ably::Models::DevicePushDetails,Hash,nil] A device push notification details object
+    #
+    # @return [Ably::Models::DevicePushDetails]
+    #
+    def DevicePushDetails(device_push_details)
+      case device_push_details
+      when Ably::Models::DevicePushDetails
+        device_push_details
+      else
+        Ably::Models::DevicePushDetails.new(device_push_details)
+      end
+    end
+  end
+end
+
+module Ably::Models
+  # An object with the push notification details for {DeviceDetails} object
+  #
+  class DevicePushDetails < Ably::Exceptions::BaseAblyException
+    include Ably::Modules::ModelCommon
+
+    # @param hash_object   [Hash,nil]  Device push detail attributes
+    #
+    def initialize(hash_object = {})
+      @raw_hash_object = hash_object || {}
+      @hash_object     = IdiomaticRubyWrapper(@raw_hash_object)
+    end
+
+    # The current state of the push registration.
+    #
+    # @spec PCP4
+    #
+    # @return [Symbol]
+    #
+    def state
+      attributes[:state]
+    end
+
+    def state=(val)
+      unless val.nil? || val.kind_of?(String)
+        raise ArgumentError, "state must be nil or a string value"
+      end
+      attributes[:state] = val
+    end
+
+    # A JSON object of key-value pairs that contains of the push transport and address.
+    #
+    # @spec PCP3
+    #
+    # @return [Hash, nil]
+    #
+    def recipient
+      attributes[:recipient] || {}
+    end
+
+    def recipient=(val)
+      unless val.nil? || val.kind_of?(Hash)
+        raise ArgumentError, "recipient must be nil or a Hash value"
+      end
+      attributes[:recipient] = val
+    end
+
+    # An {Ably::Models::ErrorInfo} object describing the most recent error when the state is Failing or Failed.
+    #
+    # @spec PCP2
+    #
+    # @return [Ably::Models::ErrorInfo]
+    #
+    def error_reason
+      attributes[:error_reason]
+    end
+
+    def error_reason=(val)
+      unless val.nil? || val.kind_of?(Hash) || val.kind_of?(Ably::Models::ErrorInfo)
+        raise ArgumentError, "error_reason must be nil, a Hash value or a ErrorInfo object"
+      end
+
+      attributes[:error_reason] = if val.nil?
+        nil
+      else
+        ErrorInfo(val)
+      end
+    end
+
+    def attributes
+      @hash_object
+    end
+  end
+end

data/lib/ably/models/error_info.rb

@@ -0,0 +1,104 @@
+module Ably::Modules
+  module Conversions
+    private
+    # Convert error_details argument to a {ErrorInfo} object
+    #
+    # @param error_details [ErrorInfo,Hash] Error info attributes
+    #
+    # @return [ErrorInfo]
+    #
+    def ErrorInfo(error_details)
+      case error_details
+      when Ably::Models::ErrorInfo
+        error_details
+      else
+        Ably::Models::ErrorInfo.new(error_details)
+      end
+    end
+  end
+end
+
+module Ably::Models
+  # An exception type encapsulating error information containing
+  # an Ably-specific error code and generic status code.
+  #
+  class ErrorInfo < Ably::Exceptions::BaseAblyException
+    include Ably::Modules::ModelCommon
+
+    def initialize(hash_object)
+      @raw_hash_object = hash_object
+      @hash_object     = IdiomaticRubyWrapper(hash_object.clone.freeze)
+    end
+
+    # Ably error code.
+    #
+    # @spec TI1
+    #
+    # @return [Integer]
+    #
+    def code
+      attributes[:code]
+    end
+
+    # This is included for REST responses to provide a URL for additional help on the error code.
+    #
+    # @spec TI4
+    #
+    # @return [String]
+    #
+    def href
+      attributes[:href]
+    end
+
+    # Additional message information, where available.
+    #
+    # @spec TI1
+    #
+    # @return [String]
+    #
+    def message
+      attributes[:message]
+    end
+
+    # Information pertaining to what caused the error where available.
+    #
+    # @spec TI1
+    #
+    # @return [Ably::Models::ErrorInfo]
+    #
+    def cause
+      attributes[:cause]
+    end
+
+    # HTTP Status Code corresponding to this error, where applicable.
+    #
+    # @spec TI1
+    #
+    # @return [Integer]
+    #
+    def status_code
+      attributes[:status_code]
+    end
+
+    # If a request fails, the request ID must be included in the ErrorInfo returned to the user.
+    #
+    # @spec RSC7c
+    #
+    # @return [String]
+    #
+    def request_id
+      attributes[:request_id]
+    end
+    alias_method :status, :status_code
+
+    def attributes
+      @hash_object
+    end
+
+    def to_s
+      error_href = href || (code ? "https://help.ably.io/error/#{code}" : '')
+      see_msg = " -> see #{error_href} for help" unless message.to_s.include?(error_href.to_s)
+      "<Error: #{message} (code: #{code}, http status: #{status} request_id: #{request_id} cause: #{cause})>#{see_msg}"
+    end
+  end
+end

data/lib/ably/models/http_paginated_response.rb

@@ -0,0 +1,112 @@
+require 'ably/models/paginated_result'
+
+module Ably::Models
+  # HTTP respones object from Rest#request object
+  # Wraps any Ably HTTP response that supports paging and provides methods to iterate through
+  # the pages using {#first}, {#next}, {#has_next?} and {#last?}
+
+  class HttpPaginatedResponse < PaginatedResult
+    # Retrieve the first page of results.
+    # When used as part of the {Ably::Realtime} library, it will return a {Ably::Util::SafeDeferrable} object,
+    #   and allows an optional success callback block to be provided.
+    #
+    # @return [HttpPaginatedResponse,Ably::Util::SafeDeferrable]
+    #
+    def first(&success_callback)
+      async_wrap_if_realtime(success_callback) do
+        return nil unless supports_pagination?
+        HttpPaginatedResponse.new(client.get(pagination_url('first')), base_url, client, pagination_options, &each_block)
+      end
+    end
+
+    # Retrieve the next page of results.
+    # When used as part of the {Ably::Realtime} library, it will return a {Ably::Util::SafeDeferrable} object,
+    #   and allows an optional success callback block to be provided.
+    #
+    # @return [HttpPaginatedResponse,Ably::Util::SafeDeferrable]
+    #
+    def next(&success_callback)
+      async_wrap_if_realtime(success_callback) do
+        return nil unless has_next?
+        HttpPaginatedResponse.new(client.get(pagination_url('next')), base_url, client, pagination_options, &each_block)
+      end
+    end
+
+    # The HTTP status code of the response.
+    #
+    # @spec HP4
+    #
+    # @return [Integer]
+    #
+    def status_code
+      http_response.status.to_i
+    end
+
+    # Whether statusCode indicates success. This is equivalent to 200 <= statusCode < 300.
+    #
+    # @spec HP5
+    #
+    # @return [Boolean]
+    #
+    def success?
+      (200..299).include?(http_response.status.to_i)
+    end
+
+    # The error code if the X-Ably-Errorcode HTTP header is sent in the response.
+    #
+    # @spec HP6
+    #
+    # @return [Integer]
+    #
+    def error_code
+      if http_response.headers['X-Ably-Errorcode']
+        http_response.headers['X-Ably-Errorcode'].to_i
+      end
+    end
+
+    # The error message if the X-Ably-Errormessage HTTP header is sent in the response.
+    #
+    # @spec HP7
+    #
+    # @return [String]
+    #
+    def error_message
+      http_response.headers['X-Ably-Errormessage']
+    end
+
+    # The headers of the response.
+    #
+    # @spec HP8
+    #
+    # @return [Hash<String, String>]
+    #
+    def headers
+      http_response.headers || {}
+    end
+
+    # Farady compatible response object used when an exception is raised
+    # @api private
+    class ErrorResponse
+      def initialize(status, error_code, error_message)
+        @status = status
+        @error_code = error_code
+        @error_message = error_message
+      end
+
+      def status
+        @status
+      end
+
+      def headers
+        {
+          'X-Ably-Errorcode' => @error_code,
+          'X-Ably-Errormessage' => @error_message
+        }
+      end
+
+      def body
+        nil
+      end
+    end
+  end
+end

data/lib/ably/models/idiomatic_ruby_wrapper.rb

@@ -0,0 +1,235 @@
+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 Hash 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
+  #
+  # @!attribute [r] stop_at
+  #   @return [Array<Symbol,String>] array of keys that this wrapper should stop wrapping at to preserve the underlying Hash as is
+  #
+  class IdiomaticRubyWrapper
+    include Enumerable
+    include Ably::Modules::Conversions
+    include Ably::Modules::MessagePack
+
+    attr_reader :stop_at
+
+    # Creates an IdiomaticRubyWrapper around the mixed case Hash object
+    #
+    # @attribute [Hash] mixedCaseHashObject mixed case Hash object
+    # @attribute [Array<Symbol,String>] stop_at array of keys that this wrapper should stop wrapping at to preserve the underlying Hash as is
+    #
+    def initialize(mixedCaseHashObject, options = {})
+      stop_at = options.fetch(:stop_at, [])
+
+      if mixedCaseHashObject.kind_of?(IdiomaticRubyWrapper)
+        $stderr.puts "<IdiomaticRubyWrapper#initialize> WARNING: Wrapping a IdiomaticRubyWrapper with another IdiomaticRubyWrapper"
+      end
+
+      @attributes = mixedCaseHashObject
+      @stop_at = Array(stop_at).each_with_object({}) do |key, object|
+        object[convert_to_snake_case_symbol(key)] = true
+      end.freeze
+    end
+
+    def [](key)
+      value = attributes[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)
+      attributes[source_key_for(key)] = value
+    end
+
+    def fetch(key, default = nil)
+      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
+      attributes.size
+    end
+
+    def empty?
+      attributes.empty?
+    end
+
+    def keys
+      map { |key, value| key }
+    end
+
+    def values
+      map { |key, value| value }
+    end
+
+    def has_key?(key)
+      attributes.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
+      return to_enum(:each) unless block_given?
+
+      attributes.each do |key, value|
+        key = convert_to_snake_case_symbol(key)
+        value = self[key]
+        yield key, value
+      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
+
+    # @!attribute [r] Hash
+    # @return [Hash] Access to the raw Hash object provided to the constructor of this wrapper
+    def attributes
+      @attributes
+    end
+
+    # Takes the underlying Hash object and returns it in as a JSON ready Hash object using camelCase for compability with the Ably service.
+    # Note name clashes are ignored and will result in loss of one or more values
+    # @example
+    #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
+    #   wrapper.as_json => { 'mixedCase': true, 'snakeCase': 1 }
+    def as_json(*args)
+      attributes.each_with_object({}) do |key_val, new_hash|
+        key                      = key_val[0]
+        mixed_case_key           = convert_to_mixed_case(key)
+        wrapped_val              = self[key]
+        wrapped_val              = wrapped_val.as_json(args) if wrapped_val.kind_of?(IdiomaticRubyWrapper)
+
+        new_hash[mixed_case_key] = wrapped_val
+      end
+    end
+
+    # Converts the current wrapped mixedCase object to JSON
+    # using snakedCase syntax as expected by the Realtime API
+    def to_json(*args)
+      as_json(args).to_json
+    end
+
+    # Generate a symbolized Hash object representing the underlying Hash in a Ruby friendly format.
+    # Note name clashes are ignored and will result in loss of one or more values
+    # @example
+    #   wrapper = IdiomaticRubyWrapper({ 'mixedCase': true, mixed_case: false, 'snake_case': 1 })
+    #   wrapper.to_hash => { mixed_case: true, snake_case: 1 }
+    def to_hash(*args)
+      each_with_object({}) do |key_val, object|
+        key, val    = key_val
+        val         = val.to_hash(args) if val.kind_of?(IdiomaticRubyWrapper)
+        object[key] = val
+      end
+    end
+
+    # Method to create a duplicate of the underlying Hash object
+    # Useful when underlying Hash is frozen
+    def dup
+      Ably::Models::IdiomaticRubyWrapper.new(attributes.dup, stop_at: stop_at.keys)
+    end
+
+    # Freeze the underlying data
+    def freeze
+      attributes.freeze
+    end
+
+    def to_s
+      attributes.to_s
+    end
+
+    # @!attribute [r] hash
+    # @return [Integer] Compute a hash-code for this hash. Two hashes with the same content will have the same hash code
+    def hash
+      attributes.hash
+    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 = [
+        lambda { |key_sym| convert_to_mixed_case(key_sym) },
+        lambda { |key_sym| key_sym.to_sym },
+        lambda { |key_sym| key_sym.to_s },
+        lambda { |key_sym| convert_to_mixed_case(key_sym).to_sym },
+        lambda { |key_sym| convert_to_lower_case(key_sym) },
+        lambda { |key_sym| convert_to_lower_case(key_sym).to_sym },
+        lambda { |key_sym| convert_to_mixed_case(key_sym, force_camel: true) },
+        lambda { |key_sym| convert_to_mixed_case(key_sym, force_camel: true).to_sym }
+      ]
+
+      preferred_format = format_preferences.detect do |format|
+        attributes.has_key?(format.call(symbolized_key))
+      end || format_preferences.first
+
+      preferred_format.call(symbolized_key)
+    end
+  end
+end