pubnub-picklive 3.3.0.7

data/lib/pubnub.rb

@@ -0,0 +1,413 @@
+## www.pubnub.com - PubNub realtime push service in the cloud.
+## http://www.pubnub.com/blog/ruby-push-api - Ruby Push API Blog
+
+## PubNub Real Time Push APIs and Notifications Framework
+## Copyright (c) 2012 PubNub
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.3 Real-time Push Cloud API
+## -----------------------------------
+
+require 'base64'
+require 'open-uri'
+require 'uri'
+
+require 'pubnub_crypto'
+require 'pubnub_request'
+
+require 'eventmachine'
+require 'em-http-request'
+require 'yajl'
+require 'json'
+require 'uuid'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+
+
+class Pubnub
+
+  SUCCESS_RESPONSE = 200
+  MSG_TOO_LARGE_RESPONSE = 400
+
+  TIMEOUT_BAD_RESPONSE_CODE = 1
+  TIMEOUT_BAD_JSON_RESPONSE = 0.5
+  TIMEOUT_GENERAL_ERROR = 1
+  TIMEOUT_SUBSCRIBE = 310
+  TIMEOUT_NON_SUBSCRIBE = 5
+
+  class PresenceError < RuntimeError;
+  end
+  class PublishError < RuntimeError;
+  end
+  class SubscribeError < RuntimeError;
+  end
+  class InitError < RuntimeError;
+  end
+
+  attr_accessor :publish_key, :subscribe_key, :secret_key, :cipher_key, :ssl, :channel, :origin, :session_uuid
+
+  ORIGIN_HOST = 'pubsub.pubnub.com'
+  #ORIGIN_HOST = 'test.pubnub.com'
+
+  def initialize(*args)
+
+    if args.size == 5 # passing in named parameters
+
+      @publish_key = args[0].to_s
+      @subscribe_key = args[1].to_s
+      @secret_key = args[2].to_s
+      @cipher_key = args[3].to_s
+      @ssl = args[4]
+
+    elsif args.size == 1 && args[0].class == Hash # passing in an options hash
+
+      options_hash = HashWithIndifferentAccess.new(args[0])
+      @publish_key = options_hash[:publish_key].blank? ? nil : options_hash[:publish_key].to_s
+      @subscribe_key = options_hash[:subscribe_key].blank? ? nil : options_hash[:subscribe_key].to_s
+      @secret_key = options_hash[:secret_key].blank? ? nil : options_hash[:secret_key].to_s
+      @cipher_key = options_hash[:cipher_key].blank? ? nil : options_hash[:cipher_key].to_s
+      @ssl = options_hash[:ssl].blank? ? false : true
+      @logger = options_hash[:logger]
+
+    else
+      raise(InitError, "Initialize with either a hash of options, or exactly 5 named parameters.")
+    end
+
+    @session_uuid = uuid
+    verify_init
+  end
+
+  def verify_init
+    # publish_key and cipher_key are both optional.
+    raise(InitError, "subscribe_key is a mandatory parameter.") if @subscribe_key.blank?
+  end
+
+
+  def publish(options)
+    options = HashWithIndifferentAccess.new(options)
+    publish_request = PubnubRequest.new(:operation => :publish)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    publish_request.ssl = @ssl
+    publish_request.set_origin(options)
+    publish_request.set_channel(options)
+    publish_request.set_callback(options)
+    publish_request.set_cipher_key(options, self.cipher_key)
+    publish_request.set_message(options, self.cipher_key)
+    publish_request.set_publish_key(options, self.publish_key)
+    publish_request.set_subscribe_key(options, self.subscribe_key)
+    publish_request.set_secret_key(options, self.secret_key)
+
+
+    publish_request.format_url!
+
+    check_for_em publish_request
+  end
+
+  def subscribe(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    operation = options[:operation].nil? ? :subscribe : :presence
+
+    subscribe_request = PubnubRequest.new(:operation => operation, :session_uuid => @session_uuid)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    subscribe_request.ssl = @ssl
+    subscribe_request.set_origin(options)
+    subscribe_request.set_channel(options)
+    subscribe_request.set_callback(options)
+    subscribe_request.set_cipher_key(options, self.cipher_key) unless subscribe_request.operation == "presence"
+
+    subscribe_request.set_subscribe_key(options, self.subscribe_key)
+
+    format_url_options = options[:override_timetoken].present? ? options[:override_timetoken] : nil
+    subscribe_request.format_url!(format_url_options)
+
+    check_for_em subscribe_request
+
+  end
+
+  def presence(options)
+    usage_error = "presence() requires :channel and :callback options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
+    end
+
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
+    end
+
+    subscribe(options.merge(:operation => "presence"))
+
+  end
+
+
+  def here_now(options = nil)
+    usage_error = "here_now() requires :channel and :callback options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
+    end
+
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
+    end
+
+    here_now_request = PubnubRequest.new(:operation => :here_now)
+
+    here_now_request.ssl = @ssl
+    here_now_request.set_channel(options)
+    here_now_request.set_callback(options)
+
+    here_now_request.set_subscribe_key(options, self.subscribe_key)
+
+    here_now_request.format_url!
+    check_for_em here_now_request
+
+  end
+
+  def detailed_history(options = nil)
+    usage_error = "detailed_history() requires :channel, :callback, and :count options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
+    end
+
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:count] && options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
+    end
+
+
+    detailed_history_request = PubnubRequest.new(:operation => :detailed_history)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    # /detailed_history/SUBSCRIBE_KEY/CHANNEL/JSONP_CALLBACK/LIMIT
+
+    detailed_history_request.ssl = @ssl
+    detailed_history_request.set_channel(options)
+    detailed_history_request.set_callback(options)
+    detailed_history_request.set_cipher_key(options, self.cipher_key)
+
+    detailed_history_request.set_subscribe_key(options, self.subscribe_key)
+
+    detailed_history_request.history_count = options[:count]
+    detailed_history_request.history_start = options[:start]
+    detailed_history_request.history_end = options[:end]
+    detailed_history_request.history_reverse = options[:reverse]
+
+    detailed_history_request.format_url!
+    check_for_em detailed_history_request
+
+  end
+
+  def history(options = nil)
+    usage_error = "history() requires :channel, :callback, and :limit options."
+    if options.class != Hash
+      raise(ArgumentError, usage_error)
+    end
+
+    options = HashWithIndifferentAccess.new(options) unless (options == nil)
+
+    unless options[:limit] && options[:channel] && options[:callback]
+      raise(ArgumentError, usage_error)
+    end
+
+
+    history_request = PubnubRequest.new(:operation => :history)
+
+    #TODO: refactor into initializer code on request instantiation
+
+    # /history/SUBSCRIBE_KEY/CHANNEL/JSONP_CALLBACK/LIMIT
+
+    history_request.ssl = @ssl
+    history_request.set_channel(options)
+    history_request.set_callback(options)
+    history_request.set_cipher_key(options, self.cipher_key)
+
+    history_request.set_subscribe_key(options, self.subscribe_key)
+    history_request.history_limit = options[:limit]
+
+    history_request.format_url!
+    check_for_em history_request
+
+  end
+
+  def time(options)
+    options = HashWithIndifferentAccess.new(options)
+    raise(PubNubRuntimeError, "You must supply a callback.") if options['callback'].blank?
+
+    time_request = PubnubRequest.new(:operation => :time)
+    time_request.set_callback(options)
+
+    time_request.format_url!
+    check_for_em time_request
+  end
+
+  def my_callback(x, quiet = false)
+    if quiet !=false
+      puts("mycallback says: #{x.to_s}")
+    else
+      ""
+    end
+
+  end
+
+  def uuid
+    UUID.new.generate
+  end
+
+  def check_for_em request
+    if EM.reactor_running?
+      _request(request, true)
+    else
+      EM.run do
+        _request(request)
+      end
+    end
+  end
+
+  private
+
+  def _request(request, is_reactor_running = false)
+    request.format_url!
+    EM.schedule {
+      begin
+
+        operation_timeout = %w(subscribe presence).include?(request.operation) ? TIMEOUT_SUBSCRIBE : TIMEOUT_NON_SUBSCRIBE
+        conn = EM::HttpRequest.new(request.url, :inactivity_timeout => operation_timeout) #client times out in 310s unless the server returns or timeout first
+        req = conn.get()
+
+        req.errback{
+          logAndRetryGeneralError(is_reactor_running, req, request)
+        }
+
+        req.callback {
+
+          if %w(subscribe presence).include?(request.operation)
+            if (checkForBadJSON(req) == true && request.operation == "subscribe")
+              logAndRetryBadJSON(is_reactor_running, req, request)
+            else
+              processGoodResponse(is_reactor_running, req, request)
+            end
+          else
+            if req.response_header.http_status.to_i != SUCCESS_RESPONSE
+
+              begin
+                server_response = Yajl.load(req.response)
+                request.callback.call(server_response)
+              rescue => e
+                request.callback.call([0, "Bad server response: #{req.response_header.http_status.to_i}"])
+              ensure
+                EM.stop unless is_reactor_running
+              end
+
+              else
+                processGoodResponse(is_reactor_running, req, request)
+              end
+          end
+
+        }
+
+      rescue EventMachine::ConnectionError, RuntimeError => e # RuntimeError for catching "EventMachine not initialized"
+        error_message = "Network Error: #{e.message}"
+        puts(error_message)
+        [0, error_message]
+      end
+    }
+  end
+
+  def checkForBadJSON(req)
+    jsonError = false
+    begin
+      JSON.parse(req.response)
+    rescue => e
+      jsonError = true
+    end
+    jsonError
+  end
+
+  def processGoodResponse(is_reactor_running, req, request)
+
+    if (req.response_header.http_status.to_i != SUCCESS_RESPONSE)
+
+      unless (req.response_header.http_status.to_i == MSG_TOO_LARGE_RESPONSE)
+        logAndRetryBadResponseCode(is_reactor_running, req, request)
+      end
+
+    else
+
+      request.package_response!(req.response)
+      cycle = request.callback.call(request.response)
+
+      if %w(subscribe presence).include?(request.operation) && (cycle != false || request.first_request?)
+        _request(request, is_reactor_running)
+      else
+        EM.stop unless is_reactor_running
+      end
+    end
+  end
+
+  def logAndRetryGeneralError(is_reactor_running, req, request)
+    errMsg = "#{Time.now}: Network connectivity issue while attempting to reach #{request.url}"
+    logError(errMsg, request.url)
+    retryRequest(is_reactor_running, req, request, TIMEOUT_GENERAL_ERROR)
+  end
+
+  def logAndRetryBadJSON(is_reactor_running, req, request)
+    errMsg = "#{Time.now}: Retrying from bad JSON: #{req.response.to_s}"
+    logError(errMsg, request.url)
+    retryRequest(is_reactor_running, req, request, TIMEOUT_BAD_JSON_RESPONSE)
+  end
+
+  def logAndRetryBadResponseCode(is_reactor_running, req, request)
+    errMsg = "#{Time.now}: Retrying from bad server response code: (#{req.response_header.http_status.to_i}) #{req.response.to_s}"
+    logError(errMsg, request.url)
+    retryRequest(is_reactor_running, req, request, TIMEOUT_BAD_RESPONSE_CODE)
+  end
+
+  def logError(errMsg, url)
+    logger.debug("url: #{url}")
+    logger.debug("#{errMsg}")
+    logger.debug("")
+  end
+
+  def retryRequest(is_reactor_running, req, request, delay)
+
+    if %w(subscribe presence).include?(request.operation)
+      EM::Timer.new(delay) do
+        _request(request, is_reactor_running)
+      end
+    else
+      error_msg = [0, "Request to #{request.url} failed."]
+
+      request.set_error(true)
+      request.callback.call(error_msg)
+
+      logger.debug(error_msg)
+
+      EM.stop unless is_reactor_running
+    end
+
+  end
+
+  def logger
+    @logger ||= init_default_logger
+  end
+
+  def init_default_logger
+    logger = Logger.new("#{Dir.tmpdir}/pubnubError.log", 10, 10000000)
+    logger.level = Logger::DEBUG
+    logger
+  end
+
+end

data/lib/pubnub_crypto.rb

@@ -0,0 +1,53 @@
+class PubnubCrypto
+  require 'yajl'
+
+  def initialize(cipher_key)
+    @alg = "AES-256-CBC"
+    sha256_key = Digest::SHA256.hexdigest(cipher_key)
+    @key = sha256_key.slice(0,32)
+
+    #puts("\nraw sha cipher_key is: #{cipher_key}")
+    #puts("raw sha cipher_key is: #{sha256_key}")
+    #puts("padded cipher_key is: #{@key}\n")
+
+    @iv = '0123456789012345'
+  end
+
+
+  def encrypt(message)
+
+    aes = OpenSSL::Cipher::Cipher.new(@alg)
+    aes.encrypt
+    aes.key = @key
+    aes.iv = @iv
+
+    json_message = Yajl.dump(message)
+    cipher = aes.update(json_message)
+    cipher << aes.final
+
+    Base64.strict_encode64(cipher)
+
+  end
+
+
+  def decrypt(cipher_text)
+    decode_cipher = OpenSSL::Cipher::Cipher.new(@alg)
+    decode_cipher.decrypt
+    decode_cipher.key = @key
+    decode_cipher.iv = @iv
+
+    plain_text = ""
+
+    begin
+    undecoded_text = Base64.decode64(cipher_text)
+    plain_text = decode_cipher.update(undecoded_text)
+    plain_text << decode_cipher.final
+    rescue => e
+
+      return "DECRYPTION_ERROR"
+
+    end
+
+    return Yajl.load(plain_text)
+  end
+end

data/lib/pubnub_request.rb

@@ -0,0 +1,310 @@
+class PubnubRequest
+  attr_accessor :cipher_key, :host, :query, :response, :timetoken, :url, :operation, :callback, :publish_key, :subscribe_key, :secret_key, :channel, :jsonp, :message, :ssl, :port
+  attr_accessor :history_limit, :history_count, :history_start, :history_end, :history_reverse, :session_uuid, :last_timetoken, :origin, :error
+
+  class RequestError < RuntimeError;
+  end
+
+  def initialize(args = {})
+    args = HashWithIndifferentAccess.new(args)
+
+    @operation = args[:operation].to_s
+    @callback = args[:callback]
+    @cipher_key = args[:cipher_key]
+    @session_uuid = args[:session_uuid]
+    @publish_key = args[:publish_key]
+    @subscribe_key = args[:subscribe_key]
+    @channel = args[:channel]
+    @jsonp = args[:jsonp].present? ? "1" : "0"
+    @message = args[:message]
+    @secret_key = args[:secret_key] || "0"
+    @timetoken = args[:timetoken] || "0"
+    @ssl = args[:ssl]
+
+    @port = args[:port]
+    @url = args[:url]
+    @host = args[:host]
+    @query = args[:query]
+  end
+
+  def op_exception
+    if @operation.present?
+      ("Pubnub::" + @operation.to_s.capitalize + "Error").constantize
+    else
+      PubnubRequest::RequestError
+    end
+  end
+
+  def ==(another)
+    self.operation == another.operation && self.callback == another.callback &&
+        self.channel == another.channel && self.message == another.message
+  end
+
+  def set_error(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:error].present?
+      self.error = true
+    end
+    self
+  end
+
+  def set_origin(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:origin].present?
+      self.origin = options[:origin].to_s
+      self
+    end
+  end
+
+  def set_channel(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:channel].blank?
+      raise(op_exception, "channel is a required parameter.")
+    else
+      self.channel = options[:channel].to_s
+      self
+    end
+  end
+
+  def set_callback(options)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:callback].blank?
+      raise(op_exception, "callback is a required parameter.")
+    elsif !options[:callback].try(:respond_to?, "call")
+      raise(op_exception, "callback is invalid.")
+    else
+      self.callback = options[:callback]
+      self
+    end
+  end
+
+
+  def set_cipher_key(options, self_cipher_key)
+    options = HashWithIndifferentAccess.new(options)
+
+    if self_cipher_key.present? && options['cipher_key'].present?
+      raise(op_exception, "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(Pubnub::PublishError, "secret key must be a string.") if this_cipher_key.class != String
+      self.cipher_key = this_cipher_key
+    end
+  end
+
+  def set_secret_key(options, self_secret_key)
+    options = HashWithIndifferentAccess.new(options)
+
+    if self_secret_key.present? && options['secret_key'].present?
+      raise(Pubnub::PublishError, "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(Pubnub::PublishError, "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)
+      self.secret_key = hmac
+    else
+      self.secret_key = "0"
+    end
+  end
+
+  def set_message(options, self_cipher_key)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:message].blank? && options[:message] != ""
+      raise(op_exception, "message is a required parameter.")
+    else
+      my_cipher_key = options[:cipher_key] || self_cipher_key
+
+      if my_cipher_key.present?
+        self.message = Yajl.dump(aes_encrypt(my_cipher_key, options, self))
+      else
+        self.message = Yajl.dump(options[:message])
+      end
+    end
+  end
+
+  def set_publish_key(options, self_publish_key)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:publish_key].blank? && self_publish_key.blank?
+      raise(Pubnub::PublishError, "publish_key is a required parameter.")
+    elsif self_publish_key.present? && options['publish_key'].present?
+      raise(Pubnub::PublishError, "existing publish_key #{self_publish_key} cannot be overridden at publish-time.")
+    else
+      self.publish_key = (self_publish_key || options[:publish_key]).to_s
+    end
+  end
+
+  def set_subscribe_key(options, self_subscribe_key)
+    options = HashWithIndifferentAccess.new(options)
+
+    if options[:subscribe_key].blank? && self_subscribe_key.blank?
+      raise(op_exception, "subscribe_key is a required parameter.")
+    elsif self_subscribe_key.present? && options['subscribe_key'].present?
+      raise(op_exception, "existing subscribe_key #{self_subscribe_key} cannot be overridden at subscribe-time.")
+    else
+      self.subscribe_key = (self_subscribe_key || options[:subscribe_key]).to_s
+    end
+  end
+
+  def package_response!(response_data)
+    self.response = response_data.respond_to?(:content) ? Yajl.load(response_data.content) : Yajl.load(response_data)
+    self.last_timetoken = self.timetoken
+    self.timetoken = self.response[1] unless self.operation == "time"
+
+    if self.cipher_key.present? && %w(subscribe history detailed_history).include?(self.operation)
+
+      myarr = Array.new
+      pc = PubnubCrypto.new(@cipher_key)
+
+      case @operation
+        when "publish"
+          iterate = self.response.first
+        when "subscribe"
+          iterate = self.response.first
+        when "history"
+          iterate = self.response
+        when "detailed_history"
+          iterate = self.response.first
+
+        else
+          raise(RequestError, "Don't know how to iterate on this operation.")
+      end
+
+      iterate.each do |message|
+        message = pc.decrypt(message)
+        myarr.push(message)
+      end
+
+      if %w(publish subscribe).include?(@operation)
+        self.response[0] = myarr
+      elsif @operation == "detailed_history"
+        json_response_data = Yajl.load(response_data)
+        self.response = [myarr, json_response_data[1], json_response_data[2]]
+      else
+        self.response = myarr
+      end
+
+    end
+  end
+
+  def format_url!(override_timetoken = nil)
+
+    raise(Pubnub::PublishError, "Missing .operation in PubnubRequest object") if self.operation.blank?
+
+    if @ssl.present?
+      origin = 'https://' + (self.origin.present? ? self.origin : Pubnub::ORIGIN_HOST)
+      @port = 443
+    else
+      origin = 'http://' + (self.origin.present? ? self.origin : Pubnub::ORIGIN_HOST)
+      @port = 80
+    end
+
+    if override_timetoken.present?
+      self.timetoken = override_timetoken.to_s
+    end
+
+    case self.operation.to_s
+      when "publish"
+        url_array = [self.operation.to_s, self.publish_key.to_s, self.subscribe_key.to_s,
+                     self.secret_key.to_s, self.channel.to_s, "0", self.message]
+
+      when "subscribe"
+        url_array = [self.operation.to_s, self.subscribe_key.to_s, self.channel.to_s, "0", @timetoken]
+
+      when "presence"
+        url_array = ["subscribe", self.subscribe_key.to_s, ((self.channel.to_s) + "-pnpres"), "0", @timetoken]
+
+      when "time"
+        url_array = [self.operation.to_s, "0"]
+
+      when "history"
+        url_array = [self.operation.to_s, self.subscribe_key.to_s, self.channel.to_s, "0", self.history_limit.to_s]
+
+      when "detailed_history"
+        url_array = ["v2", "history", "sub-key", self.subscribe_key.to_s, "channel", self.channel.to_s]
+
+      when "here_now"
+        url_array = ["v2", "presence", "sub-key", self.subscribe_key.to_s, "channel", self.channel.to_s]
+
+      else
+
+        raise(PubnubRequest::RequestError, "I can't create that URL for you due to unknown operation type.")
+    end
+
+    self.url = origin + encode_URL(url_array)
+
+    uri = URI.parse(self.url)
+
+    self.host = uri.host
+    url_params = ""
+
+    if %w(subscribe presence).include?(@operation)
+      uri.query = uri.query.blank? ? "uuid=#{@session_uuid}" : (uri.query + "uuid=#{@session_uuid}")
+
+    elsif @operation == "detailed_history"
+      url_sep = "?"
+
+      if @history_count || @history_start || @history_end || @history_reverse
+
+        if @history_count
+          url_params += url_sep + "count=" + @history_count.to_s
+          url_sep = "&"
+        end
+
+        if @history_start
+          url_params += url_sep + "start=" + @history_start.to_s
+          url_sep = "&"
+        end
+
+        if @history_end
+          url_params += url_sep + "end=" + @history_end.to_s
+          url_sep = "&"
+        end
+
+        if @history_reverse
+          url_params += url_sep + "reverse=true"
+          url_sep = "&"
+        end
+      end
+    end
+
+    self.query = uri.path + (uri.query.present? ? ("?" + uri.query) : "") + url_params
+    self.url += url_params
+    self
+
+  end
+
+  def aes_encrypt(cipher_key, options, publish_request)
+    options = HashWithIndifferentAccess.new(options)
+
+    pc = PubnubCrypto.new(cipher_key)
+    publish_request.message = pc.encrypt(options[:message])
+
+  end
+
+  def encode_URL(request)
+    ## Construct Request URL
+    url = '/' + request.map { |bit| bit.split('').map { |ch|
+      ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.index(ch) ?
+          '%' + ch.unpack('H2')[0].to_s.upcase : URI.encode(ch)
+    }.join('') }.join('/')
+    return url
+  end
+
+  def first_request?
+    @last_timetoken == "0"
+  end
+
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: pubnub-picklive
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 3.3.0.7
+platform: ruby
+authors:
+- PubNub
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: activesupport
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: eventmachine
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: em-http-request
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  name: uuid
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: yajl-ruby
+- !ruby/object:Gem::Dependency
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: json
+description: Ruby anywhere in the world in 250ms with PubNub!
+email: support@pubnub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pubnub.rb
+- lib/pubnub_crypto.rb
+- lib/pubnub_request.rb
+homepage: http://github.com/pubnub/pubnub-api
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: PubNub Official Ruby gem
+test_files: []