ActiveSupport::Callbacks::ClassMethods

define_callbacks(*names) 链接

定义对象生命周期中支持回调的事件集。

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

选项¶ ↑

:terminator - 确定 before 过滤器何时会中断回调链，阻止调用后续的 before 和 around 回调，并阻止事件触发。这应该是一个 lambda 函数。当前对象和回调的 lambda 结果将被提供给 terminator lambda。
```
define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
```
在此示例中，如果任何 before validate 回调返回 false，则不会执行任何后续的 before 和 around 回调。

默认的 terminator 会在回调抛出 :abort 时中断链。
:skip_after_callbacks_if_terminated - 确定 after 回调是否应被 :terminator 选项终止。默认情况下，无论回调链是否被终止，after 回调都会被执行。如果 :terminator 选项设置为 nil，此选项无效。
:scope - 指示当对象用作回调时应执行哪些方法。
```
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
```
在上面的例子中，每当保存一个账户时，都会调用 Audit#before 方法。另一方面，
```
define_callbacks :save, scope: [:kind, :name]
```
将改为触发 Audit#before_save。这是通过调用给定实例上的 #{kind}_#{name} 来构造的。在这种情况下，“kind”是“before”，“name”是“save”。在此上下文中，:kind 和 :name 具有特殊含义：“kind”指的是回调的类型（before/after/around），“name”指的是正在定义回调的方法。

像这样的声明
```
define_callbacks :save, scope: [:name]
```
将调用 Audit#save。

注意¶ ↑

传递给 define_callbacks 的 names 不能以 !、? 或 = 结尾。

多次使用相同的 names 调用 define_callbacks 会覆盖之前使用 set_callback 注册的回调。

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/callbacks.rb, line 903
        def define_callbacks(*names)
          options = names.extract_options!

          names.each do |name|
            name = name.to_sym

            module_eval <<-RUBY, __FILE__, __LINE__ + 1
              def _run_#{name}_callbacks
                yield if block_given?
              end
              silence_redefinition_of_method(:_run_#{name}_callbacks)

              def _run_#{name}_callbacks!(&block)
                run_callbacks #{name.inspect}, &block
              end

              def self._#{name}_callbacks
                get_callbacks(#{name.inspect})
              end

              def self._#{name}_callbacks=(value)
                set_callbacks(#{name.inspect}, value)
              end

              def _#{name}_callbacks
                __callbacks[#{name.inspect}]
              end
            RUBY

            ([self] + self.descendants).each do |target|
              target.set_callbacks name, CallbackChain.new(name, options)
            end
          end
        end

reset_callbacks(name) 链接

移除给定事件的所有已设置回调。

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/callbacks.rb, line 813
def reset_callbacks(name)
  callbacks = get_callbacks name

  self.descendants.each do |target|
    chain = target.get_callbacks(name).dup
    callbacks.each { |c| chain.delete(c) }
    target.set_callbacks name, chain
  end

  set_callbacks(name, callbacks.dup.clear)
end

set_callback(name, *filter_list, &block) 链接

为给定事件安装回调。

set_callback :save, :before, :before_method
set_callback :save, :after,  :after_method, if: :condition
set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }

第二个参数指示回调是运行在事件的 :before、:after 还是 :around。如果省略，则默认为 :before。这意味着上面的第一个示例也可以写成

set_callback :save, :before_method

回调可以指定为命名实例方法的符号；作为 proc、lambda 或块；或者作为一个响应 define_callbacks 的 :scope 参数确定的某个方法的对象。

如果提供 proc、lambda 或块，其主体将在当前对象的上下文中进行评估。它还可以选择接受当前对象作为参数。

Before 和 around 回调按设置的顺序调用；after 回调按相反的顺序调用。

Around 回调可以访问事件的返回值（如果它没有被中断），通过 yield 调用。

选项¶ ↑

:if - 一个符号或符号数组，每个符号命名一个实例方法或 proc；仅当所有这些都返回 true 值时，才会调用回调。

如果提供 proc，其主体将在当前对象的上下文中进行评估。它还可以选择接受当前对象作为参数。
:unless - 一个符号或符号数组，每个符号命名一个实例方法或 proc；仅当所有这些都返回 false 值时，才会调用回调。

如果提供 proc，其主体将在当前对象的上下文中进行评估。它还可以选择接受当前对象作为参数。
:prepend - 如果为 true，回调将被添加到现有链的前面，而不是后面。

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/callbacks.rb, line 739
def set_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)

  self_chain = get_callbacks name
  mapped = filters.map do |filter|
    Callback.build(self_chain, filter, type, options)
  end

  __update_callbacks(name) do |target, chain|
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.set_callbacks name, chain
  end
end

skip_callback(name, *filter_list, &block) 链接

跳过先前设置的回调。与 set_callback 类似，可以传递 :if 或 :unless 选项来控制何时跳过回调。

注意：此示例使用了 PersonRecord 和 saving_message，您可以在此处查看它们的定义

class Writer < PersonRecord
  attr_accessor :age
  skip_callback :save, :before, :saving_message, if: -> { age > 18 }
end

当 if 选项返回 true 时，回调被跳过。

writer = Writer.new
writer.age = 20
writer.save

输出

- save
saved

当 if 选项返回 false 时，回调不被跳过。

young_writer = Writer.new
young_writer.age = 17
young_writer.save

输出

saving...
- save
saved

如果回调尚未设置（除非 :raise 选项设置为 false），则会引发 ArgumentError。

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/callbacks.rb, line 788
def skip_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)

  options[:raise] = true unless options.key?(:raise)

  __update_callbacks(name) do |target, chain|
    filters.each do |filter|
      callback = chain.find { |c| c.matches?(type, filter) }

      if !callback && options[:raise]
        raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined"
      end

      if callback && (options.key?(:if) || options.key?(:unless))
        new_callback = callback.merge_conditional_options(chain, if_option: options[:if], unless_option: options[:unless])
        chain.insert(chain.index(callback), new_callback)
      end

      chain.delete(callback)
    end
    target.set_callbacks name, chain
  end
end

模块 ActiveSupport::Callbacks::ClassMethods

实例公共方法

define_callbacks(*names) 链接

选项¶ ↑

注意¶ ↑

reset_callbacks(name) 链接

set_callback(name, *filter_list, &block) 链接

选项¶ ↑

skip_callback(name, *filter_list, &block) 链接