sonic-pi

ActiveSupport::Callbacks::ClassMethods#define_callbacks

Define sets of events in the object life cycle that support callbacks.

  define_callbacks :validate
  define_callbacks :initialize, :save, :destroy

===== Options

* <tt>:terminator</tt> - Determines when a before filter will halt the
  callback chain, preventing following callbacks from being called and
  the event from being triggered. This should be a lambda to be executed.
  The current object and the return result of the callback will be called
  with the lambda.

    define_callbacks :validate, terminator: ->(target, result) { result == false }

  In this example, if any before validate callbacks returns +false+,
  other callbacks are not executed. Defaults to +false+, meaning no value
  halts the chain.

* <tt>:skip_after_callbacks_if_terminated</tt> - Determines if after
  callbacks should be terminated by the <tt>:terminator</tt> option. By
  default after callbacks executed no matter if callback chain was
  terminated or not. Option makes sense only when <tt>:terminator</tt>
  option is specified.

* <tt>:scope</tt> - Indicates which methods should be executed when an
  object is used as a callback.

    class Audit
      def before(caller)
        puts 'Audit: before is called'
      end

      def before_save(caller)
        puts 'Audit: before_save is called'
      end
    end

    class Account
      include ActiveSupport::Callbacks

      define_callbacks :save
      set_callback :save, :before, Audit.new

      def save
        run_callbacks :save do
          puts 'save in main'
        end
      end
    end

  In the above case whenever you save an account the method
  <tt>Audit#before</tt> will be called. On the other hand

    define_callbacks :save, scope: [:kind, :name]

  would trigger <tt>Audit#before_save</tt> instead. That's constructed
  by calling <tt>#{kind}_#{name}</tt> on the given instance. In this
  case "kind" is "before" and "name" is "save". In this context +:kind+
  and +:name+ have special meanings: +:kind+ refers to the kind of
  callback (before/after/around) and +:name+ refers to the method on
  which callbacks are being defined.

  A declaration like

    define_callbacks :save, scope: [:name]

  would call <tt>Audit#save</tt>.

Source | Google | Stack overflow