Ruby rescue exception during multiple methods

Question

I have built a simple banking application, which is able to perform the usual operations; Deposit, Withdraw etc.

My controller methods perform these operations and rescue exceptions that are raised by the account or other entities.

Here are some of these methods used in the controller code:

def open(type, with:)
    account = create type, (holders.find with)
    add account
    init_yearly_interest_for account
    boundary.render AccountSuccessMessage.new(account)
  rescue ItemExistError => message
    boundary.render message
  end

  def deposit(amount, into:)
    account = find into
    account.deposit amount
    boundary.render DepositSuccessMessage.new(amount)
  rescue ItemExistError => message
    boundary.render message
  end

  def withdraw(amount, from:)
    account = find from
    init_limit_reset_for account unless account.breached?
    account.withdraw amount
    boundary.render WithdrawSuccessMessage.new(amount)
  rescue ItemExistError, OverLimit, InsufficientFunds => message
    boundary.render message
  end

  def get_balance_of(id)
    account = find id
    boundary.render BalanceMessage.new(account)
  rescue ItemExistError => message
    boundary.render message
  end

  def transfer(amount, from:, to:)
    donar = find from
    recipitent = find to
    init_limit_reset_for donar unless donar.breached?
    donar.withdraw amount
    recipitent.deposit amount
    boundary.render TransferSuccessMessage.new(amount)
  rescue ItemExistError, OverLimit, InsufficientFunds => message
    boundary.render message
  end

  def add_holder(id, to:)
    holder = holders.find id
    account = find to
    account.add_holder holder
    boundary.render AddHolderSuccessMessage.new(holder, account)
  rescue ItemExistError, HolderOnAccount => message
    boundary.render message
  end

  def get_transactions_of(id)
    transactions = (find id).transactions
    boundary.render TransactionsMessage.new(transactions)
  rescue ItemExistError => message
    boundary.render message
  end

  def get_accounts_of(id)
    holder = holders.find id
    accounts = store.select { |_, a| a.holder? holder }.values
    boundary.render DisplayAccountsMessage.new(accounts)
  rescue ItemExistError => message
    boundary.render message
  end

As you can see I am rescuing multiple errors during multiple methods, often the same errors are handled.

Although this is working, I wonder if it is possible to refactor and handle these exceptions whenever any of the methods in the controller are called.

So for example:

during: 
  open, deposit, withdraw
rescue ItemExistError => message
  boundary.render message

Any help would be greatly appreciated.

Answer 1

Rails' ActiveSupport gem provides the rescue_from helper:

https://edgeapi.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from

class MyController < ApplicationController
  rescue_from ItemExistError, with: :item_exist_error

  def get_transactions_of(id)
    transactions = (find id).transactions
    boundary.render TransactionsMessage.new(transactions)
  end


  def get_accounts_of(id)
    holder = holders.find id
    accounts = store.select { |_, a| a.holder? holder }.values
    boundary.render DisplayAccountsMessage.new(accounts)
  end

  private

  def item_exist_error(_exception)
    boundary.render message
  end
end

Answer 2

You can do this with metaprogramming by defining a method that wraps each of the methods you want to rescue from. It's your call whether or not this is actually cleaner code.

class MyController
  # define a unified exception handler for some methods
  def self.rescue_from *meths, exception, &handler
    meths.each do |meth|
      # store the previous implementation
      old = instance_method(meth)
      # wrap it
      define_method(meth) do |*args|
        begin
          old.bind(self).call(*args)
        rescue exception => e
          handler.call(e)
        end
      end
    end
  end

  rescue_from :open, :deposit, :withdraw, ItemExistError do |message|
    boundary.render message
  end
end

If you aren't going to reuse the method (i.e. if you only want a unified handler for this one set of methods and this one exception class), I would remove the rescue_from definition and put the metaprogramming code right in the class.

Answer 3

Would a before and after style callback help?

Variables to store the list of actions that have callbacks

@before_actions = Hash.new {|hash,key| hash[key] = Array.new}
@after_actions = Hash.new {|hash,key| hash[key] = Array.new}

Defining the before_action method action is the callback to be executed, methods is an array of actions that have callbacks assigned to them

def before_action(action, methods)  
  methods.each do |m|
    @before_actions[m] << action
  end
end

def after_action(action, methods)  
  methods.each do |m|
    @after_actions[m] << action
  end
end

Block used inside our methods that allows us to use these callbacks

def execute_callbacks  
  @before_actions.each {|k,v| v.each {|v| send(v)}}
  yield
  @after_actions.each {|k,v| v.each {|v| send(v)}}
end

Declaring the before and after actions that we want to occur (maybe put callbacks like #first_do_this and #lastly_do_this as private methods?)

before_action :first_do_this, [:do_something]  
after_action :lastly_do_this, [:do_something]

private
def first_do_this  
  puts "this occurs first"
end

def lastly_do_this  
  puts "this occurs last"
end

Our method that we want to work around. (I know its not that elegant, it could be improved)

def do_something  
  execute_callbacks do
    puts "hello world"
  end
end

When do_something is called

do_something # =>
  this occurs first
  hello world
  this occurs last

Answer 4

You could try writing a method like this:

def call_and_rescue
  yield if block_given?
rescue ItemExistError => message
  boundary.render message
end

Then use it: call_and_rescue { open(type, with) }