wrangler 0.1.21 → 0.1.22

data/README.rdoc

@@ -91,15 +91,22 @@ Here is the full set of configuration values for both classes, as well as their
       # match will NOT send notification emails (e.g. for filtering out crazy
       # browsers).
       # array of hashes, each with one key (http header string) and a value
-      # (regexp to match in http header string)
+      # (regexp to match in http header string). this allows for more than one
+      # regexp to be specified for the same header if that's more convenient.
+      # any one pattern match will block notification.
+      # note that this looks in all request headers, including query params
+      # (e.g. form fields, url query params)
       :block_notify_on_request_headers => [],
       # configure whether to send emails synchronously or asynchronously
       # using delayed_job (these can be true even if delayed job is not
       # installed, in which case, will just send emails synchronously anyway)
-      :delayed_job_for_controller_errors => false,
-      :delayed_job_for_non_controller_errors => false,
+      :delayed_job_for_controller_errors => true,
+      :delayed_job_for_non_controller_errors => true,
       # mappings from exception classes to http status codes (see above)
       # add/remove from this list as desired in environment configuration
+      # note that the keys are String names of the classes, not the class
+      # constants themselves
+      # (e.g. "StandardError" => "500",    and _NOT_ StandardError => "500")
       :error_class_status_codes => Wrangler::codes_for_exception_classes,
       # explicitly indicate which exceptions to send email notifications for
       :notify_exception_classes => %w(),
@@ -108,13 +115,21 @@ Here is the full set of configuration values for both classes, as well as their
       # where to look for app-specific error page templates (ones you create
       # yourself, for example...there are some defaults in this gem you can
       # use as well...and that are configured already by default)
-      :error_template_dir => File.join(RAILS_ROOT, 'app', 'views', 'error'),
-      # excplicit mappings from exception class to arbitrary error page
+      :error_template_dir => (defined?(RAILS_ROOT) ? File.join(RAILS_ROOT, 'app', 'views', 'error') : nil),
+      # explicit mappings from exception class to arbitrary error page
       # templates, different set for html and js responses (Wrangler determines
       # which to use automatically, so you can have an entry in both
       # hashes for the same error class)
+      # note that the keys are String names of the classes, not the class
+      # constants themselves
+      # (e.g. "StandardError" => "file",    and _NOT_ StandardError => "file")
       :error_class_html_templates => {},
       :error_class_js_templates => {},
+      # you can specify options to pass to the render() call when rendering
+      # error page for errors. This is applied globally, so plan accordingly
+      # (one good option is to pass in :layout => 'my_layout' so your app
+      # layout gets applied to the error templates)
+      :render_error_options => {},
       # you can specify a fallback failsafe error template to render if
       # no appropriate template is found in the usual places (you shouldn't
       # rely on this, and error messages will be logged if this template is
@@ -130,8 +145,20 @@ Here is the full set of configuration values for both classes, as well as their
       # regexp-style
 
       # just DON'T change this! this is the error template of last resort!
+      # if you do change this, you really should have a good reason for it and
+      # really know what you're doing. really.
       :absolute_last_resort_default_error_template =>
-        File.join(WRANGLER_ROOT,'rails','app','views','wrangler','500.html')
+        File.join(WRANGLER_ROOT,'rails','app','views','wrangler','500.html'),
+      # allows for inserting additional data/comments/status/environment into
+      # the notification emails. possibilities include fetching the release number,
+      # patch info, current state of different services....
+      # pass a proc instance that accepts a single
+      # argument, the request object (if any).
+      # (e.g. +Proc.new { |request| puts "request is: #{request}" }+, but don't
+      # do that, that would be redundant, silly and not secure).
+      # NOTE: +request+ can be nil (if background process, for example), so
+      # implement accordingly
+      :call_for_supplementary_info => nil
 
 #####################
 # ExceptionNotifier:

data/lib/wrangler.rb

@@ -100,7 +100,7 @@ module Wrangler
       
       # if that didn't work, fall back on configured app-specific default
       if file_path.blank? || !File.exists?(file_path)
-        file_path = config[:default_error_template]
+        file_path = Wrangler::Exception_handler.config[:default_error_template]
 
         log_error(["Could not find an error template in the usual places " +
                   "for exception #{exception.class}, status code " +
@@ -110,7 +110,7 @@ module Wrangler
 
       # as a last resort, just render the gem's 500 error
       if file_path.blank? || !File.exists?(file_path)
-        file_path = config[:absolute_last_resort_default_error_template]
+        file_path = Wrangler::ExceptionHandler.config[:absolute_last_resort_default_error_template]
 
         log_error("Still no template found. Using gem default of " +
                   file_path)
@@ -118,8 +118,13 @@ module Wrangler
 
       log_error("Will render error template: '#{file_path}'")
 
-      render :file => file_path,
-             :status => status_code
+      options = { :file => file_path, :status => status_code }
+
+      unless Wrangler::ExceptionHandler.config[:render_error_options].blank?
+        options.merge! Wrangler::ExceptionHandler.config[:render_error_options]
+      end
+
+      render options
     end
 
 
@@ -148,21 +153,20 @@ module Wrangler
       case request.format
       when /html/
         response_format = 'html'
-        template_mappings = config[:error_class_html_templates]
+        template_mappings = Wrangler::ExceptionHandler.config[:error_class_html_templates]
       when /js/
         response_format = 'js'
-        template_mappings = config[:error_class_js_templates]
+        template_mappings = Wrangler::ExceptionHandler.config[:error_class_js_templates]
       when /xml/
         'xml'
       end
       format_extension_pattern = ".#{response_format || ''}*"
 
       if template_mappings
-
         # search for direct mapping from exception name to error template
 
-        if template_mappings[exception_class]
-          error_file = template_mappings[exception_class]
+        if template_mappings[exception_class.name]
+          error_file = template_mappings[exception_class.name]
 
           return error_file if File.exists?(error_file)
 
@@ -172,13 +176,12 @@ module Wrangler
         end
 
         # search for mapping from an ancestor class to error template
-
         ancestor_class =
           Wrangler::class_has_ancestor?(exception_class.superclass,
-                                       template_mappings)
+                                       template_mappings.keys)
 
         if ancestor_class
-          error_file = template_mappings[ancestor_class]
+          error_file = template_mappings[ancestor_class.name]
 
           return error_file if File.exists?(error_file)
 
@@ -191,7 +194,7 @@ module Wrangler
 
       # search for a file named after the exception in one of the search dirs
 
-      search_paths = [ config[:error_template_dir],
+      search_paths = [ Wrangler::ExceptionHandler::config[:error_template_dir],
                        File.join(RAILS_ROOT, 'public'),
                        File.join(WRANGLER_ROOT, 'rails', 'app', 'views', 'wrangler')
                      ]

data/lib/wrangler/exception_handler.rb

@@ -7,28 +7,28 @@ module Wrangler
   def self.codes_for_exception_classes
     classes = {
       # These are standard errors in rails / ruby
-      NameError =>      "503",
-      TypeError =>      "503",
-      RuntimeError =>   "500",
-      ArgumentError =>  "500",
+      NameError.name =>      "503",
+      TypeError.name =>      "503",
+      RuntimeError.name =>   "500",
+      ArgumentError.name =>  "500",
       # the default mapping for an unrecognized exception class
       :default => "500"
     }
 
     # from exception_notification gem:
     # Highly dependent on the verison of rails, so we're very protective about these'
-    classes.merge!({ ActionView::TemplateError => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
-    classes.merge!({ ActiveRecord::RecordNotFound => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
-    classes.merge!({ ActiveResource::ResourceNotFound => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
+    classes.merge!({ ActionView::TemplateError.name => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
+    classes.merge!({ ActiveRecord::RecordNotFound.name => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
+    classes.merge!({ ActiveResource::ResourceNotFound.name => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
 
     # from exception_notification gem:
     if defined?(ActionController)
-      classes.merge!({ ActionController::UnknownController => "404" })          if ActionController.const_defined?(:UnknownController)
-      classes.merge!({ ActionController::MissingTemplate => "404" })            if ActionController.const_defined?(:MissingTemplate)
-      classes.merge!({ ActionController::MethodNotAllowed => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
-      classes.merge!({ ActionController::UnknownAction => "501" })              if ActionController.const_defined?(:UnknownAction)
-      classes.merge!({ ActionController::RoutingError => "404" })               if ActionController.const_defined?(:RoutingError)
-      classes.merge!({ ActionController::InvalidAuthenticityToken => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
+      classes.merge!({ ActionController::UnknownController.name => "404" })          if ActionController.const_defined?(:UnknownController)
+      classes.merge!({ ActionController::MissingTemplate.name => "404" })            if ActionController.const_defined?(:MissingTemplate)
+      classes.merge!({ ActionController::MethodNotAllowed.name => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
+      classes.merge!({ ActionController::UnknownAction.name => "501" })              if ActionController.const_defined?(:UnknownAction)
+      classes.merge!({ ActionController::RoutingError.name => "404" })               if ActionController.const_defined?(:RoutingError)
+      classes.merge!({ ActionController::InvalidAuthenticityToken.name => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
     end
 
     return classes
@@ -72,6 +72,9 @@ module Wrangler
       :delayed_job_for_non_controller_errors => true,
       # mappings from exception classes to http status codes (see above)
       # add/remove from this list as desired in environment configuration
+      # note that the keys are String names of the classes, not the class
+      # constants themselves
+      # (e.g. "StandardError" => "500",    and _NOT_ StandardError => "500")
       :error_class_status_codes => Wrangler::codes_for_exception_classes,
       # explicitly indicate which exceptions to send email notifications for
       :notify_exception_classes => %w(),
@@ -81,12 +84,20 @@ module Wrangler
       # yourself, for example...there are some defaults in this gem you can
       # use as well...and that are configured already by default)
       :error_template_dir => (defined?(RAILS_ROOT) ? File.join(RAILS_ROOT, 'app', 'views', 'error') : nil),
-      # excplicit mappings from exception class to arbitrary error page
+      # explicit mappings from exception class to arbitrary error page
       # templates, different set for html and js responses (Wrangler determines
       # which to use automatically, so you can have an entry in both
       # hashes for the same error class)
+      # note that the keys are String names of the classes, not the class
+      # constants themselves
+      # (e.g. "StandardError" => "file",    and _NOT_ StandardError => "file")
       :error_class_html_templates => {},
       :error_class_js_templates => {},
+      # you can specify options to pass to the render() call when rendering
+      # error page for errors. This is applied globally, so plan accordingly
+      # (one good option is to pass in :layout => 'my_layout' so your app
+      # layout gets applied to the error templates)
+      :render_error_options => {},
       # you can specify a fallback failsafe error template to render if
       # no appropriate template is found in the usual places (you shouldn't
       # rely on this, and error messages will be logged if this template is
@@ -106,7 +117,6 @@ module Wrangler
       # really know what you're doing. really.
       :absolute_last_resort_default_error_template =>
         File.join(WRANGLER_ROOT,'rails','app','views','wrangler','500.html'),
-
       # allows for inserting additional data/comments/status/environment into
       # the notification emails. possibilities include fetching the release number,
       # patch info, current state of different services....
@@ -173,7 +183,7 @@ module Wrangler
       if exception.respond_to?(:status_code)
         return exception.status_code
       else
-        return config[:error_class_status_codes][exception.class] ||
+        return config[:error_class_status_codes][exception.class.name] ||
                config[:error_class_status_codes][:default]
       end
     end

data/lib/wrangler/wrangler_helper.rb

@@ -23,15 +23,19 @@ module Wrangler
   #            classes as an ancestor
   #   - other_klasses: a Class, an Array (or any other container that responds
   #                    to include?() ) of Classes
+  # 
   #-----------------------------------------------------------------------------
   def class_has_ancestor?(klass, other_klasses)
     return nil if !klass.is_a?(Class)
 
-    other_klasses = [other_klasses] if other_klasses.is_a?(Class)
+    other_klasses = [other_klasses] unless other_klasses.is_a?(Array)
+    if other_klasses.first.is_a?(Class)
+      other_klasses.map! { |k| k.name }
+    end
 
     current_klass = klass
     while current_klass
-      return current_klass if other_klasses.include?(current_klass)
+      return current_klass if other_klasses.include?(current_klass.name)
       current_klass = current_klass.superclass
     end
 

data/wrangler.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{wrangler}
-  s.version = "0.1.21"
+  s.version = "0.1.22"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Percival"]
-  s.date = %q{2010-05-18}
+  s.date = %q{2010-06-15}
   s.description = %q{A gem for handling exceptions thrown inside your Rails app. If you include the
 gem in your application controller, wrangler will render the error pages you
 configure for each exception or HTTP error code. It will also handle notifying

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wrangler
 version: !ruby/object:Gem::Version 
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors: 
 - Brian Percival
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-18 00:00:00 -07:00
+date: 2010-06-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency