module ActiveSupport::Rescuable::ClassMethods

def constantize_rescue_handler_class(class_or_name) 

def constantize_rescue_handler_class(class_or_name)
  case class_or_name
  when String, Symbol
    begin
      # Try a lexical lookup first since we support
      #
      #     class Super
      #       rescue_from 'Error', with: …
      #     end
      #
      #     class Sub
      #       class Error < StandardError; end
      #     end
      #
      # so an Error raised in Sub will hit the 'Error' handler.
      const_get class_or_name
    rescue NameError
      class_or_name.safe_constantize
    end
  else
    class_or_name
  end
end

def find_rescue_handler(exception) 

def find_rescue_handler(exception)
  if exception
    # Handlers are in order of declaration but the most recently declared
    # is the highest priority match, so we search for matching handlers
    # in reverse.
    _, handler = rescue_handlers.reverse_each.detect do |class_or_name, _|
      if klass = constantize_rescue_handler_class(class_or_name)
        klass === exception
      end
    end
    handler
  end
end

def handler_for_rescue(exception, object: self) # :nodoc:

:nodoc: 
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

def rescue_from(*klasses, with: nil, &block)

Exceptions raised inside exception handlers are not propagated up.

end
end
redirect_back_or_to root_url, alert: exception.record.errors.full_messages.to_sentence
def show_record_errors(exception)

end
head :forbidden
def deny_access
private

end
redirect_to root_url, alert: exception.message
rescue_from "MyApp::BaseError" do |exception|

rescue_from ActiveRecord::RecordInvalid, with: :show_record_errors
rescue_from User::NotAuthorized, with: :deny_access
class ApplicationController < ActionController::Base

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

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

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

Registers exception classes with a handler to be called by rescue_with_handler. 
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

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

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

end
rescue_with_handler(exception) || raise
rescue => exception
# ...
begin

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

Matches an exception to a handler based on the exception class. 
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