hoptoad_notifier 2.1.3 → 2.2.0

data/CHANGELOG

@@ -0,0 +1,41 @@
+Version 2.2.0 - 2010-02-18
+===============================================================================
+
+Bumping the version from 2.1.4 to 2.2.0 since adding Rack support warrants a minor version.
+
+Jason Morrison (1):
+      Stringify array elements when making assertions about Notice XML for 1.9 compatibility
+
+
+Version 2.1.4 - 2010-02-12
+===============================================================================
+
+Chad Pytel (2):
+      add more info to README for 1.2.6
+      fix gem unpack line for 1.2.6
+
+Jason Morrison (2):
+      Adding additional instructions for Rails 1.2.6
+      Typesetting in README.rdoc
+
+Joe Ferris (11):
+      Separating Rails functionality out more
+      Initial Rack middleware
+      Extract request info from rack env
+      Added integration tests for rescuing
+      Fixed reporting of Rails version
+      Small refactoring
+      Automatically add Rack middleware for Rails apps that support it (catches exceptions from Metal)
+      Added an integration test and docs for rack apps
+      Added integration/readme coverage of Sinatra apps
+      Added docs to HoptoadNotifier::Rack
+      Require rack in tests for older versions of Rails; use active_support instead of activesupport
+
+Nick Quaranto (3):
+      Fixing the capistrano hook bit in the readme
+      Adding changeling:minor and changeling:patch to automate notifier releases
+      Adding rake changeling:push
+
+
+
+

data/README.rdoc

@@ -10,7 +10,7 @@ to the Hoptoad server specified in your environment.
 * {IRC}[irc://irc.freenode.net/thoughtbot]
 * {mailing list}[http://groups.google.com/group/hoptoad-notifier-dev]
 
-== Installation
+== Rails Installation
 
 === Remove exception_notifier
 
@@ -48,15 +48,37 @@ every server you deploy to has the gem installed or your application won't start
 
 === Rails 1.2.6
 
-Install the hoptoad_notifier Gem, and then add something like this at the
-bottom of your config/environment.rb:
+Install the hoptoad_notifier gem: 
 
+  gem install hoptoad_notifier
+
+Once installed, you should vendor the hoptoad_notifier gem:
+
+  mkdir vendor/gems
+  cd vendor/gems
+  gem unpack hoptoad_notifier
+
+And then add the following to the Rails::Initializer.run do |config|
+block in environment.rb so that the vendored gem is loaded.
+
+  # Add the vendor/gems/*/lib directories to the LOAD_PATH
+  config.load_paths += Dir.glob(File.join(RAILS_ROOT, 'vendor', 'gems', '*', 'lib'))
+
+Next add something like this at the bottom of your config/environment.rb:
+
+  require 'hoptoad_notifier'
+  require 'hoptoad_notifier/rails'
   HoptoadNotifier.configure do |config|
     config.api_key = 'your_key_here'
   end
 
-You will need to copy the hoptoad_notifier_tasks.rake file into your
-RAILS_ROOT/lib/tasks directory in order for the rake hoptoad:test task to work.
+You will also need to copy the hoptoad_notifier_tasks.rake file into your
+RAILS_ROOT/lib/tasks directory in order for the rake hoptoad:test task to work:
+
+  cp vendor/gems/hoptoad_notifier-2.1.3/generators/hoptoad/templates/hoptoad_notifier_tasks.rake lib/tasks 
+
+As always, if you choose not to vendor the hoptoad_notifier gem, make sure
+every server you deploy to has the gem installed or your application won't start.
 
 === Testing it out
 
@@ -68,6 +90,45 @@ this rake task (from RAILS_ROOT):
 If everything is configured properly, that task will send a notice to Hoptoad 
 which will be visible immediately.
 
+== Rack
+
+In order to use hoptoad_notifier in a non-Rails rack app, just load the
+hoptoad_notifier, configure your API key, and use the HoptoadNotifier::Rack
+middleware:
+
+  require 'rack'
+  require 'hoptoad_notifier'
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = 'my_api_key'
+  end
+
+  app = Rack::Builder.app do
+    use HoptoadNotifier::Rack
+    run lambda { |env| raise "Rack down" }
+  end
+
+== Sinatra
+
+Using hoptoad_notifier in a Sinatra app is just like a Rack app, but you have
+to disable Sinatra's error rescuing functionality:
+
+  require 'sinatra/base'
+  require 'hoptoad_notifier'
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = 'my_api_key'
+  end
+
+  class MyApp < Sinatra::Default
+    use HoptoadNotifier::Rack
+    enable :raise_errors
+
+    get "/" do
+      raise "Sinatra has left the building"
+    end
+  end
+
 == Usage
 
 For the most part, Hoptoad works for itself.  Once you've included the notifier 
@@ -102,7 +163,7 @@ Additionally, it's possible to review the errors in Hoptoad that occurred before
 
 When Hoptoad is installed as a gem, you need to add
 
-  require 'hoptoad_notifier/recipes/hoptoad'
+  require 'hoptoad_notifier/capistrano'
 
 to your deploy.rb
 

data/Rakefile

@@ -22,6 +22,83 @@ task :ginger do
   load File.join(*%w[vendor ginger bin ginger])
 end
 
+namespace :changeling do
+  desc "Bumps the version by a minor or patch version, depending on what was passed in."
+  task :bump, :part do |t, args|
+    # Thanks, Jeweler!
+    if HoptoadNotifier::VERSION  =~ /^(\d+)\.(\d+)\.(\d+)(?:\.(.*?))?$/
+      major = $1.to_i
+      minor = $2.to_i
+      patch = $3.to_i
+      build = $4
+    else
+      abort
+    end
+
+    case args[:part]
+    when /minor/
+      minor += 1
+      patch = 0
+    when /patch/
+      patch += 1
+    else
+      abort
+    end
+
+    version = [major, minor, patch, build].compact.join('.')
+
+    File.open(File.join("lib", "hoptoad_notifier", "version.rb"), "w") do |f|
+      f.write <<EOF
+module HoptoadNotifier
+  VERSION = "#{version}".freeze
+end
+EOF
+    end
+  end
+
+  desc "Writes out the new CHANGELOG and prepares the release"
+  task :change do
+    load 'lib/hoptoad_notifier/version.rb'
+    file    = "CHANGELOG"
+    old     = File.read(file)
+    version = HoptoadNotifier::VERSION
+    message = "Bumping to version #{version}"
+
+    File.open(file, "w") do |f|
+      f.write <<EOF
+Version #{version} - #{Date.today}
+===============================================================================
+
+#{`git log $(git tag | tail -1)..HEAD | git shortlog`}
+#{old}
+EOF
+    end
+
+    exec ["#{ENV["EDITOR"]} #{file}",
+          "git commit -aqm '#{message}'",
+          "git tag -a -m '#{message}' v#{version}",
+          "echo '\n\n\033[32mMarked v#{version} /' `git show-ref -s refs/heads/master` 'for release. Run: rake changeling:push\033[0m\n\n'"].join(' && ')
+  end
+
+  desc "Bump by a minor version (1.2.3 => 1.3.0)"
+  task :minor do |t|
+    Rake::Task['changeling:bump'].invoke(t.name)
+    Rake::Task['changeling:change'].invoke
+  end
+
+  desc "Bump by a patch version, (1.2.3 => 1.2.4)"
+  task :patch do |t|
+    Rake::Task['changeling:bump'].invoke(t.name)
+    Rake::Task['changeling:change'].invoke
+  end
+
+  desc "Push the latest version and tags"
+  task :push do |t|
+    system("git push origin master")
+    system("git push origin $(git tag | tail -1)")
+  end
+end
+
 begin
   require 'yard'
   YARD::Rake::YardocTask.new do |t|
@@ -81,7 +158,7 @@ end
 
 LOCAL_GEM_ROOT = File.join(GEM_ROOT, 'tmp', 'local_gems').freeze
 RAILS_VERSIONS = IO.read('SUPPORTED_RAILS_VERSIONS').strip.split("\n")
-LOCAL_GEMS = [['sham_rack', nil], ['capistrano', nil], ['sqlite3-ruby', nil]] +
+LOCAL_GEMS = [['sham_rack', nil], ['capistrano', nil], ['sqlite3-ruby', nil], ['sinatra', nil]] +
   RAILS_VERSIONS.collect { |version| ['rails', version] }
 
 task :vendor_test_gems do
@@ -107,19 +184,18 @@ end
 
 task :cucumber => [:gemspec, :vendor_test_gems]
 
-OLD_RAILS_VERSIONS = RAILS_VERSIONS[0...-1]
-
 namespace :cucumber do
   namespace :rails do
-    OLD_RAILS_VERSIONS.each do |version|
+    RAILS_VERSIONS.each do |version|
       desc "Test integration of the gem with Rails #{version}"
       task version do
+        puts "Testing Rails #{version}"
         ENV['RAILS_VERSION'] = version
         system("cucumber --format progress features/rails.feature")
       end
     end
 
     desc "Test integration of the gem with all Rails versions"
-    task :all => [:cucumber, *OLD_RAILS_VERSIONS]
+    task :all => RAILS_VERSIONS
   end
 end

data/lib/hoptoad_notifier.rb

@@ -6,8 +6,8 @@ require 'hoptoad_notifier/version'
 require 'hoptoad_notifier/configuration'
 require 'hoptoad_notifier/notice'
 require 'hoptoad_notifier/sender'
-require 'hoptoad_notifier/catcher'
 require 'hoptoad_notifier/backtrace'
+require 'hoptoad_notifier/rack'
 
 # Gem for applications to automatically post errors to the Hoptoad of their choice.
 module HoptoadNotifier
@@ -47,7 +47,7 @@ module HoptoadNotifier
     # Returns the Ruby version, Rails version, and current Rails environment
     def environment_info
       info = "[Ruby: #{RUBY_VERSION}]"
-      info << " [Rails: #{::Rails::VERSION::STRING}]" if defined?(Rails)
+      info << " [#{configuration.framework}]"
       info << " [Env: #{configuration.environment_name}]"
     end
 

data/lib/hoptoad_notifier/configuration.rb

@@ -7,7 +7,7 @@ module HoptoadNotifier
         :http_open_timeout, :http_read_timeout, :ignore, :ignore_by_filters,
         :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
         :params_filters, :project_root, :port, :protocol, :proxy_host,
-        :proxy_pass, :proxy_port, :proxy_user, :secure].freeze
+        :proxy_pass, :proxy_port, :proxy_user, :secure, :framework].freeze
 
     # The API key for your project, found on the project edit form.
     attr_accessor :api_key
@@ -80,6 +80,9 @@ module HoptoadNotifier
     # The logger used by HoptoadNotifier
     attr_accessor :logger
 
+    # The framework HoptoadNotifier is configured to use
+    attr_accessor :framework
+
     DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
 
     DEFAULT_BACKTRACE_FILTERS = [
@@ -124,6 +127,7 @@ module HoptoadNotifier
       @notifier_name            = 'Hoptoad Notifier'
       @notifier_version         = VERSION
       @notifier_url             = 'http://hoptoadapp.com'
+      @framework                = 'Standalone'
     end
 
     # Takes a block and adds it to the list of backtrace filters. When the filters

data/lib/hoptoad_notifier/notice.rb

@@ -68,7 +68,7 @@ module HoptoadNotifier
       self.exception    = args[:exception]
       self.api_key      = args[:api_key]
       self.project_root = args[:project_root]
-      self.url          = args[:url]
+      self.url          = args[:url] || rack_env(:url)
 
       self.notifier_name    = args[:notifier_name]
       self.notifier_version = args[:notifier_version]
@@ -78,12 +78,12 @@ module HoptoadNotifier
       self.ignore_by_filters   = args[:ignore_by_filters]   || []
       self.backtrace_filters   = args[:backtrace_filters]   || []
       self.params_filters      = args[:params_filters]      || []
-      self.parameters          = args[:parameters]          || {}
+      self.parameters          = args[:parameters]          || rack_env(:params) || {}
       self.component           = args[:component] || args[:controller]
       self.action              = args[:action]
 
       self.environment_name = args[:environment_name]
-      self.cgi_data         = args[:cgi_data]
+      self.cgi_data         = args[:cgi_data] || args[:rack_env]
       self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => self.backtrace_filters)
       self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
       self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
@@ -291,5 +291,15 @@ module HoptoadNotifier
         end
       end
     end
+
+    def rack_env(method)
+      rack_request.send(method) if rack_request
+    end
+
+    def rack_request
+      @rack_request ||= if args[:rack_env]
+        ::Rack::Request.new(args[:rack_env])
+      end
+    end
   end
 end

data/lib/hoptoad_notifier/rack.rb

@@ -0,0 +1,40 @@
+module HoptoadNotifier
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Hoptoad and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'hoptoad_notifier'
+  #
+  #   HoptoadNotifier.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use HoptoadNotifier::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard HoptoadNotifier.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        HoptoadNotifier.notify_or_ignore(raised, :rack_env => env)
+        raise
+      end
+
+      if env['rack.exception']
+        HoptoadNotifier.notify_or_ignore(env['rack.exception'], :rack_env => env)
+      end
+
+      response
+    end
+  end
+end

data/lib/hoptoad_notifier/rails.rb

@@ -1,11 +1,37 @@
-if defined?(ActionController::Base) && !ActionController::Base.include?(HoptoadNotifier::Catcher)
-  ActionController::Base.send(:include, HoptoadNotifier::Catcher)
-end
+require 'hoptoad_notifier'
+require 'hoptoad_notifier/rails/controller_methods'
+require 'hoptoad_notifier/rails/action_controller_catcher'
+require 'hoptoad_notifier/rails/error_lookup'
+
+module HoptoadNotifier
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ErrorLookup)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ControllerMethods)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
 
-require 'hoptoad_notifier/rails_initializer'
-HoptoadNotifier::RailsInitializer.initialize
+      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
+                                                      HoptoadNotifier::Rack
+      end
 
-HoptoadNotifier.configure(true) do |config|
-  config.environment_name = RAILS_ENV
-  config.project_root     = RAILS_ROOT
+      HoptoadNotifier.configure(true) do |config|
+        config.logger = rails_logger
+        config.environment_name = RAILS_ENV  if defined?(RAILS_ENV)
+        config.project_root     = RAILS_ROOT if defined?(RAILS_ROOT)
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}" if defined?(::Rails::VERSION)
+      end
+    end
+  end
 end
+
+HoptoadNotifier::Rails.initialize
+

data/lib/hoptoad_notifier/rails/action_controller_catcher.rb

@@ -0,0 +1,29 @@
+module HoptoadNotifier
+  module Rails
+    module ActionControllerCatcher
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_in_public_without_hoptoad, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_hoptoad)
+      end
+
+      private
+
+      # Overrides the rescue_action method in ActionController::Base, but does not inhibit
+      # any custom processing that is defined with Rails 2's exception helpers.
+      def rescue_action_in_public_with_hoptoad(exception)
+        unless hoptoad_ignore_user_agent?
+          HoptoadNotifier.notify_or_ignore(exception, hoptoad_request_data)
+        end
+        rescue_action_in_public_without_hoptoad(exception)
+      end
+
+      def hoptoad_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        HoptoadNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+    end
+  end
+end

data/lib/hoptoad_notifier/rails/controller_methods.rb

@@ -0,0 +1,59 @@
+module HoptoadNotifier
+  module Rails
+    module ControllerMethods
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like HoptoadNotifier.notify.
+      def notify_hoptoad(hash_or_exception)
+        unless consider_all_requests_local || local_request?
+          HoptoadNotifier.notify(hash_or_exception, hoptoad_request_data)
+        end
+      end
+
+      def hoptoad_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        HoptoadNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+      def hoptoad_request_data
+        { :parameters       => hoptoad_filter_if_filtering(params.to_hash),
+          :session_data     => hoptoad_session_data,
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => hoptoad_request_url,
+          :cgi_data         => hoptoad_filter_if_filtering(request.env),
+          :environment_vars => hoptoad_filter_if_filtering(ENV) }
+      end
+
+      def hoptoad_filter_if_filtering(hash)
+        if respond_to?(:filter_parameters)
+          filter_parameters(hash) rescue hash
+        else
+          hash
+        end
+      end
+
+      def hoptoad_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def hoptoad_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.request_uri
+        url
+      end
+    end
+  end
+end
+

data/lib/hoptoad_notifier/rails/error_lookup.rb

@@ -0,0 +1,33 @@
+module HoptoadNotifier
+  module Rails
+    module ErrorLookup
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_locally_without_hoptoad, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_hoptoad)
+      end
+
+      private
+
+      def rescue_action_locally_with_hoptoad(exception)
+        result = rescue_action_locally_without_hoptoad(exception)
+
+        if HoptoadNotifier.configuration.development_lookup
+          path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
+          notice = HoptoadNotifier.build_lookup_hash_for(exception, hoptoad_request_data)
+
+          result << @template.render(
+            :file          => path,
+            :use_full_path => false,
+            :locals        => { :host    => HoptoadNotifier.configuration.host,
+                                :api_key => HoptoadNotifier.configuration.api_key,
+                                :notice  => notice })
+        end
+
+        result
+      end
+    end
+  end
+end
+

data/lib/hoptoad_notifier/tasks.rb

@@ -21,10 +21,8 @@ namespace :hoptoad do
     RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
 
     require 'action_controller/test_process'
-    require 'app/controllers/application' if File.exists?('app/controllers/application.rb')
 
-    request = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
+    Dir["app/controllers/application*.rb"].each { |file| require(file) }
 
     class HoptoadTestingException < RuntimeError; end
 
@@ -35,10 +33,11 @@ namespace :hoptoad do
 
     HoptoadNotifier.configuration.development_environments = []
 
-    in_controller = ApplicationController.included_modules.include? HoptoadNotifier::Catcher
-    in_base = ActionController::Base.included_modules.include? HoptoadNotifier::Catcher
+    catcher = HoptoadNotifier::Rails::ActionControllerCatcher
+    in_controller = ApplicationController.included_modules.include?(catcher)
+    in_base = ActionController::Base.included_modules.include?(catcher)
     if !in_controller || !in_base
-      puts "HoptoadNotifier::Catcher must be included inside your ApplicationController class."
+      puts "Rails initialization did not occur"
       exit
     end
 
@@ -47,6 +46,11 @@ namespace :hoptoad do
       puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
     end
 
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      exit
+    end
+
     puts 'Setting up the Controller.'
     class ApplicationController
       # This is to bypass any filters that may prevent access to the action.
@@ -56,7 +60,7 @@ namespace :hoptoad do
         raise exception_class.new, 'Testing hoptoad via "rake hoptoad:test". If you can see this, it works.'
       end
 
-      def rescue_action exception
+      def rescue_action(exception)
         rescue_action_in_public exception
       end
 
@@ -82,9 +86,11 @@ namespace :hoptoad do
         nil
       end
     end
+    class HoptoadVerificationController < ApplicationController; end
 
     puts 'Processing request.'
-    class HoptoadVerificationController < ApplicationController; end
+    request = ActionController::TestRequest.new
+    response = ActionController::TestResponse.new
     HoptoadVerificationController.new.process(request, response)
   end
 end

data/lib/hoptoad_notifier/version.rb

@@ -1,3 +1,3 @@
 module HoptoadNotifier
-  VERSION = "2.1.3".freeze
+  VERSION = "2.2.0".freeze
 end

data/test/catcher_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-class CatcherTest < Test::Unit::TestCase
+class ActionControllerCatcherTest < Test::Unit::TestCase
 
   include DefinesConstants
 
@@ -17,7 +17,7 @@ class CatcherTest < Test::Unit::TestCase
 
   def build_controller_class(&definition)
     returning Class.new(ActionController::Base) do |klass|
-      klass.__send__(:include, HoptoadNotifier::Catcher)
+      klass.__send__(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
       klass.class_eval(&definition) if definition
       define_constant('HoptoadTestController', klass)
     end
@@ -29,13 +29,23 @@ class CatcherTest < Test::Unit::TestCase
       if value.respond_to?(:to_hash)
         assert_sent_hash value.to_hash, element_xpath
       else
-        assert_sent_element value.to_s, element_xpath
+        assert_sent_element value, element_xpath
       end
     end
   end
 
   def assert_sent_element(value, xpath)
-    assert_valid_node last_sent_notice_document, xpath, value
+    assert_valid_node last_sent_notice_document, xpath, stringify_array_elements(value).to_s
+  end
+
+  def stringify_array_elements(data)
+    if data.respond_to?(:to_ary)
+      data.collect do |value|
+        stringify_array_elements(value)
+      end
+    else
+      data.to_s
+    end
   end
 
   def assert_sent_request_info_for(request)
@@ -172,7 +182,7 @@ class CatcherTest < Test::Unit::TestCase
 
   should "not create actions from Hoptoad methods" do
     controller = build_controller_class.new
-    assert_equal [], HoptoadNotifier::Catcher.instance_methods
+    assert_equal [], HoptoadNotifier::Rails::ActionControllerCatcher.instance_methods
   end
 
   should "ignore exceptions when user agent is being ignored by regular expression" do

data/test/configuration_test.rb

@@ -28,6 +28,7 @@ class ConfigurationTest < Test::Unit::TestCase
     assert_config_default :ignore,
                           HoptoadNotifier::Configuration::IGNORE_DEFAULT
     assert_config_default :development_lookup, true
+    assert_config_default :framework, 'Standalone'
   end
 
   should "provide default values for secure connections" do

data/test/helper.rb

@@ -3,10 +3,12 @@ require 'rubygems'
 
 gem 'jferris-mocha', '>= 0.9.5.0.1241126838'
 
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. vendor ginger lib])
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
 require 'shoulda'
 require 'mocha'
 
-$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. vendor ginger lib])
 require 'ginger'
 
 require 'action_controller'
@@ -15,8 +17,9 @@ require 'active_record'
 require 'active_record/base'
 require 'active_support'
 require 'nokogiri'
+require 'rack'
 
-require File.join(File.dirname(__FILE__), "..", "lib", "hoptoad_notifier")
+require "hoptoad_notifier"
 
 begin require 'redgreen'; rescue LoadError; end
 
@@ -234,4 +237,3 @@ class FakeLogger
   def fatal(*args); end
 end
 
-RAILS_DEFAULT_LOGGER = FakeLogger.new

data/test/notice_test.rb

@@ -143,7 +143,7 @@ class NoticeTest < Test::Unit::TestCase
   end
 
   should "use the caller as the backtrace for an exception without a backtrace" do
-    filters = HoptoadNotifier.configuration.backtrace_filters
+    filters = HoptoadNotifier::Configuration.new.backtrace_filters
     backtrace = HoptoadNotifier::Backtrace.parse(caller, :filters => filters)
     notice = build_notice(:exception => StandardError.new('error'), :backtrace => nil)
 
@@ -338,6 +338,21 @@ class NoticeTest < Test::Unit::TestCase
     end
   end
 
+  should "extract data from a rack environment hash" do
+    # TODO: extract session data
+    # TODO: extract controller
+    # TODO: extract action
+    url = "https://subdomain.happylane.com:100/test/file.rb?var=value&var2=value2"
+    parameters = { 'var' => 'value', 'var2' => 'value2' }
+    env = Rack::MockRequest.env_for(url)
+
+    notice = build_notice(:rack_env => env)
+
+    assert_equal url, notice.url
+    assert_equal parameters, notice.parameters
+    assert_equal 'GET', notice.cgi_data['REQUEST_METHOD']
+  end
+
   def assert_accepts_exception_attribute(attribute, args = {}, &block)
     exception = build_exception
     block ||= lambda { exception.send(attribute) }

data/test/rack_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RackTest < Test::Unit::TestCase
+
+  should "call the upstream app with the environment" do
+    environment = { 'key' => 'value' }
+    app = lambda { |env| ['response', {}, env] }
+    stack = HoptoadNotifier::Rack.new(app)
+
+    response = stack.call(environment)
+
+    assert_equal ['response', {}, environment], response
+  end
+
+  should "deliver an exception raised while calling an upstream app" do
+    HoptoadNotifier.stubs(:notify_or_ignore)
+
+    exception = build_exception
+    environment = { 'key' => 'value' }
+    app = lambda do |env|
+      raise exception
+    end
+
+    begin
+      stack = HoptoadNotifier::Rack.new(app)
+      stack.call(environment)
+    rescue Exception => raised
+      assert_equal exception, raised
+    else
+      flunk "Didn't raise an exception"
+    end
+
+    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+  should "deliver an exception in rack.exception" do
+    HoptoadNotifier.stubs(:notify_or_ignore)
+    exception = build_exception
+    environment = { 'key' => 'value' }
+
+    response = [200, {}, ['okay']]
+    app = lambda do |env|
+      env['rack.exception'] = exception
+      response
+    end
+    stack = HoptoadNotifier::Rack.new(app)
+
+    actual_response = stack.call(environment)
+
+    assert_equal response, actual_response
+    assert_received(HoptoadNotifier, :notify_or_ignore) do |expect|
+      expect.with(exception, :rack_env => environment)
+    end
+  end
+
+end

data/test/rails_initializer_test.rb

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'hoptoad_notifier', 'rails_initializer')
+
+require 'hoptoad_notifier/rails'
 
 class RailsInitializerTest < Test::Unit::TestCase
   include DefinesConstants
@@ -11,20 +12,20 @@ class RailsInitializerTest < Test::Unit::TestCase
       end
     end
     define_constant("Rails", rails)
-    HoptoadNotifier::RailsInitializer.initialize
+    HoptoadNotifier::Rails.initialize
     assert_equal "RAILS LOGGER", HoptoadNotifier.logger
   end
 
   should "trigger use of Rails' default logger if logger isn't set and Rails.logger doesn't exist" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
 
-    HoptoadNotifier::RailsInitializer.initialize
+    HoptoadNotifier::Rails.initialize
     assert_equal "RAILS DEFAULT LOGGER", HoptoadNotifier.logger
   end
 
   should "allow overriding of the logger if already assigned" do
     define_constant("RAILS_DEFAULT_LOGGER", "RAILS DEFAULT LOGGER")
-    HoptoadNotifier::RailsInitializer.initialize
+    HoptoadNotifier::Rails.initialize
 
     HoptoadNotifier.configure(true) do |config|
       config.logger = "OVERRIDDEN LOGGER"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hoptoad_notifier
 version: !ruby/object:Gem::Version 
-  version: 2.1.3
+  version: 2.2.0
 platform: ruby
 authors: 
 - thoughtbot, inc
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-27 00:00:00 -05:00
+date: 2010-02-18 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -81,6 +81,7 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- CHANGELOG
 - INSTALL
 - MIT-LICENSE
 - Rakefile
@@ -95,11 +96,13 @@ files:
 - generators/hoptoad/templates/initializer.rb
 - lib/hoptoad_notifier/backtrace.rb
 - lib/hoptoad_notifier/capistrano.rb
-- lib/hoptoad_notifier/catcher.rb
 - lib/hoptoad_notifier/configuration.rb
 - lib/hoptoad_notifier/notice.rb
+- lib/hoptoad_notifier/rack.rb
+- lib/hoptoad_notifier/rails/action_controller_catcher.rb
+- lib/hoptoad_notifier/rails/controller_methods.rb
+- lib/hoptoad_notifier/rails/error_lookup.rb
 - lib/hoptoad_notifier/rails.rb
-- lib/hoptoad_notifier/rails_initializer.rb
 - lib/hoptoad_notifier/sender.rb
 - lib/hoptoad_notifier/tasks.rb
 - lib/hoptoad_notifier/version.rb
@@ -113,6 +116,7 @@ files:
 - test/logger_test.rb
 - test/notice_test.rb
 - test/notifier_test.rb
+- test/rack_test.rb
 - test/rails_initializer_test.rb
 - test/sender_test.rb
 - rails/init.rb
@@ -156,5 +160,6 @@ test_files:
 - test/logger_test.rb
 - test/notice_test.rb
 - test/notifier_test.rb
+- test/rack_test.rb
 - test/rails_initializer_test.rb
 - test/sender_test.rb

data/lib/hoptoad_notifier/catcher.rb

@@ -1,95 +0,0 @@
-module HoptoadNotifier
-  # Include this module in Controllers in which you want to be notified of errors.
-  module Catcher
-
-    # Sets up an alias chain to catch exceptions when Rails does
-    def self.included(base) #:nodoc:
-      if base.instance_methods.map(&:to_s).include? 'rescue_action_in_public' and !base.instance_methods.map(&:to_s).include? 'rescue_action_in_public_without_hoptoad'
-        base.send(:alias_method, :rescue_action_in_public_without_hoptoad, :rescue_action_in_public)
-        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_hoptoad)
-        base.send(:alias_method, :rescue_action_locally_without_hoptoad, :rescue_action_locally)
-        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_hoptoad)
-      end
-    end
-
-    private
-
-    # Overrides the rescue_action method in ActionController::Base, but does not inhibit
-    # any custom processing that is defined with Rails 2's exception helpers.
-    def rescue_action_in_public_with_hoptoad(exception)
-      unless hoptoad_ignore_user_agent?
-        HoptoadNotifier.notify_or_ignore(exception, hoptoad_request_data)
-      end
-      rescue_action_in_public_without_hoptoad(exception)
-    end
-
-    def rescue_action_locally_with_hoptoad(exception)
-      result = rescue_action_locally_without_hoptoad(exception)
-
-      if HoptoadNotifier.configuration.development_lookup
-        path   = File.join(File.dirname(__FILE__), '..', 'templates', 'rescue.erb')
-        notice = HoptoadNotifier.build_lookup_hash_for(exception, hoptoad_request_data)
-
-        result << @template.render(
-          :file          => path,
-          :use_full_path => false,
-          :locals        => { :host    => HoptoadNotifier.configuration.host,
-                              :api_key => HoptoadNotifier.configuration.api_key,
-                              :notice  => notice })
-      end
-
-      result
-    end
-
-    # This method should be used for sending manual notifications while you are still
-    # inside the controller. Otherwise it works like HoptoadNotifier.notify.
-    def notify_hoptoad(hash_or_exception)
-      unless consider_all_requests_local || local_request?
-        HoptoadNotifier.notify(hash_or_exception, hoptoad_request_data)
-      end
-    end
-
-    def hoptoad_ignore_user_agent? #:nodoc:
-      # Rails 1.2.6 doesn't have request.user_agent, so check for it here
-      user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-      HoptoadNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-    end
-
-    def hoptoad_request_data
-      { :parameters       => hoptoad_filter_if_filtering(params.to_hash),
-        :session_data     => hoptoad_session_data,
-        :controller       => params[:controller],
-        :action           => params[:action],
-        :url              => hoptoad_request_url,
-        :cgi_data         => hoptoad_filter_if_filtering(request.env),
-        :environment_vars => hoptoad_filter_if_filtering(ENV) }
-    end
-
-    def hoptoad_filter_if_filtering(hash)
-      if respond_to?(:filter_parameters)
-        filter_parameters(hash) rescue hash
-      else
-        hash
-      end
-    end
-
-    def hoptoad_session_data
-      if session.respond_to?(:to_hash)
-        session.to_hash
-      else
-        session.data
-      end
-    end
-
-    def hoptoad_request_url
-      url = "#{request.protocol}#{request.host}"
-
-      unless [80, 443].include?(request.port)
-        url << ":#{request.port}"
-      end
-
-      url << request.request_uri
-      url
-    end
-  end
-end

data/lib/hoptoad_notifier/rails_initializer.rb

@@ -1,16 +0,0 @@
-module HoptoadNotifier
-  # used to initialize Rails-specific code
-  class RailsInitializer
-    def self.initialize
-      rails_logger = if defined?(Rails.logger)
-                       Rails.logger
-                     elsif defined?(RAILS_DEFAULT_LOGGER)
-                       RAILS_DEFAULT_LOGGER
-                     end
-
-      HoptoadNotifier.configure(true) do |config|
-        config.logger = rails_logger if config.respond_to? :logger
-      end
-    end
-  end
-end