scout 5.3.5 → 5.4.4.alpha

data/vendor/pusher-gem/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/vendor/pusher-gem/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 New Bamboo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/pusher-gem/README.md

@@ -0,0 +1,80 @@
+Pusher gem
+==========
+
+Getting started
+---------------
+
+After registering at <http://pusher.com> configure your app with the security credentials
+
+    Pusher.app_id = 'your-pusher-app-id'
+    Pusher.key = 'your-pusher-key'
+    Pusher.secret = 'your-pusher-secret'
+
+Trigger an event with {Pusher::Channel#trigger!}
+
+    Pusher['a_channel'].trigger!('an_event', {:some => 'data'})
+
+Handle errors by rescuing `Pusher::Error` (all Pusher errors are descendants of this error)
+
+    begin
+      Pusher['a_channel'].trigger!('an_event', {:some => 'data'})
+    rescue Pusher::Error => e
+      # (Pusher::AuthenticationError, Pusher::HTTPError, or Pusher::Error)
+    end
+
+Optionally a socket id may be provided. This will exclude the event from being triggered on this socket id (see <http://pusher.com/docs/publisher_api_guide/publisher_excluding_recipients> for more info).
+
+    Pusher['a_channel'].trigger!('an_event', {:some => 'data'}, socket_id)
+
+If you don't need to handle failure cases, then you can simply use the {Pusher::Channel#trigger} method, which will rescue and log any errors for you
+
+    Pusher['a_channel'].trigger('an_event', {:some => 'data'})
+
+Logging
+-------
+
+Errors are logged to `Pusher.logger`. It will by default use `Logger` from stdlib, however you can assign any logger:
+
+    Pusher.logger = Rails.logger
+
+Asynchronous triggering
+-----------------------
+
+To avoid blocking in a typical web application, you may wish to use the {Pusher::Channel#trigger_async} method which makes asynchronous API requests. `trigger_async` returns a deferrable which you can optionally bind to with success and failure callbacks.
+
+You need to be running eventmachine to make use of this functionality. This is already the case if, for example, you're deploying to Heroku or using the Thin web server. You will also need to add `em-http-request` to your Gemfile.
+
+    $ gem install em-http-request
+
+    deferrable = Pusher['a_channel'].trigger_async('an_event', {
+      :some => 'data'
+    }, socket_id)
+    deferrable.callback {
+      # Do something on success
+    }
+    deferrable.errback { |error|
+      # error is a instance of Pusher::Error
+    }
+
+Private channels
+----------------
+
+The Pusher Gem also deals with signing requests for authenticated private channels. A quick Rails controller example:
+
+    reponse = Pusher['private-my_channel'].authenticate(params[:socket_id])
+    render :json => response
+    
+Read more about private channels in [the docs](http://pusher.com/docs/client_api_guide/client_channels#subscribe-private-channels) and under {Pusher::Channel#authenticate}.
+
+Developing
+----------
+
+Use bundler in order to run specs with the correct dependencies.
+
+    bundle
+    bundle exec rspec spec/*_spec.rb
+
+Copyright
+---------
+
+Copyright (c) 2010 New Bamboo. See LICENSE for details.

data/vendor/pusher-gem/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |s|
+  s.pattern = 'spec/**/*.rb'
+end
+
+task :default => :spec
+task :test => :spec

data/vendor/pusher-gem/examples/async_message.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'pusher'
+require 'eventmachine'
+require 'em-http-request'
+
+# To get these values:
+# - Go to https://app.pusherapp.com/
+# - Click on Choose App.
+# - Click on one of your apps
+# - Click API Access
+Pusher.app_id = 'your_app_id'
+Pusher.key = 'your_key'
+Pusher.secret = 'your_secret'
+
+
+EM.run {
+  deferrable = Pusher['test_channel'].trigger_async('my_event', 'hi')
+
+  deferrable.callback { # called on success
+    puts "Message sent successfully."
+    EM.stop
+  }
+  deferrable.errback { |error| # called on error
+    puts "Message could not be sent."
+    puts error
+    EM.stop
+  }
+}

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

@@ -0,0 +1,107 @@
+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/channel.rb

@@ -0,0 +1,154 @@
+require 'core_extensions'
+require 'hmac-sha2'
+require 'json'
+
+module Pusher
+  # Trigger events on Channels
+  class Channel
+    attr_reader :name
+
+    def initialize(base_url, name)
+      @uri = base_url.dup
+      @uri.path = @uri.path + "/channels/#{name}/"
+      @name = name
+    end
+
+    # Trigger event asynchronously using EventMachine::HttpRequest
+    #
+    # @param (see #trigger!)
+    # @return [EM::DefaultDeferrable]
+    #   Attach a callback to be notified of success (with no parameters).
+    #   Attach an errback to be notified of failure (with an error parameter
+    #   which includes the HTTP status code returned)
+    # @raise [LoadError] unless em-http-request gem is available
+    # @raise [Pusher::Error] unless the eventmachine reactor is running. You
+    #   probably want to run your application inside a server such as thin
+    #
+    def trigger_async(event_name, data, socket_id = nil, &block)
+      request = construct_event_request(event_name, data, socket_id)
+      request.send_async
+    end
+
+    # Trigger event
+    #
+    # @example
+    #   begin
+    #     Pusher['my-channel'].trigger!('an_event', {:some => 'data'})
+    #   rescue Pusher::Error => e
+    #     # Do something on error
+    #   end
+    #
+    # @param data [Object] Event data to be triggered in javascript.
+    #   Objects other than strings will be converted to JSON
+    # @param socket_id Allows excluding a given socket_id from receiving the
+    #   event - see http://pusher.com/docs/publisher_api_guide/publisher_excluding_recipients for more info
+    #
+    # @raise [Pusher::Error] on invalid Pusher response - see the error message for more details
+    # @raise [Pusher::HTTPError] on any error raised inside Net::HTTP - the original error is available in the original_error attribute
+    #
+    def trigger!(event_name, data, socket_id = nil)
+      request = construct_event_request(event_name, data, socket_id)
+      request.send_sync
+    end
+
+    # Trigger event, catching and logging any errors.
+    #
+    # @note CAUTION! No exceptions will be raised on failure
+    # @param (see #trigger!)
+    #
+    def trigger(event_name, data, socket_id = nil)
+      trigger!(event_name, data, socket_id)
+    rescue Pusher::Error => e
+      Pusher.logger.error("#{e.message} (#{e.class})")
+      Pusher.logger.debug(e.backtrace.join("\n"))
+    end
+    
+    # Request channel stats
+    #
+    # @return [Hash] See Pusher api docs for reported stats
+    # @raise [Pusher::Error] on invalid Pusher response - see the error message for more details
+    # @raise [Pusher::HTTPError] on any error raised inside Net::HTTP - the original error is available in the original_error attribute
+    #
+    def stats
+      request = Pusher::Request.new(:get, @uri + 'stats', {})
+      return request.send_sync
+    end
+
+    # Compute authentication string required to subscribe to this channel.
+    #
+    # See http://pusher.com/docs/auth_signatures for more details.
+    #
+    # @param socket_id [String] Each Pusher socket connection receives a
+    #   unique socket_id. This is sent from pusher.js to your server when
+    #   channel authentication is required.
+    # @param custom_string [String] Allows signing additional data
+    # @return [String]
+    #
+    def authentication_string(socket_id, custom_string = nil)
+      raise "Invalid socket_id" if socket_id.nil? || socket_id.empty?
+      raise 'Custom argument must be a string' unless custom_string.nil? || custom_string.kind_of?(String)
+
+      string_to_sign = [socket_id, name, custom_string].compact.map{|e|e.to_s}.join(':')
+      Pusher.logger.debug "Signing #{string_to_sign}"
+      token = Pusher.authentication_token
+      signature = HMAC::SHA256.hexdigest(token.secret, string_to_sign)
+
+      return "#{token.key}:#{signature}"
+    end
+    
+    # Deprecated - for backward compatibility
+    alias :socket_auth :authentication_string
+
+    # Generate an authentication endpoint response
+    #
+    # @example Private channels
+    #   render :json => Pusher['private-my_channel'].authenticate(params[:socket_id])
+    #
+    # @example Presence channels
+    #   render :json => Pusher['private-my_channel'].authenticate(params[:socket_id], {
+    #     :user_id => current_user.id, # => required
+    #     :user_info => { # => optional - for example
+    #       :name => current_user.name,
+    #       :email => current_user.email
+    #     }
+    #   })
+    #
+    # @param socket_id [String]
+    # @param custom_data [Hash] used for example by private channels
+    #
+    # @return [Hash]
+    #
+    # @private Custom data is sent to server as JSON-encoded string
+    #
+    def authenticate(socket_id, custom_data = nil)
+      custom_data = custom_data.to_json if custom_data
+      auth = socket_auth(socket_id, custom_data)
+      r = {:auth => auth}
+      r[:channel_data] = custom_data if custom_data
+      r
+    end
+
+    private
+
+    def construct_event_request(event_name, data, socket_id)
+      params = {
+        :name => event_name,
+      }
+      params[:socket_id] = socket_id if socket_id
+
+      body = case data
+      when String
+        data
+      else
+        begin
+          data.to_json
+        rescue Exception => e
+          Pusher.logger.error("Could not convert #{data.inspect} into JSON")
+          raise e
+        end
+      end
+
+      request = Pusher::Request.new(:post, @uri + 'events', params, body)
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+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