Asynchronous method calls using Rails’s ActiveJob

class DestroyAccountJob < ActiveJob
  def perform(account)
    account.destroy!
  end
end

# In the code, this will be used like:
DestroyAccountJob.perform_later(account)

include AsyncExecutor

# Call `self.destroy!` in a background job
perform_later(:destroy!)

balance = AccountBalance.create!(account: account)
start_date = 3.months.ago
end_date = Time.now

# 1. With a method name
balance.perform_later(:compute_balance, start_date:, end_date:)

# 2. With a proxy object
balance.perform_later.compute_balance(start_date:, end_date:)

# 3. With a block
balance.perform_later do
  compute_balance(start_date:, end_date:)
end

# app/lib/active_job/async_executor.rb

# Perform any action later (by enqueuing an ad-hoc job), without needing to define a new ActiveJob subclass.
module ActiveJob::AsyncExecutor
  # Internal class. Converts each method called on `target` into an asynchronous job.
  class Proxy
    # @param target [StandardObject]
    def initialize(target)
      @target = target
    end

    def method_missing(method, *args, &block)
      AsyncExecutorJob.perform_later(@target, method, *args)
    end
  end

  # Call the given method later, in an ad-hoc job.
  #
  # @overload perform_later(method)
  #   Invoke the given method on `self` later.
  #   @param method [String, Symbol, nil] the name of the method to call
  #   @return [Proxy]
  #   @example
  #     perform_later(:compute_balance, start_date:, end_date:)
  #
  # @overload perform_later()
  #   Return a proxy to `self`, that will execute methods called on it later.
  #   @return [Proxy]
  #   @example
  #     balance.perform_later.compute_balance(start_date:, end_date:)
  #
  # @overload perform_later{}
  #   Evaluate the block in the receiver's context, and execute methods called on it later.
  #   @yield [] a block evaluated in the receiver's context (optional)
  #   @return [Proxy]
  #   @example
  #     balance.perform_later { compute_balance(start_date:, end_date:) }
  def perform_later(method = nil, *args, &block)
    proxy = Proxy.new(self)
    if block_given?
      proxy.instance_eval(&block)
    elsif method
      proxy.public_send(method, *args)
    else
      proxy
    end
  end
end

# app/jobs/async_executor_job.rb

# See ActiveJob::AsyncExecutor
class AsyncExecutorJob < ApplicationJob
  def perform(target, method, *args)
    target.public_send(method, *args)
  end
end