pubnub 3.4.1 → 3.5.1

data/lib/pubnub/events/revoke.rb

@@ -0,0 +1,56 @@
+module Pubnub
+  class Revoke
+    include Pubnub::Event
+    include Pubnub::SingleEvent
+    include Pubnub::Formatter
+    include Pubnub::Validator
+    include Pubnub::PAM
+
+    def initialize(options, app)
+      super
+      @event = 'grant'
+      @allow_multiple_channels = false
+
+      @timestamp = current_time
+
+      @write = options[:write]
+      @read  = options[:read]
+      @ttl   = options[:ttl]   || Pubnub::Configuration::DEFAULT_TTL
+    end
+
+    def validate!
+      super
+
+      raise ArgumentError.new(:object => self, :message => 'publish_key is required by Revoke') unless @publish_key
+      raise ArgumentError.new(:object => self, :message => 'Parameter secret_key is required by Revoke') if !@secret_key || @secret_key == 0
+
+      raise ArgumentError.new(:object => self, :message => 'ttl parameter is too big, max value is: 525600') unless @ttl.to_i <= 525600 || @ttl.nil?
+      raise ArgumentError.new(:object => self, :message => 'ttl parameter is too small, min value is: 1')  unless @ttl.to_i >= 1 || @ttl.nil?
+    end
+
+    private
+
+    def parameters(app, signature = false)
+      write = 0
+      read  = 0
+
+      {
+          :timestamp => @timestamp,
+          :w         => write,
+          :r         => read,
+          :ttl       => @ttl
+      }.merge(super(app, signature))
+    end
+
+    def path(app)
+      '/' + [
+          'v1',
+          'auth',
+          'grant',
+          'sub-key',
+          @subscribe_key
+      ].join('/')
+    end
+
+  end
+end

data/lib/pubnub/events/subscribe.rb

@@ -0,0 +1,34 @@
+module Pubnub
+  class Subscribe
+    include Pubnub::Event
+    include Pubnub::SubscribeEvent
+    include Pubnub::Formatter
+    include Pubnub::Validator
+
+
+    def initialize(options, app)
+      super
+      @event = 'subscribe'
+      @allow_multiple_channels = true
+
+    end
+
+    def fire(app)
+      app.update_timetoken(0)
+      super
+    end
+
+    def validate!
+      super
+      # Check channels
+      raise ArgumentError.new(:object => self, :message => 'Subscribe requires :channel or :channels argument') unless @channel
+
+      # check callback
+      raise ArgumentError.new(:object => self, :message => 'Callback parameter is required while using async subscribe') if !@http_sync && @callback.blank?
+
+    end
+
+    private
+
+  end
+end

data/lib/pubnub/events/time.rb

@@ -0,0 +1,52 @@
+module Pubnub
+  class Time
+    include Pubnub::Event
+    include Pubnub::SingleEvent
+    include Pubnub::Formatter
+    include Pubnub::Validator
+
+    def initialize(options, app)
+      super
+      @channel = @channel.first
+      @event = 'time'
+      @doesnt_require_callback = true
+    end
+
+    def validate!
+      super
+      # check callback
+      raise ArgumentError.new(:object => self, :message => 'Callback parameter is required while using async time') if !@http_sync && @callback.blank?
+    end
+
+    private
+
+    def path(app)
+      '/time/0'
+    end
+
+    def timetoken(parsed_response)
+      parsed_response.first if parsed_response.is_a? Array
+    end
+
+    def format_envelopes(response, app, error)
+
+      parsed_response = Parser.parse_json(response.body) if Parser.valid_json?(response.body)
+
+      envelopes = Array.new
+      envelopes << Envelope.new(
+          {
+              :message           => timetoken(parsed_response),
+              :response_message  => timetoken(parsed_response),
+              :timetoken         => timetoken(parsed_response)
+          },
+          app
+      )
+
+      envelopes = add_common_data_to_envelopes(envelopes, response, app, error)
+
+      envelopes
+
+    end
+
+  end
+end

data/lib/pubnub/exceptions.rb

@@ -0,0 +1,50 @@
+module Pubnub
+  class Error < StandardError
+    attr_reader :operation, :request, :response, :env, :error, :message, :app, :event
+
+    def initialize(options = {})
+      if options.is_a? Hash
+        @event     = options[:event]
+        @operation = @event
+        @request   = options[:request]
+        @env       = options[:env]
+        @response  = options[:response]
+        @error     = options[:error]
+        @message   = options[:message] unless options[:message].nil?
+        @app       = options[:app]
+      end
+
+      @error = self unless @error
+
+      log_error
+    end
+
+    private
+
+    def log_error
+      error_message = String.new
+      error_message << "OPERATION: #{@operation}\n" if @operation
+      error_message << "REQUEST: #{@request}\n"     if @request
+      error_message << "ENV: #{@env}\n"             if @env
+      error_message << "APP: #{@app}\n"             if @app
+      error_message << "RESPONSE: #{@response}\n"   if @response
+      error_message << "ERROR TYPE: #{@error.class.to_s}\n"
+      error_message << "ERROR MESSAGE: #{@message}\n"
+      error_message << "ERROR BACKTRACE: #{self.backtrace}"
+
+      if $logger.blank?
+        puts error_message
+      else
+        $logger.error(error_message)
+      end
+    end
+
+  end
+
+  class JSONParseError < Error; end
+  class InitializationError < Error; end
+  class ArgumentError < Error; end
+  class RequestError < Error; end
+  class ResponseError < Error; end
+
+end

data/lib/pubnub/formatter.rb

@@ -0,0 +1,45 @@
+module Pubnub
+  module Formatter
+    # Formats channels as array of channels as strings
+    def format_channels(channels, should_encode = true)
+      channel_array = case channels.class.to_s
+        when 'String'
+          channels.split(',')
+        when 'Array'
+          channels.map { |channel| channel.to_s }
+        else
+          [channels.to_s]
+      end
+
+      channel_array = channel_array.map { |channel| encode_channel(channel) } if should_encode
+      channel_array
+    end
+
+    def encode_channel(channel)
+      URI.encode_www_form_component(channel).gsub('+', '%20')
+    end
+
+    def format_message(message)
+      if @cipher_key
+        pc = Pubnub::Crypto.new(@cipher_key)
+        begin
+          message = pc.encrypt(message)
+          URI.escape(message.to_json)
+        rescue => error
+          @error_callback.call 'bug'
+        end
+      else
+        URI.encode_www_form_component(message.to_json).gsub('+', '%20')
+      end
+    end
+
+    def params_hash_to_url_params(hash)
+      params = String.new
+      hash.each do |key, value|
+        params << "#{key}=#{value}&"
+      end
+      params
+    end
+
+  end
+end

data/lib/pubnub/pam.rb

@@ -0,0 +1,59 @@
+module Pubnub
+  module PAM
+    def signature(app)
+      channel = @original_channel.first
+      message = "#{@subscribe_key}\n#{@publish_key}\n#{@event}\n#{variables_for_signature(app)}"
+      Base64.urlsafe_encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), @secret_key.to_s, message)).strip
+    end
+
+    def payload(parsed_response)
+      parsed_response['payload'] if parsed_response
+    end
+
+    def message(parsed_response)
+      parsed_response['message'] if parsed_response
+    end
+
+    def channel(parsed_response)
+      @channel.first
+    end
+
+    def parameters(app, signature = false)
+      params = super(app)
+      params.merge!({ :timestamp => @timestamp })
+      params.merge!({ :channel   => @channel.first })
+      params.merge!({ :signature => signature(app) }) unless signature
+      params
+    end
+
+    def variables_for_signature(app)
+      parameters(app, true).map{|k,v|
+        "#{k.to_s}=#{CGI.escape(v.to_s).gsub('+','%20')}"
+      }.sort.join('&')
+    end
+
+    def current_time
+      ::Time.now.to_i
+    end
+
+    def format_envelopes(response, app, error)
+
+      parsed_response = Parser.parse_json(response.body) if Parser.valid_json?(response.body)
+
+      envelopes = Array.new
+      envelopes << Envelope.new(
+          {
+              :payload => payload(parsed_response),
+              :message => message(parsed_response),
+              :channel => channel(parsed_response)
+          },
+          app
+      )
+
+      envelopes = add_common_data_to_envelopes(envelopes, response, app, error)
+
+      envelopes
+
+    end
+  end
+end

data/lib/pubnub/parser.rb

@@ -0,0 +1,21 @@
+module Pubnub
+  class Parser
+    # Parses string to JSON
+    def self.parse_json(string)
+      begin
+        return JSON.parse(string)
+      rescue JSON::ParserError => e
+        return Pubnub::Envelope.format_after_json_error(string, e)
+      end
+    end
+
+    def self.valid_json?(string)
+      begin
+        JSON.parse(string)
+        true
+      rescue JSON::ParserError
+        false
+      end
+    end
+  end
+end

data/lib/pubnub/validator.rb

@@ -0,0 +1,29 @@
+module Pubnub
+  module Validator
+
+    def valid_channel?(allow_array = true)
+      valid = true
+      if @channel.is_a? Array
+        if allow_array
+          @channel.each do |channel|
+            unless channel.is_a?(String) || channel.is_a?(Symbol)
+              valid = false
+              break
+            end
+          end
+        else
+          valid = false
+        end
+      else
+        if !@channel.is_a?(String) && !@channel.is_a?(Symbol)
+          valid = false
+        elsif @channel.to_s.index(',') && !allow_array
+          valid = false
+        end
+      end
+
+      valid
+
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Pubnub
+  VERSION = '3.5.1'
+end

data/pubnub.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = 'pubnub'
-  s.version = '3.4.1'
+  s.version = '3.5.1'
 
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
   s.authors = ['PubNub']
-  s.date = '2013-10-19'
+  s.date = '2014-01-15'
   s.description = 'Ruby anywhere in the world in 250ms with PubNub!'
   s.email = 'support@pubnub.com'
   s.files = `git ls-files`.split("\n")
@@ -17,9 +17,7 @@ Gem::Specification.new do |s|
   s.summary = 'PubNub Official Ruby gem'
 
   s.add_dependency 'eventmachine'
-  s.add_dependency 'httparty'
-  s.add_dependency 'persistent_httparty'
-  s.add_dependency 'em-http-request'
+  s.add_dependency 'net-http-persistent'
   s.add_dependency 'json'
 
 end

data/spec/lib/client_spec.rb

@@ -1,346 +1,48 @@
 require 'spec_helper'
-require 'rr'
-require 'vcr'
 
 describe Pubnub::Client do
-
-  describe '#uuid' do
-    it 'should return a UUID' do
-    end
-  end
-
-  describe '.initialize' do
-
-    before do
-      @publish_key   = 'demo_pub_key'
-      @subscribe_key = 'demo_sub_key'
-      @secret_key    = 'demo_md5_key'
-      @cipher_key    = 'demo_cipher_key'
-      @ssl           = false
-      @channel       = 'pn_test'
-    end
-
-    shared_examples_for 'successful initialization' do
-
-      it 'should initialize' do
-        @pn.publish_key.should   == @publish_key
-        @pn.subscribe_key.should == @subscribe_key
-        @pn.secret_key.should    == @secret_key
-        @pn.cipher_key.should    == @cipher_key
-        @pn.ssl.should           == @ssl_enabled
-      end
-    end
-
-    context 'when initialized' do
-      it 'should set a sessionUUID' do
-        Pubnub.new(:subscribe_key => :demo).session_uuid.should_not == nil
-      end
-    end
-
-    context 'when named' do
-      context 'and there are more than one arguments' do
-        it 'should throw an error' do
-          lambda { Pubnub::Client.new('arg1', 'arg2', 'arg3') }.should raise_error
-        end
-      end
-    end
-
-    context 'when passed with optional parameters in a hash' do
-      context 'when the hash key is a symbol' do
-        before do
-          @pn = Pubnub::Client.new(:publish_key   => @publish_key,
-                                   :subscribe_key => @subscribe_key,
-                                   :secret_key    => @secret_key,
-                                   :cipher_key    => @cipher_key,
-                                   :ssl           => @ssl_enabled)
-        end
-        it_behaves_like 'successful initialization'
-      end
-    end
-
-    describe '.verify_config' do
-      context 'subscribe_key' do
-        it 'should not throw an exception if present' do
-          lambda {  pn = Pubnub::Client.new(:subscribe_key => 'demo') }.should_not raise_error
-        end
-
-        it 'should not throw an exception if present' do
-          lambda { pn = Pubnub::Client.new(:subscribe_key => :bar) }.should_not raise_error
-        end
-      end
-    end
+  it 'has valid version constant' do
+    expect(Pubnub::Client::VERSION).to match(/\d+\.\d+\..+/)
   end
 
-  describe 'public methods' do
-    describe '.time' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when callback or block is missing' do
-          lambda { @pn.time }.
-              should raise_error(ArgumentError, 'time() require, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.time(:callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
-
-      end
-    end
-
-    describe '.publish' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.publish(:callback => @my_callback, :message => @my_message) }.
-              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.publish(:message => @my_message, :channel => @my_channel) }.
-              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when message is missing' do
-          lambda { @pn.publish(:channel => @my_channel, :callback => @my_callback) }.
-              should raise_error(ArgumentError, 'publish() requires :channel, :message parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.presence(:channel => @my_channel, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
-
-      end
-    end
-
-    describe '.subscribe' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.subscribe(:foo => :bar, :callback => @my_callback) }.
-              should raise_error(ArgumentError, 'subscribe() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.subscribe(:channel => @my_channel) }.
-              should raise_error(ArgumentError, 'subscribe() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.subscribe(:channel => @my_channel, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
-
-      end
+  context '#inititalize' do
+    it 'requires arguments' do
+      expect{ Pubnub.new() }.to raise_error
     end
 
-    describe '.here_now' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
+    context 'parameter :subscribe_key' do
+      it 'is required' do
+        expect{ Pubnub.new(:http_sync => true) }.to raise_error(Pubnub::InitializationError)
       end
 
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.here_now(:foo => :bar) }.
-              should raise_error(ArgumentError, 'here_now() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.here_now(:channel => @my_channel) }.
-              should raise_error(ArgumentError, 'here_now() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.here_now(:channel => @my_channel, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
+      it 'must be valid' do
+        expect{ Pubnub.new(:subscribe_key => 123) }.to raise_error(Pubnub::InitializationError)
+        expect{ Pubnub.new(:subscribe_key => [] ) }.to raise_error(Pubnub::InitializationError)
+        expect{ Pubnub.new(:subscribe_key => {} ) }.to raise_error(Pubnub::InitializationError)
 
+        expect{ Pubnub.new(:subscribe_key => 'key') }.not_to raise_error
+        expect{ Pubnub.new(:subscribe_key => :key ) }.not_to raise_error
       end
     end
 
-    describe '.presence' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.presence(:foo => :bar) }.
-              should raise_error(ArgumentError, 'presence() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.presence(:channel => @my_channel) }.
-              should raise_error(ArgumentError, 'presence() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.presence(:channel => @my_channel, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
+    context 'parameter :publish_key' do
+      it 'must be valid' do
+        expect{ Pubnub.new(:subscribe_key => 'valid', :publish_key => ['invalid']) }.to raise_error(Pubnub::InitializationError)
+        expect{ Pubnub.new(:subscribe_key => 'valid', :publish_key => {'invalid' => 'yeah'}) }.to raise_error(Pubnub::InitializationError)
+        expect{ Pubnub.new(:subscribe_key => 'valid', :publish_key => ['invalid']) }.to raise_error(Pubnub::InitializationError)
 
+        expect{ Pubnub.new(:subscribe_key => 'valid', :publish_key => 'key') }.not_to raise_error
+        expect{ Pubnub.new(:subscribe_key => 'valid', :publish_key => :key ) }.not_to raise_error
       end
     end
 
-    describe '.hisotry' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.history(:count => 10, :callback => @my_callback) }.
-              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.history(:channel => @my_channel, :count => 10) }.
-              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when count is missing' do
-          lambda { @pn.history(:channel => @my_channel, :callback => @my_callback) }.
-              should raise_error(ArgumentError, 'history() requires :channel, :count parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.history(:channel => @my_channel, :count => 10, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
-
-      end
+    it 'starts EventMachine reactor in a separate thread' do
+      pubnub = Pubnub.new(:subscribe_key => 'key')
+      sleep(0.1)
+      expect(EM.reactor_running?).to be true
+      expect(EM.reactor_thread).not_to be eq Thread.current
     end
 
-    describe '.leave' do
-      before do
-
-        @my_callback = lambda { |message| Rails.logger.debug(message) }
-        @my_pub_key = 'demo'
-        @my_sub_key = 'demo'
-        @my_message = 'hello_world!'
-        @my_channel = 'hello_world'
-
-        @my_cipher_key = 'my_cipher_key'
-        @my_sec_key = 'my_sec_key'
-        @alt_sec_key = 'alt_sec_key'
-      end
-
-      context 'required parameters' do
-
-        before do
-          @pn = Pubnub.new(:subscribe_key => @my_sub_key)
-        end
-
-        it 'should raise when channel is missing' do
-          lambda { @pn.leave(:callback => @my_callback) }.
-              should raise_error(ArgumentError, 'leave() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is missing' do
-          lambda { @pn.leave(:channel => @my_channel) }.
-              should raise_error(ArgumentError, 'leave() requires :channel parameters and, if async, callback parameter or block given.')
-        end
-
-        it 'should raise when callback is invalid' do
-          lambda { @pn.leave(:channel => @my_channel, :callback => :blah) }.
-              should raise_error('callback is invalid.')
-        end
-
-      end
-    end
   end
+
 end