scout 5.7.1 → 5.7.2.pre

data/vendor/pusher-gem/lib/pusher.rb

@@ -1,107 +0,0 @@
-autoload 'Logger', 'logger'
-require 'uri'
-
-# Used for configuring API credentials and creating Channel objects
-#
-module Pusher
-  # All Pusher errors descend from this class so you can easily rescue Pusher
-  # errors
-  #
-  # @example
-  #   begin
-  #     Pusher['a_channel'].trigger!('an_event', {:some => 'data'})
-  #   rescue Pusher::Error => e
-  #     # Do something on error
-  #   end
-  class Error < RuntimeError; end
-  class AuthenticationError < Error; end
-  class ConfigurationError < Error; end
-  class HTTPError < Error; attr_accessor :original_error; end
-
-  class << self
-    attr_accessor :scheme, :host, :port
-    attr_writer :logger
-    attr_accessor :app_id, :key, :secret
-
-    # @private
-    def logger
-      @logger ||= begin
-        log = Logger.new($stdout)
-        log.level = Logger::INFO
-        log
-      end
-    end
-
-    # @private
-    def authentication_token
-      Signature::Token.new(@key, @secret)
-    end
-
-    # @private Builds a connection url for Pusherapp
-    def url
-      URI::Generic.build({
-        :scheme => self.scheme,
-        :host => self.host,
-        :port => self.port,
-        :path => "/apps/#{self.app_id}"
-      })
-    end
-
-    # Configure Pusher connection by providing a url rather than specifying
-    # scheme, key, secret, and app_id separately.
-    #
-    # @example
-    #   Pusher.url = http://KEY:SECRET@api.pusherapp.com/apps/APP_ID
-    #
-    def url=(url)
-      uri = URI.parse(url)
-      self.app_id = uri.path.split('/').last
-      self.key    = uri.user
-      self.secret = uri.password
-      self.host   = uri.host
-      self.port   = uri.port
-    end
-
-    # Configure whether Pusher API calls should be made over SSL
-    # (default false)
-    #
-    # @example
-    #   Pusher.encrypted = true
-    #
-    def encrypted=(boolean)
-      Pusher.scheme = boolean ? 'https' : 'http'
-      # Configure port if it hasn't already been configured
-      Pusher.port ||= boolean ? 443 : 80
-    end
-
-    private
-
-    def configured?
-      host && scheme && key && secret && app_id
-    end
-  end
-
-  # Defaults
-  self.scheme = 'http'
-  self.host = 'api.pusherapp.com'
-
-  if ENV['PUSHER_URL']
-    self.url = ENV['PUSHER_URL']
-  end
-
-  # Return a channel by name
-  #
-  # @example
-  #   Pusher['my-channel']
-  # @return [Channel]
-  # @raise [ConfigurationError] unless key, secret and app_id have been
-  #   configured
-  def self.[](channel_name)
-    raise ConfigurationError, 'Missing configuration: please check that Pusher.key, Pusher.secret and Pusher.app_id are configured.' unless configured?
-    @channels ||= {}
-    @channels[channel_name.to_s] ||= Channel.new(url, channel_name)
-  end
-end
-
-require 'pusher/channel'
-require 'pusher/request'

data/vendor/pusher-gem/lib/pusher/request.rb

@@ -1,107 +0,0 @@
-require 'signature'
-require 'digest/md5'
-require 'json'
-
-module Pusher
-  class Request
-    def initialize(verb, uri, params, body = nil, token = nil)
-      @verb = verb
-      @uri = uri
-
-      if body
-        @body = body
-        params[:body_md5] = Digest::MD5.hexdigest(body)
-      end
-
-      request = Signature::Request.new(verb.to_s.upcase, uri.path, params)
-      auth_hash = request.sign(token || Pusher.authentication_token)
-      @params = params.merge(auth_hash)
-    end
-
-    def send_sync
-      require 'net/http' unless defined?(Net::HTTP)
-      require 'net/https' if (ssl? && !defined?(Net::HTTPS))
-
-      @http_sync ||= begin
-        http = Net::HTTP.new(@uri.host, @uri.port)
-        http.use_ssl = true if ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ssl?
-        http
-      end
-
-      begin
-        case @verb
-        when :post
-          response = @http_sync.post("#{@uri.path}?#{@params.to_params}",
-            @body, { 'Content-Type'=> 'application/json' })
-        when :get
-          response = @http_sync.get("#{@uri.path}?#{@params.to_params}",
-            { 'Content-Type'=> 'application/json' })
-        else
-          raise "Unknown verb"
-        end
-      rescue Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED,
-             Errno::ETIMEDOUT, Errno::EHOSTUNREACH, Errno::ECONNRESET,
-             Timeout::Error, EOFError,
-             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
-             Net::ProtocolError => e
-        error = Pusher::HTTPError.new("#{e.message} (#{e.class})")
-        error.original_error = e
-        raise error
-      end
-
-      return handle_response(response.code.to_i, response.body.chomp)
-    end
-
-    def send_async
-      unless defined?(EventMachine) && EventMachine.reactor_running?
-        raise Error, "In order to use trigger_async you must be running inside an eventmachine loop"
-      end
-      require 'em-http' unless defined?(EventMachine::HttpRequest)
-
-      deferrable = EM::DefaultDeferrable.new
-
-      http = EventMachine::HttpRequest.new(@uri).post({
-        :query => @params, :timeout => 5, :body => @body,
-        :head => {'Content-Type'=> 'application/json'}
-      })
-      http.callback {
-        begin
-          handle_response(http.response_header.status, http.response.chomp)
-          deferrable.succeed
-        rescue => e
-          deferrable.fail(e)
-        end
-      }
-      http.errback {
-        Pusher.logger.debug("Network error connecting to pusher: #{http.inspect}")
-        deferrable.fail(Error.new("Network error connecting to pusher"))
-      }
-
-      deferrable
-    end
-
-    private
-
-    def handle_response(status_code, body)
-      case status_code
-      when 200
-        return JSON.decode(body, :symbolize_keys => true)
-      when 202
-        return true
-      when 400
-        raise Error, "Bad request: #{body}"
-      when 401
-        raise AuthenticationError, body
-      when 404
-        raise Error, "Resource not found: app_id is probably invalid"
-      else
-        raise Error, "Unknown error (status code #{status_code}): #{body}"
-      end
-    end
-
-    def ssl?
-      @uri.scheme == 'https'
-    end
-  end
-end

data/vendor/pusher-gem/spec/channel_spec.rb

@@ -1,274 +0,0 @@
-require 'spec_helper'
-
-describe Pusher::Channel do
-  before do
-    Pusher.app_id = '20'
-    Pusher.key    = '12345678900000001'
-    Pusher.secret = '12345678900000001'
-    Pusher.host = 'api.pusherapp.com'
-    Pusher.port = 80
-    Pusher.encrypted = false
-
-    WebMock.reset!
-    WebMock.disable_net_connect!
-
-    @pusher_url_regexp = %r{/apps/20/channels/test_channel/events}
-  end
-
-  after do
-    Pusher.app_id = nil
-    Pusher.key = nil
-    Pusher.secret = nil
-  end
-
-  describe 'trigger!' do
-    before :each do
-      WebMock.stub_request(:post, @pusher_url_regexp).
-        to_return(:status => 202)
-      @channel = Pusher['test_channel']
-    end
-
-    it 'should configure HTTP library to talk to pusher API' do
-      @channel.trigger!('new_event', 'Some data')
-      WebMock.should have_requested(:post, %r{http://api.pusherapp.com})
-    end
-
-    it "should POST to https api if ssl enabled" do
-      Pusher.encrypted = true
-      Pusher::Channel.new(Pusher.url, 'test_channel').trigger('new_event', 'Some data')
-      WebMock.should have_requested(:post, %r{https://api.pusherapp.com})
-    end
-
-    it 'should POST hashes by encoding as JSON in the request body' do
-      @channel.trigger!('new_event', {
-        :name => 'Pusher',
-        :last_name => 'App'
-      })
-      WebMock.should have_requested(:post, %r{/apps/20/channels/test_channel/events}).with do |req|
-        query_hash = req.uri.query_values
-        query_hash["name"].should == 'new_event'
-        query_hash["auth_key"].should == Pusher.key
-        query_hash["auth_timestamp"].should_not be_nil
-
-        parsed = MultiJson.decode(req.body)
-        parsed.should == {
-          "name" => 'Pusher',
-          "last_name" => 'App'
-        }
-
-        req.headers['Content-Type'].should == 'application/json'
-      end
-    end
-
-    it "should POST string data unmodified in request body" do
-      string = "foo\nbar\""
-      @channel.trigger!('new_event', string)
-      WebMock.should have_requested(:post, %r{/apps/20/channels/test_channel/events}).with do |req|
-        req.body.should == "foo\nbar\""
-      end
-    end
-
-    it "should catch all Net::HTTP exceptions and raise a Pusher::HTTPError, exposing the original error if required" do
-      WebMock.stub_request(
-        :post, %r{/apps/20/channels/test_channel/events}
-      ).to_raise(Timeout::Error)
-
-      error_raised = nil
-      begin
-        Pusher['test_channel'].trigger!('new_event', 'Some data')
-      rescue => e
-        error_raised = e
-      end
-      error_raised.class.should == Pusher::HTTPError
-      error_raised.message.should == 'Exception from WebMock (Timeout::Error)'
-      error_raised.original_error.class.should == Timeout::Error
-    end
-
-    it "should raise AuthenticationError if pusher returns 401" do
-      WebMock.stub_request(
-        :post,
-        %r{/apps/20/channels/test_channel/events}
-      ).to_return(:status => 401)
-      lambda {
-        Pusher['test_channel'].trigger!('new_event', 'Some data')
-      }.should raise_error(Pusher::AuthenticationError)
-    end
-
-    it "should raise Pusher::Error if pusher returns 404" do
-      WebMock.stub_request(
-        :post, %r{/apps/20/channels/test_channel/events}
-      ).to_return(:status => 404)
-      lambda {
-        Pusher['test_channel'].trigger!('new_event', 'Some data')
-      }.should raise_error(Pusher::Error, 'Resource not found: app_id is probably invalid')
-    end
-
-    it "should raise Pusher::Error if pusher returns 500" do
-      WebMock.stub_request(
-        :post, %r{/apps/20/channels/test_channel/events}
-      ).to_return(:status => 500, :body => "some error")
-      lambda {
-        Pusher['test_channel'].trigger!('new_event', 'Some data')
-      }.should raise_error(Pusher::Error, 'Unknown error (status code 500): some error')
-    end
-  end
-
-  describe 'trigger' do
-    it "should log failure if error raised in Net::HTTP call" do
-      stub_request(:post, @pusher_url_regexp).to_raise(Net::HTTPBadResponse)
-      Pusher.logger.should_receive(:error).with("Exception from WebMock (Net::HTTPBadResponse) (Pusher::HTTPError)")
-      Pusher.logger.should_receive(:debug) #backtrace
-      Pusher::Channel.new(Pusher.url, 'test_channel').trigger('new_event', 'Some data')
-    end
-
-    it "should log failure if Pusher returns an error response" do
-      stub_request(:post, @pusher_url_regexp).to_return(:status => 401)
-      # @http.should_receive(:post).and_raise(Net::HTTPBadResponse)
-      Pusher.logger.should_receive(:error).with(" (Pusher::AuthenticationError)")
-      Pusher.logger.should_receive(:debug) #backtrace
-      Pusher::Channel.new(Pusher.url, 'test_channel').trigger('new_event', 'Some data')
-    end
-  end
-
-  describe "trigger_async" do
-    it "should by default POST to http api" do
-      EM.run {
-        stub_request(:post, @pusher_url_regexp).to_return(:status => 202)
-        channel = Pusher::Channel.new(Pusher.url, 'test_channel')
-        channel.trigger_async('new_event', 'Some data').callback {
-          WebMock.should have_requested(:post, %r{http://api.pusherapp.com})
-          EM.stop
-        }
-      }
-    end
-
-    it "should POST to https api if ssl enabled" do
-      Pusher.encrypted = true
-      EM.run {
-        stub_request(:post, @pusher_url_regexp).to_return(:status => 202)
-        channel = Pusher::Channel.new(Pusher.url, 'test_channel')
-        channel.trigger_async('new_event', 'Some data').callback {
-          WebMock.should have_requested(:post, %r{https://api.pusherapp.com})
-          EM.stop
-        }
-      }
-    end
-
-    it "should return a deferrable which succeeds in success case" do
-      stub_request(:post, @pusher_url_regexp).to_return(:status => 202)
-
-      EM.run {
-        d = Pusher['test_channel'].trigger_async('new_event', 'Some data')
-        d.callback {
-          WebMock.should have_requested(:post, @pusher_url_regexp)
-          EM.stop
-        }
-        d.errback {
-          fail
-          EM.stop
-        }
-      }
-    end
-
-    it "should return a deferrable which fails (with exception) in fail case" do
-      stub_request(:post, @pusher_url_regexp).to_return(:status => 401)
-
-      EM.run {
-        d = Pusher['test_channel'].trigger_async('new_event', 'Some data')
-        d.callback {
-          fail
-        }
-        d.errback { |error|
-          WebMock.should have_requested(:post, @pusher_url_regexp)
-          error.should be_kind_of(Pusher::AuthenticationError)
-          EM.stop
-        }
-      }
-    end
-  end
-
-  describe "stats" do
-    before :each do
-      @api_path = %r{/apps/20/channels/presence-test_channel/stats}
-    end
-
-    it "should call the user_count api" do
-      WebMock.stub_request(:get, @api_path).to_return({
-        :status => 200,
-        :body => JSON.generate(:user_count => 1)
-      })
-      @channel = Pusher['presence-test_channel']
-
-      @channel.stats.should == {
-        :user_count => 1
-      }
-    end
-  end
-
-  describe "socket_auth" do
-    before :each do
-      @channel = Pusher['test_channel']
-    end
-
-    it "should return an authentication string given a socket id" do
-      auth = @channel.socket_auth('socketid')
-
-      auth.should == '12345678900000001:827076f551e22451357939e4c7bb1200de29f921d5bf80b40d71668f9cd61c40'
-    end
-
-    it "should raise error if authentication is invalid" do
-      [nil, ''].each do |invalid|
-        lambda {
-          @channel.socket_auth(invalid)
-        }.should raise_error
-      end
-    end
-
-    describe 'with extra string argument' do
-
-      it 'should be a string or nil' do
-        lambda {
-          @channel.socket_auth('socketid', 'boom')
-        }.should_not raise_error
-
-        lambda {
-          @channel.socket_auth('socketid', 123)
-        }.should raise_error
-
-        lambda {
-          @channel.socket_auth('socketid', nil)
-        }.should_not raise_error
-
-        lambda {
-          @channel.socket_auth('socketid', {})
-        }.should raise_error
-      end
-
-      it "should return an authentication string given a socket id and custom args" do
-        auth = @channel.socket_auth('socketid', 'foobar')
-
-        auth.should == "12345678900000001:#{HMAC::SHA256.hexdigest(Pusher.secret, "socketid:test_channel:foobar")}"
-      end
-
-    end
-  end
-
-  describe '#authenticate' do
-
-    before :each do
-      @channel = Pusher['test_channel']
-      @custom_data = {:uid => 123, :info => {:name => 'Foo'}}
-    end
-
-    it 'should return a hash with signature including custom data and data as json string' do
-      MultiJson.stub!(:encode).with(@custom_data).and_return 'a json string'
-
-      response = @channel.authenticate('socketid', @custom_data)
-
-      response.should == {
-        :auth => "12345678900000001:#{HMAC::SHA256.hexdigest(Pusher.secret, "socketid:test_channel:a json string")}",
-        :channel_data => 'a json string'
-      }
-    end
-  end
-end