Módulo: Mongoide::Interceptable

Ampliado por:
ActiveSupport::Concern
Incluido en:
Compuesto
Definido en:
lib/mongoid/interceptable.rb

Overview

Este módulo contiene todos los ganchos de función de retorno para Mongoid.

Colapso delresumen constante

DEVOLUCIONES DE LLAMADAS = 
[
  :after_build,
  :después_de_crear,
  :después de destruir,
  después_de_encontrar,
  :after_initialize,
  :after_save,
  :después del toque,
  :después de la actualización,
  :después de insertar,
  :después de la validación,
  alrededor_create,
  alrededor_destruir,
  alrededor_de_guardar,
  :alrededor_de_actualizar,
  :alrededor_insertar,
  Antes de crear,
  :antes_de_destruir,
  :antes_de_guardar,
  :before_update,
  Antes de actualizar,
  :antes_de_la_validación,
].freeze

Resumen del método de instancia colapsar

Detalles del método de instancia

#_mongoid_run_child_after_callbacks(callback_list: []) ⇒ Object

Ejecutar las devoluciones de llamadas posteriores.

Parámetros:

  • callback_list (arreglo<ActiveSupport::Callbacks::función de retornoSequence, ActiveSupport::Callbacks::filtros::Environment>) (predeterminado: []) —

    Lista de pares de secuencia de función de retorno y entorno.



250
251
252
253
254
255
 
# Archivo 'lib/mongoid/interceptable.rb', línea 250

def ejecutar(callback_list: [])
  callback_list.reverse_each hacer |next_sequence, env|
    next_sequence.invocar_después(env)
    return false si env.detenido
  end
end

#_mongoid_run_child_before_callbacks(tipo, hijos: [], lista_de_callbacks: []) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta las funciones de retorno previas de la clase dada para los documentos incrustados.

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno que se ejecutará.

  • hijo (Array<documento>) (predeterminado: []) —

    Niños en los que se ejecutarán devoluciones de llamadas.

  • callback_list (arreglo<ActiveSupport::Callbacks::función de retornoSequence, ActiveSupport::Callbacks::filtros::Environment>) (predeterminado: []) —

    Lista de pares de secuencia de función de retorno y entorno. Esta lista se utilizará posteriormente para ejecutar después las devoluciones de llamada en orden inverso.



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

def _mongoid_ejecutar_hijo_antes_de_las_devoluciones_de_llamadas(kind, hijos: [], callback_list: [])
  hijo.cada hacer |niño|
    blockchain = niño.función de retorno[child_callback_type(kind, niño)]
    env = ActiveSupport::función de retorno::Filtros::Entorno.Nuevo(niño, false, nulo)
    next_sequence = compile_callbacks(blockchain)
    a menos que next_sequence.¿final?
      Mongoid.logger.advertencia("Lasdevoluciones de llamadas están deshabilitadas para documentos incrustados. Se omiten las devoluciones de llamadas para #{child.class.name}. ")
      Mongoid.logger.advertencia("Para habilitar callbacks alrededor de los documentos incrustados, establece Mongoid::Config.around_callbacks_for_embeds en true.")
    end
    next_sequence.invocar_antes(env)
    return false si env.detenido
    env.Valor = !env.detenido
    callback_list << [next_sequence, env]
  end
  callback_list
end

#_mongoid_run_child_callbacks(tipo, hijos: nulo, &bloque) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta las funciones de devolución de llamada para los documentos incrustados.

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno que se ejecutará.

  • hijo (Array<documento>) (predeterminado: nulo) —

    Hijos para ejecutar devoluciones de llamada en. Si es nulo, las devoluciones de llamada se ejecutarán en todos los elementos secundarios anidados del documento.



153
154
155
156
157
158
159
160
161
162
163
 
# Archivo 'lib/mongoid/interceptable.rb', línea 153

def _mongoid_run_child_callbacks(kind, hijos: nulo, Ybloque)
  si Mongoid::Config.alrededor de devoluciones de llamadas para incrustaciones
    ejecutar(kind,
                                             hijos: hijo,
                                             Ybloque)
  else
    ejecutar(kind,
                                                hijos: hijo,
                                                Ybloque)
  end
end

#_mongoid_run_child_callbacks_with_around(kind, children: nil, &block) ⇒ objeto

Ejecute las devoluciones de llamada del tipo dado para los documentos incrustados, incluidas las devoluciones de llamada en torno.

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno que se ejecutará.

  • hijo (Array<documento>) (predeterminado: nulo) —

    Hijos para ejecutar devoluciones de llamada en. Si es nulo, las devoluciones de llamada se ejecutarán en todos los elementos secundarios anidados del documento.

    @api privado



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

def ejecutar(kind, hijos: nulo, Ybloque)
  hijo = (hijo || cascadable_children(kind))
  con_niños = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks

  return bloque&.llamar si hijo.¿vacío?

  fibras = hijo.map hacer |niño|
    Fiber.Nuevo hacer
      niño.run_callbacks(child_callback_type(kind, niño), with_children: con_niños) hacer
        Fiber.rendimiento
      end
    end
  end

  fibras.cada hacer |fibra|
    fibra.currículum
    propagar Mongoid::Errors::InvalidAroundCallback a menos que fibra.alive?
  end

  bloque&.llamar

  fibras.reversa.cada(Y:resume)
end

#_mongoid_run_child_callbacks_without_around(kind, children: nil, &block) ⇒ Object

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta las funciones de retorno del tipo dado para documentos incrustados sin funciones de retorno alrededor.

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno que se ejecutará.

  • hijo (Array<documento>) (predeterminado: nulo) —

    Hijos para ejecutar devoluciones de llamada en. Si es nulo, las devoluciones de llamada se ejecutarán en todos los elementos secundarios anidados del documento.



207
208
209
210
211
212
213
214
215
216
217
218
 
# Archivo 'lib/mongoid/interceptable.rb', línea 207

def ejecutar(kind, hijos: nulo, Ybloque)
  hijo = (hijo || cascadable_children(kind))
  callback_list = _mongoid_ejecutar_hijo_antes_de_las_devoluciones_de_llamadas(kind, hijos: hijo)
  return false si callback_list == false
  Valor = bloque&.llamar
  callback_list.cada hacer |siguiente, env|
    env.Valor &&= Valor
  end
  return false si ejecutar(callback_list: callback_list) == false

  Valor
end

#callback_executable?(tipo) ⇒ true (verdadero) | false (falso)

¿El tipo de función de retorno proporcionado puede ser ejecutado por este documento?

Ejemplos:

¿Se puede ejecutar la función de retorno?

document.callback_executable?(:save)

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno.

Devuelve:

  • (true | false) —

    Si se puede ejecutar la función de retorno.



62
63
64
 
# Archivo 'lib/mongoid/interceptable.rb', línea 62

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

#in_callback_state?(tipo) ⇒ true | false

¿Se encuentra actualmente el documento en un estado que podría requerir potencialmente la ejecución de devoluciones de llamada?

Ejemplos:

¿El documento está en estado de función de retorno?

document.in_callback_state?(:update)

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno.

Devuelve:

  • (true | false) —

    Si el documento está en estado de función de retorno.



75
76
77
 
# Archivo 'lib/mongoid/interceptable.rb', línea 75

def ¿en_estado_de_devolución_de_llamada?(kind)
  [ crear:, :destroy ].incluir?(kind) || nuevo_registro? || flagged_for_destroy? || ¿cambió?
end

#pending_callbacks ⇒ Array<Symbol>

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve los callbacks almacenados para ser ejecutados posteriormente.

Devuelve:

  • (Matriz<Símbolo><Symbol>) —

    Símbolos de método de los callbacks pendientes almacenados.



262
263
264
 
# Archivo 'lib/mongoid/interceptable.rb', línea 262

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

#pending_callbacks=(valor) ⇒ Array<Symbol>

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Almacena callbacks para ejecutar posteriormente. Un buen caso de uso para esto es retrasar las callbacks after_find y after_initialize hasta que las asociaciones estén establecidas en el documento. Esto también se puede utilizar para retrasar la aplicación de lo por defecto en un documento.

Parámetros:

  • Valor (Matriz<Símbolo><Symbol>) —

    Símbolos de método de los callbacks pendientes por almacenar.

Devuelve:

  • (Matriz<Símbolo><Symbol>) —

    Símbolos de método de los callbacks pendientes almacenados.



276
277
278
 
# Archivo 'lib/mongoid/interceptable.rb', línea 276

def pending_callbacks=(Valor)
  @devoluciones_de_llamadas_pendientes = Valor
end

#run_after_callbacks(*tipos) ⇒ objeto

Nota:

ActiveSupport no permite este tipo de comportamiento por defecto, por lo que Mongoid debe sortearlo e implementarse a sí mismo.

Ejecutar solo los callbacks posteriores para el evento específico.

Ejemplos:

Ejecuta solo los callbacks después de guardar.

model.run_after_callbacks(:save)

Parámetros:

  • *kinds (Symbol...) —

    Los eventos que están ocurriendo.

Devuelve:

  • (objeto) —

    El resultado de la ejecución de la cadena.



90
91
92
93
94
 
# Archivo 'lib/mongoid/interceptable.rb', línea 90

def run_after_callbacks(*kinds)
  kinds.cada hacer |kind|
    run_targeted_callbacks(después de, kind)
  end
end

#ejecutar_antes_de_devoluciones_de_llamadas(*tipos) ⇒ Objeto

Nota:

ActiveSupport no permite este tipo de comportamiento por defecto, por lo que Mongoid debe sortearlo e implementarse a sí mismo.

Ejecuta solo las devoluciones de llamada previas para el evento en cuestión.

Ejemplos:

Ejecuta sólo las callbacks antes de guardar.

model.run_before_callbacks(:save, :create)

Parámetros:

  • *kinds (Symbol...) —

    Los eventos que están ocurriendo.

Devuelve:

  • (objeto) —

    El resultado de la ejecución de la cadena.



107
108
109
110
111
 
# Archivo 'lib/mongoid/interceptable.rb', línea 107

def run_before_callbacks(*kinds)
  kinds.cada hacer |kind|
    run_targeted_callbacks(:antes, kind)
  end
end

#run_callbacks(kind, with_children: true, skip_if: nil, &block) ⇒ Objeto

Ejecuta las funciones de retorno para el documento. Esta acción reemplaza la funcionalidad de Active para propagar funciones de retorno hacia documentos incrustados que hayan sido marcados de esa forma.

Ejemplos:

Ejecutar las devoluciones de llamada.

run_callbacks :save do
  save!
end

Parámetros:

  • kind (Símbolo) —

    El tipo de función de retorno que se ejecutará.

  • con_niños (true | false) (predeterminado: verdadero)

    El indicador especifica si se deben ejecutar las devoluciones de llamada del documento incrustado.

  • skip_if (Proc | nil) (predeterminado: nulo) —

    Si este procedimiento devuelve verdadero, las devoluciones de llamada no se activarán, mientras que el bloque dado aún se llamará.



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

def run_callbacks(kind, with_children: true, skip_if: nulo, Ybloque)
  si skip_if&.llamar
    return bloque&.llamar
  end
  si con_niños
    cascadable_children(kind).cada hacer |niño|
      si niño.run_callbacks(child_callback_type(kind, niño), with_children: con_niños) == false
        return false
      end
    end
  end
  si callback_executable?(kind)
    super(kind, Ybloque)
  else
    true
  end
end

#run_pending_callbacks ⇒ objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecuta las funciones de retorno pendientes. Si la función de retorno es :apply_defaults, aplicaremos los valores por defecto para este documento. De lo contrario, la función de retorno se pasa a la función run_callbacks.



285
286
287
288
289
290
291
292
293
294
 
# Archivo 'lib/mongoid/interceptable.rb', línea 285

def ejecutar_llamadas_pendientes
  pending_callbacks.cada hacer |cb|
    si [:aplicar_valores_predeterminados, :apply_post_processed_defaults].incluir?(cb)
      enviar(cb)
    else
      sí mismo.run_callbacks(cb, with_children: false)
    end
  end
  pending_callbacks.borrar
end