Is it possible to verify the number of methods assigned to a Proc in Ruby?

Question

I'm currently working on a DSL in relation to accounting. What I'd like to be able to do is:

accountant do
  credit @account_1, -@amount
  debit  @account_2,  @amount
end

Currently, this executes the following method:

class Accountant
  def accountant &block
    AccountantHelper.class_eval(&block)
  end
end

...Which in turn executes the block on the AccountantHelper class, calling the "credit" and "debit" methods respectively:

class AccountantHelper
  def self.credit account, amount
    account.credit amount
  end

  def self.debit account, amount
    account.debit amount
  end
end

(Please hold back any fire about using class_eval() -- this is only a prototype after all!)

The goal is for the block to act as a transaction, ensuring that if the entire block can't be executed successfully, then none of it should. However in addition to this, it should also verify the integrity of the data passed into the block. In this case I need to verify that there is both a "credit" and a "debit" method within the block (in double-entry accounting, for every credit there must also be at least one debit, and vice versa). Currently I could call:

accountant do
  credit @account_1, @amount
end

...And the code will execute without any errors. This would be a bad thing as there is no corresponding "debit" to keep the accounts in balance.

Is it possible to verify what gets passed into the block? Or am I heading down the wrong path here?

Answer 1

I guess you can make your credit and debit actions "lazy", so that they are executed by the wrapper method, after the validation. Here's a proof of concept, similar to yours, but without metaprogramming part, skipped for clarity:

def transaction
  yield
  if @actions.map(&:last).inject(&:+) == 0
    @actions.each do |account, amount|
      @accounts[account] += amount
    end
    @actions = []
    puts 'transaction executed ok'
  else
    puts 'balance not zero, rolling back transaction'
    # rollback (effectively, do nothing)
  end
end

def credit account, amount
  @actions << [account, amount]
end

def debit account, amount
  @actions<< [account, -amount]
end

@actions = []
@accounts = {a: 0, b: 0, c: 0} # start with three blank accounts

transaction do
  credit :a, 5
  debit :b, 2
  debit :c, 3
end
#=>transaction executed ok

p @accounts
#=>{:a=>5, :b=>-2, :c=>-3}

transaction do
  credit :a, 5
  debit :b, 4
end
#=> balance not zero, rolling back transaction

p @accounts
#=> {:a=>5, :b=>-2, :c=>-3}