Module: ActiveSupport::Rescuable::ClassMethods

Defined in:
lib/active_support/rescuable.rb

Instance Method Summary collapse

Instance Method Details

#handler_for_rescue(exception, object: self) ⇒ Object

:nodoc:



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/active_support/rescuable.rb', line 103

def handler_for_rescue(exception, object: self) #:nodoc:
  case rescuer = find_rescue_handler(exception)
  when Symbol
    method = object.method(rescuer)
    if method.arity == 0
      -> e { method.call }
    else
      method
    end
  when Proc
    if rescuer.arity == 0
      -> e { object.instance_exec(&rescuer) }
    else
      -> e { object.instance_exec(e, &rescuer) }
    end
  end
end

#rescue_from(*klasses, with: nil, &block) ⇒ Object

Registers exception classes with a handler to be called by rescue_with_handler.

rescue_from receives a series of exception classes or class names, and an exception handler specified by a trailing :with option containing the name of a method or a Proc object. Alternatively, a block can be given as the handler.

Handlers that take one argument will be called with the exception, so that the exception can be inspected when dealing with it.

Handlers are inherited. They are searched from right to left, from bottom to top, and up the hierarchy. The handler of the first class for which exception.is_a?(klass) holds true is the one invoked, if any.

class ApplicationController < ActionController::Base
  rescue_from User::NotAuthorized, with: :deny_access # self defined exception
  rescue_from ActiveRecord::RecordInvalid, with: :show_errors

  rescue_from 'MyAppError::Base' do |exception|
    render xml: exception, status: 500
  end

  private
    def deny_access
      ...
    end

    def show_errors(exception)
      exception.record.new_record? ? ...
    end
end

Exceptions raised inside exception handlers are not propagated up.



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/active_support/rescuable.rb', line 51

def rescue_from(*klasses, with: nil, &block)
  unless with
    if block_given?
      with = block
    else
      raise ArgumentError, "Need a handler. Pass the with: keyword argument or provide a block."
    end
  end

  klasses.each do |klass|
    key = if klass.is_a?(Module) && klass.respond_to?(:===)
      klass.name
    elsif klass.is_a?(String)
      klass
    else
      raise ArgumentError, "#{klass.inspect} must be an Exception class or a String referencing an Exception class"
    end

    # Put the new handler at the end because the list is read in reverse.
    self.rescue_handlers += [[key, with]]
  end
end

#rescue_with_handler(exception, object: self, visited_exceptions: []) ⇒ Object

Matches an exception to a handler based on the exception class.

If no handler matches the exception, check for a handler matching the (optional) exception.cause. If no handler matches the exception or its cause, this returns nil, so you can deal with unhandled exceptions. Be sure to re-raise unhandled exceptions if this is what you expect.

begin
  …
rescue => exception
  rescue_with_handler(exception) || raise
end

Returns the exception if it was handled and nil if it was not.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/active_support/rescuable.rb', line 88

def rescue_with_handler(exception, object: self, visited_exceptions: [])
  visited_exceptions << exception

  if handler = handler_for_rescue(exception, object: object)
    handler.call exception
    exception
  elsif exception
    if visited_exceptions.include?(exception.cause)
      nil
    else
      rescue_with_handler(exception.cause, object: object, visited_exceptions: visited_exceptions)
    end
  end
end