pubnub 3.4.1 → 3.5.1

data/.yardoc/checksums

@@ -1,13 +0,0 @@
-lib/pubnub/client.rb 24d210ab228a4803805472666581d982de7e7460
-lib/pubnub/configuration.rb 16cd59eb2bba2d60b411817fc12807e37a55342f
-lib/pubnub/crypto.rb 5795f15e8380ab4e4df7b66002ba27a0ef6773ca
-lib/pubnub/daemon.rb 887fe6589269f6244ac45542d278107a143cc04b
-lib/pubnub/em/client.rb 8132d65f67e1128dc94c2cd7a81fcb2672efb367
-lib/pubnub/em/connection.rb 0e07699d0469d8f072d9b93a711173e169bf6973
-lib/pubnub/em/request.rb 6e95650a088ac04a419d18235cfe84a872803bff
-lib/pubnub/em/response.rb e750b47b62843dc39bfdc006b60d6552143b3b8a
-lib/pubnub/error.rb dad9a587bdeb0d53dc217a4f3e156bc6787106c1
-lib/pubnub.rb eab5c5b85a1760514e2d3a7d200f2b5f53690d09
-lib/pubnub/request.rb affdaa20d405404058de3f0ae19bbf2ef222a172
-lib/pubnub/response.rb 47a9a785572eae36391ec7da9f214efa8f826876
-lib/version.rb 47184c709077ffbfe1336763c37cfd9cbc62cd77

data/lib/pubnub/error.rb

@@ -1,23 +0,0 @@
-module Pubnub
-  module Error
-    class PresenceError  < RuntimeError;
-    end
-    class PublishError   < RuntimeError;
-    end
-    class SubscribeError < RuntimeError;
-    end
-    class InitError      < RuntimeError;
-    end
-    class PublishError   < RuntimeError;
-    end
-    class OperationError < RuntimeError
-      def operation_exception
-        #if @operation.present?
-        #  ("Pubnub::" + @operation.to_s.capitalize + "Error").constantize
-        #else
-          PubnubRequest::RequestError
-        #end
-      end
-    end
-  end
-end

data/lib/pubnub/request.rb

@@ -1,288 +0,0 @@
-require 'pubnub/configuration.rb'
-require 'pubnub/error.rb'
-require 'pubnub/response.rb'
-
-require 'openssl'
-require 'digest/sha2'
-require 'base64'
-
-require 'json'
-
-module Pubnub
-  class Request
-    include Pubnub::Configuration
-    include Pubnub::Error
-
-    attr_accessor :error_callback, :envelopes, :port, :timetoken, :operation, :response, :ssl, :channel, :callback, :cipher_key, :subscribe_key, :secret_key, :operation, :message, :publish_key
-
-    def initialize(options = {})
-      @options = options
-
-      @params         = options[:params]
-      @operation      = options[:operation]
-      @callback       = options[:callback]
-      @error_callback = options[:error_callback]
-      @error_callback = lambda { |x| puts "AN ERROR OCCURRED: #{x.msg}" } unless @error_callback
-      @channel        = options[:channel]
-      @message        = options[:message]
-      @timetoken      = options[:timetoken] || "0"
-      @timetoken      = options[:override_timetoken] if options[:override_timetoken]
-      @ssl            = options[:ssl]
-      @params         = options[:params]
-
-      @history_limit  = options[:limit]
-
-      @port           = options[:port]
-      @host           = options[:origin]
-      @query          = options[:query]
-
-      set_cipher_key(options, @cipher_key) if %w(publish subscribe history).include? @operation
-      set_message(options, @cipher_key) if %w(publish).include? @operation
-      set_publish_key(options, @publish_key) if %w(publish).include? @operation
-      set_subscribe_key(options, @subscribe_key) if %w(publish presence here_now history subscribe leave).include? @operation
-      set_secret_key(options, @secret_key) if %w(publish subscribe).include? @operation
-
-    end
-
-    def ssl=(ssl)
-      if ssl
-        @ssl = true
-        @port = 443
-      else
-        @ssl = false
-        @port = 80
-      end
-    end
-
-    def origin
-      if @ssl
-        @origin = 'https://' + @host
-        @port = 443
-      else
-        @origin = 'http://' + @host
-        @port = 80
-      end
-      @origin
-    end
-
-    def path
-      encode_path(case @operation
-                   when 'publish'
-                     [
-                         @operation,
-                         @publish_key,
-                         @subscribe_key,
-                         @secret_key,
-                         @channel,
-                         '0',
-                         @message.to_json
-                     ]
-                   when 'subscribe'
-                     [
-                         @operation,
-                         @subscribe_key,
-                         @channel,
-                         '0',
-                         @timetoken
-                     ]
-                   when 'presence'
-                     [
-                         'subscribe',
-                         @subscribe_key,
-                         @channel.to_s + '-pnpres',
-                         '0',
-                         @timetoken
-                     ]
-                   when 'time'
-                     [
-                         @operation,
-                         '0'
-                     ]
-                   when 'history'
-                     [
-                         'v2',
-                         'history',
-                         'sub-key',
-                         @subscribe_key,
-                         'channel',
-                         @channel
-                     ]
-                    when 'here_now'
-                      [
-                          'v2',
-                          'presence',
-                          'sub-key',
-                          @subscribe_key,
-                          'channel',
-                          @channel
-                      ]
-                    when 'leave'
-                      [
-                          'v2',
-                          'presence',
-                          'sub-key',
-                          @subscribe_key,
-                          'channel',
-                          @channel
-                      ]
-                    else
-                     raise("I can't create that URL for you due to unknown operation type.")
-                 end
-      )
-    end
-
-    def encode_path(request)
-      $log.debug 'ENCODING PATH'
-      path = URI.escape('/' + request.map{|i| i.to_s}.reject(&:empty?).join('/')).gsub(/\?/,'%3F')
-      if @operation == 'leave'
-        $log.debug "#{path}/leave"
-        "#{path}/leave"
-      else
-        $log.debug path
-        path
-      end
-    end
-
-    def params
-      flat = {}
-      @params.each do |param,val|
-        next if val.to_s.empty?
-        flat[param.to_s] = val.to_s
-      end
-      flat
-    end
-
-    def query
-      params.map do |param, value|
-        [param, value].join('=')
-      end.sort.join('&')
-    end
-
-    def handle_response(http)
-      @response = nil
-
-      if http.respond_to?(:body) && http.respond_to?(:code) && http.respond_to?(:message) && http.respond_to?(:headers) # httparty
-        @response = JSON.load(http.body)
-      else # em-http-request
-        @response = http.response.respond_to?(:content) ? JSON.load(http.response.content) : JSON.load(http.response)
-      end
-
-
-      @last_timetoken = @timetoken
-      @timetoken = @response[1] unless @operation == 'time'
-
-      if @cipher_key.present? && %w(subscribe history).include?(@operation)
-
-        response_array = Array.new
-        crypto = Pubnub::Crypto.new(@cipher_key)
-
-        if %w(subscribe history).include?(@operation)
-          iteration = @response[0]
-        else
-          iteration = @response
-        end
-
-        if iteration.class == Array
-          iteration.each do |msg|
-            response_array << crypto.decrypt(msg)
-          end if iteration
-        elsif iteration.class == String
-          response_array = [crypto.decrypt(iteration)]
-        end
-
-        case @operation
-          when 'subscribe'
-            @response[0] = response_array
-          when 'history'
-            json_response_data = JSON.load(http.response)
-            @response = [response_array, json_response_data[1], json_response_data[2]]
-        end
-      end
-
-      @envelopes = Array.new
-      if %w(subscribe history).include? @operation
-        @response.first.each_with_index do |res,index|
-          @envelopes << Pubnub::Response.new(:http => http, :index => index, :response => @response, :channel => @channel, :operation => @operation, :path => path, :query => query)
-        end
-      else
-        @envelopes << Pubnub::Response.new(:http => http, :channel => @channel, :response => @response, :operation => @operation, :path => path, :query => query)
-      end
-    end
-
-
-    private
-
-    def aes_encrypt(cipher_key, options, publish_request)
-
-      pc = Pubnub::Crypto.new(cipher_key)
-      publish_request.message = pc.encrypt(options[:message])
-
-    end
-
-    def set_cipher_key(options, self_cipher_key)
-      if self_cipher_key.present? && options[:cipher_key].present?
-        raise(OperationError, "existing cipher_key #{self_cipher_key} cannot be overridden at publish-time.")
-
-      elsif (self_cipher_key.present? && options[:cipher_key].blank?) || (self_cipher_key.blank? && options[:cipher_key].present?)
-
-        this_cipher_key = self_cipher_key || options[:cipher_key]
-        raise(OperationError, 'secret key must be a string.') if this_cipher_key.class != String
-        @cipher_key = this_cipher_key
-      end
-    end
-
-    def set_secret_key(options, self_secret_key)
-      if self_secret_key.present? && options[:secret_key].present?
-        raise(OperationError, "existing secret_key #{self_secret_key} cannot be overridden at publish-time.")
-
-      elsif (self_secret_key.present? && options[:secret_key].blank?) || (self_secret_key.blank? && options[:secret_key].present?)
-
-        my_secret_key = self_secret_key || options[:secret_key]
-        raise(OperationError, 'secret key must be a string.') if my_secret_key.class != String
-
-        signature       = '{ @publish_key, @subscribe_key, @secret_key, channel, message}'
-        digest          = OpenSSL::Digest.new('sha256')
-        key             = [my_secret_key]
-        hmac            = OpenSSL::HMAC.hexdigest(digest, key.pack('H*'), signature)
-        @secret_key = hmac
-      else
-        @secret_key = '0'
-      end
-    end
-
-    def set_message(options, self_cipher_key)
-      if options[:message].blank? && options[:message] != ''
-        raise(OperationError, 'message is a required parameter.')
-      else
-        my_cipher_key = options[:cipher_key] || self_cipher_key
-
-        if my_cipher_key.present?
-          @message = aes_encrypt(my_cipher_key, options, self)
-        else
-          @message = options[:message]
-        end
-      end
-    end
-
-    def set_publish_key(options, self_publish_key)
-      if options[:publish_key].blank? && self_publish_key.blank?
-        raise(OperationError, 'publish_key is a required parameter.')
-      elsif self_publish_key.present? && options[:publish_key].present?
-        raise(OperationError, "existing publish_key #{self_publish_key} cannot be overridden at publish-time.")
-      else
-        @publish_key = (self_publish_key || options[:publish_key]).to_s
-      end
-    end
-
-    def set_subscribe_key(options, self_subscribe_key)
-      if options[:subscribe_key].blank? && self_subscribe_key.blank?
-        raise(OperationError, 'subscribe_key is a required parameter.')
-      elsif self_subscribe_key.present? && options[:subscribe_key].present?
-        raise(OperationError, "existing subscribe_key #{self_subscribe_key} cannot be overridden at subscribe-time.")
-      else
-        @subscribe_key = (self_subscribe_key || options[:subscribe_key]).to_s
-      end
-    end
-
-  end
-end

data/lib/pubnub/response.rb

@@ -1,126 +0,0 @@
-class Pubnub::Response
-  attr_reader :message, :channel, :timetoken, :status_code
-  attr_reader :response, :path, :query
-  alias :msg :message
-
-  # Creates Pubnub::Response object based on options hash
-  #
-  # Sets @message, @channel, @timetoken, @status_code, :response attributes
-  # @message contains usable single message for callback
-  # @channel contains channel which was used in request
-  # @timetoken contains server timetoken
-  # @status_code contains status code of server response
-  # @response contains whole server response body which was used to build that Pubnub::Response
-  # @headers contains whole server response headers
-  #
-  # To properly init new response object it need :http, :response, :channel options
-  # While you pass :index option it will treat :response as array which size is greater than one
-  # In case you want create your custom error response, you have to pass :error_init option with true value and :message with your message
-  def initialize(options = {})
-    @path  = options[:path]
-    @query = options[:query]
-
-    if options[:error_init]
-      @message = options[:message]
-      @response = options[:message]
-      @timetoken = 0
-    else
-      if options[:http].respond_to?(:body) && options[:http].respond_to?(:code) && options[:http].respond_to?(:message) && options[:http].respond_to?(:headers)
-        httparty = true
-      else
-        httparty = false
-      end
-
-      if httparty
-        case options[:operation]
-          when 'publish'
-            set_for_httparty(options)
-          when 'subscribe'
-            set_for_httparty(options)
-          when 'presence'
-            set_for_httparty(options)
-          when 'history'
-            set_for_httparty(options)
-          when 'leave'
-            set_for_httparty(options)
-          when 'here_now'
-            set_for_httparty(options)
-          when 'time'
-            set_for_httparty(options)
-        end
-      else # EM.http_request
-        case options[:operation]
-          when 'publish'
-            set_for_em_http_request(options)
-          when 'subscribe'
-            set_for_em_http_request(options)
-          when 'presence'
-            set_for_em_http_request(options)
-          when 'history'
-            set_for_em_http_request(options)
-          when 'leave'
-            set_for_em_http_request(options)
-          when 'here_now'
-            set_for_em_http_request(options)
-          when 'time'
-            set_for_em_http_request(options)
-        end
-      end
-    end
-  end
-
-  # Simple compare to other object basing on string representation of response
-  # (see #to_s)
-  def ==(other)
-    @response == other.to_s
-  end
-
-  private
-
-  def set_for_httparty(options)
-    if options[:response][2] && options[:operation] == 'subscribe'
-      @channel = options[:index] ? options[:response][2].split(',')[options[:index]] : options[:channel]
-    else
-      @channel = options[:channel]
-    end
-
-    if options[:operation] == 'publish'
-      set_for_publish(options[:response][1],options[:response][2])
-    elsif %w(here_now leave).include? options[:operation]
-      @message = options[:response]
-    else
-      @timetoken = options[:response][1]
-      @message = options[:index] ? options[:response][0][options[:index]] : options[:response][0]
-    end
-
-    @status_code = options[:http].response.code
-    @headers = options[:http].headers.inspect
-    @response = options[:http].body
-  end
-
-  def set_for_em_http_request(options)
-    if options[:response][2] && options[:operation] == 'subscribe'
-      @channel = options[:index] ? options[:response][2].split(',')[options[:index]] : options[:channel]
-    else
-      @channel = options[:channel]
-    end
-
-    if options[:operation] == 'publish'
-      set_for_publish(options[:response][1],options[:response][2])
-    elsif %w(here_now leave).include? options[:operation]
-      @message = options[:response]
-    else
-      @timetoken = options[:response][1]
-      @message = options[:index] ? options[:response][0][options[:index]] : options[:response][0]
-    end
-
-    @status_code = options[:http].response_header.status.to_i
-    @headers = options[:http].response_header
-    @response = options[:http].response
-  end
-
-  def set_for_publish(msg, timetoken)
-    @message = msg
-    @timetoken = timetoken
-  end
-end