模块：Mongoid::Interceptable

扩展方式：
ActiveSupport::Concern
包含在：
可组合
定义于：
lib/mongoid/interceptable.rb

Overview

该模块包含 Mongoid 的所有回调钩子。

常量摘要折叠

CALLBACKS = 
[
  :after_build,
  :after_create,
  :after_destroy,
  :after_find,
  :after_initialize,
  :after_save,
  :after_touch,
  :after_update,
  :after_upsert,
  :after_validation,
  :round_create,
  :round_destroy,
  :round_save,
  :round_update,
  :round_upsert,
  :before_create,
  :before_destroy,
  :before_save,
  :before_update,
  :before_upsert,
  :before_validation,
].冻结

实例方法摘要折叠

实例方法详细信息

# _mongoid_run_child_after_callbacks (callback_list: []) ⇒对象

执行 after 回调。

参数：

  • callback_list ( Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ) （默认为： [] ） —

    回调序列和环境对的列表。



250
251
252
253
254
255
 
# File 'lib/mongoid/interceptable.rb', line 250

def _mongoid_run_child_after_callbacks(callback_list: [])
  callback_list.reverse_each do |next_sequence, env|
    next_sequence.invoke_after(env)
    return false if env.已停止
  end
end

# _mongoid_run_child_before_callbacks (Kind,children:[],callback_list:[]) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

对嵌入式文档执行给定类型的 before 回调。

参数：

  • kind (符号) —

    要执行的回调类型。

  • 子项 ( Array< Document > ) （默认为： [] ） —

    要对其执行回调的子项。

  • callback_list ( Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ) （默认为： [] ） —

    回调序列和环境对的列表。 此列表稍后将用于以相反顺序执行 after 回调。



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/mongoid/interceptable.rb', line 229

def _mongoid_run_child_before_callbacks(kind, 子项： [], callback_list: [])
  子项.每 do |子项|
    链 = 子项.__callbacks[child_callback_type(kind, 子项)]
    env = ActiveSupport::回调::筛选器::environment.new(子项, false, nil)
    next_sequence = compile_callbacks(链)
    除非 next_sequence.final？
      Mongoid.记录器.WARN(" 对于嵌入式文档，禁用了周围回调。跳过 #{ child. class.name} 的 周围回调 。 ")
      Mongoid.记录器.WARN("要为嵌入式文档启用回调，请将 Mongoid::Config.round_callbacks_for_embeds设立为 true。 ")
    end
    next_sequence.invoke_before(env)
    return false if env.已停止
    env.值 = !env.已停止
    callback_list << [next_sequence, env]
  end
  callback_list
end

# _mongoid_run_child_callbacks (kind,children: nil, &block) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

为嵌入式文档运行回调。

参数：

  • kind (符号) —

    要执行的回调类型。

  • 子项 ( Array< Document > ) （默认为： nil ） —

    要对其执行回调的子项。 如果为零，则将对文档的所有可级联子文档执行回调。



153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/mongoid/interceptable.rb', line 153

def _mongoid_run_child_callbacks(kind, 子项： nil, 和块)
  if Mongoid::配置.around_callbacks_for_embeds
    _mongoid_run_child_callbacks_with_round(kind,
                                             子项： 子项,
                                             和块)
  else
    _mongoid_run_child_callbacks_Without_round(kind,
                                                子项： 子项,
                                                和块)
  end
end

# _mongoid_run_child_callbacks_with_round (kind,children: nil, &block) ⇒对象

为嵌入式文档执行给定类型的回调，包括周围回调。

参数：

  • kind (符号) —

    要执行的回调类型。

  • 子项 ( Array< Document > ) （默认为： nil ） —

    要对其执行回调的子项。 如果为零，则将对文档的所有可级联子文档执行回调。

    @api private



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/mongoid/interceptable.rb', line 174

def _mongoid_run_child_callbacks_with_round(kind, 子项： nil, 和块)
  子项 = (子项 || cascadable_children(kind))
  with_children = !Mongoid::配置.allow_multiple_calls_of_embedded_callbacks

  return 块&。调用 if 子项.空？

  纤维 = 子项.map do |子项|
    光纤.new do
      子项.run_callbacks(child_callback_type(kind, 子项), with_children: with_children) do
        光纤.产量
      end
    end
  end

  纤维.每 do |纤维|
    纤维.resume
    提高 Mongoid::Errors::InvalidAroundCallback 除非 纤维.alive?
  end

  块&。调用

  纤维.reverse.每(和:resume)
end

# _mongoid_run_child_callbacks_Without_round (Kind,children: nil, &block) ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

为没有周围回调的嵌入式文档执行给定类型的回调。

参数：

  • kind (符号) —

    要执行的回调类型。

  • 子项 ( Array< Document > ) （默认为： nil ） —

    要对其执行回调的子项。 如果为零，则将对文档的所有可级联子文档执行回调。



207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/mongoid/interceptable.rb', line 207

def _mongoid_run_child_callbacks_Without_round(kind, 子项： nil, 和块)
  子项 = (子项 || cascadable_children(kind))
  callback_list = _mongoid_run_child_before_callbacks(kind, 子项： 子项)
  return false if callback_list == false
  值 = 块&。调用
  callback_list.每 do |_next_sequence, env|
    env.值 &&= 值
  end
  return false if _mongoid_run_child_after_callbacks(callback_list: callback_list) == false

  值
end

# callback_executable? （种类）→ true | false

本文档是否可执行所提供的回调类型？

例子：

回调可执行吗？

document.callback_executable?(:save)

参数：

  • kind (符号) —

    回调的类型。

返回：

  • ( true | false ) —

    回调是否可以执行。



62
63
64
 
# File 'lib/mongoid/interceptable.rb', line 62

def callback_executable?(kind)
  respond_to?(" _ #{ Kind} _callbacks ")
end

# in_callback_state? （种类）→ true | false

文档当前是否处于可能需要执行回调的状态？

例子：

文档是否处于回调状态？

document.in_callback_state?(:update)

参数：

  • kind (符号) —

    回调类型。

返回：

  • ( true | false ) —

    如果文档处于回调状态。



75
76
77
 
# File 'lib/mongoid/interceptable.rb', line 75

def in_callback_state?(kind)
  [ :create, :destroy ].包括？(kind) || new_record? || flagged_for_destroy? || 改变？
end

#pending_callbacks ⇒ Array<Symbol>

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

返回存储的回调以供稍后执行。

返回：

  • ( Array<Symbol> ) —

    存储的待处理回调的方法符号。



262
263
264
 
# File 'lib/mongoid/interceptable.rb', line 262

def pending_callbacks
  @pending_callbacks ||= [].to_set
end

# pending_callbacks= (value) ⇒ Array<Symbol>

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

存储稍后执行的回调。 一个很好的使用案例是延迟 after_find 和 after_initialize 回调，直到在文档上设立关联。 这也可用于延迟对文档应用默认值。

参数：

  • 值 ( Array<Symbol> ) —

    要存储的待处理回调的方法符号。

返回：

  • ( Array<Symbol> ) —

    存储的待处理回调的方法符号。



276
277
278
 
# File 'lib/mongoid/interceptable.rb', line 276

def ped_callbacks=(值)
  @pending_callbacks = 值
end

# run_after_callbacks (*kinds) ⇒对象

注意：

ActiveSupport 默认不允许这种行为，因此 Mongoid 必须绕过它并自行实现。

仅为特定事件运行后续回调。

例子：

仅运行保存后回调。

model.run_after_callbacks(:save)

参数：

  • *kinds (符号... ) —

    正在发生的事件。

返回：

  • ( Object ) —

    链执行的结果。



90
91
92
93
94
 
# File 'lib/mongoid/interceptable.rb', line 90

def run_after_callbacks(*kinds)
  kinds.每 do |kind|
    run_targeted_callbacks(:after, kind)
  end
end

# run_before_callbacks (*kinds) ⇒对象

注意：

ActiveSupport 默认不允许这种行为，因此 Mongoid 必须绕过它并自行实现。

仅为特定事件运行 before 回调。

例子：

仅运行保存前回调。

model.run_before_callbacks(:save, :create)

参数：

  • *kinds (符号... ) —

    正在发生的事件。

返回：

  • ( Object ) —

    链执行的结果。



107
108
109
110
111
 
# File 'lib/mongoid/interceptable.rb', line 107

def run_before_callbacks(*kinds)
  kinds.每 do |kind|
    run_targeted_callbacks(:before, kind)
  end
end

# run_callbacks (Kind, with_children: true, skip_if: nil, &block) ⇒对象

为文档运行回调。 这会覆盖主动支持的功能，以将回调级联到已标记为此类的嵌入式文档。

例子：

运行回调。

run_callbacks :save do
  save!
end

参数：

  • kind (符号) —

    要执行的回调类型。

  • with_children ( true | false ) （默认为： true ） —

    标志指定是否应运行嵌入式文档的回调。

  • skip_if (Proc | nil) （默认为： nil ） —

    如果此过程返回 true，则不会触发回调，但仍会调用给定的区块。



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/mongoid/interceptable.rb', line 127

def run_callbacks(kind, with_children: true, skip_if: nil, 和块)
  if skip_if&。调用
    return 块&。调用
  end
  if with_children
    cascadable_children(kind).每 do |子项|
      if 子项.run_callbacks(child_callback_type(kind, 子项), with_children: with_children) == false
        return false
      end
    end
  end
  if callback_executable?(kind)
    超(kind, 和块)
  else
    true
  end
end

# run_pending_callbacks ⇒对象

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

运行待处理的回调。 如果回调为 :apply_defaults，我们将应用此文档的默认值。 否则，回调将传递给 run_callbacks 函数。



285
286
287
288
289
290
291
292
293
294
 
# File 'lib/mongoid/interceptable.rb', line 285

def run_pending_callbacks
  pending_callbacks.每 do |cb|
    if [:apply_defaults, :apply_post_processed_defaults].包括？(cb)
      发送(cb)
    else
      self.run_callbacks(cb, with_children: false)
    end
  end
  pending_callbacks.清除
end