Módulo: Mongoid::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.

Resumen de constantes colapsar

función de retorno = 
%i[
  después de la construcción
  after_create
  después_de_destruir
  after_find
  after_initialize
  después_guardar
  postpulsación
  después_de_la_actualización
  after_upsert
  después de la validación
  alrededor_crear
  omega_delete
  alrededor_del_ahorro
  around_update
  creando o actualizando
  before_create
  before_destroy
  antes_de_guardar
  before_update
  before_upsert
  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

Ejecuta las devoluciones de llamada posteriores.

Parámetros:

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

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



247
248
249
250
251
252
 
# Archivo 'lib/mongoid/interceptable.rb', línea 247

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 es parte de una API privada. Se debe evitar el uso de este método 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>) (valor por defecto: []) —

    Niños que ejecuten función de retorno.

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

    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.



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# Archivo 'lib/mongoid/interceptable.rb', línea 225

def ejecutar(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::filtro::Entorno.Nuevo(niño, false, nulo)
    next_sequence = compile_callbacks(blockchain)
    a menos que next_sequence.¿final?
      Mongoid.logger.advertencia("Las funciones de retorno alrededor están deshabilitadas para documentos embebidos. Saltando funciones de retorno alrededor para #{child.clase.name}.")
      Mongoid.logger.advertencia('Para habilitar funciones de retorno alrededor de documentos incrustados, configura 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, hijo: nil, &block) ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método 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>) (valor por defecto: nil) —

    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.



148
149
150
151
152
153
154
155
156
157
158
 
# Archivo 'lib/mongoid/interceptable.rb', línea 148

def _mongoid_run_child_callbacks(kind, hijos: nulo, &bloque)
  si Mongoid::Config.around_callbacks_for_embeds
    ejecutar(kind,
                                             hijos: hijo,
                                             &bloque)
  else
    ejecutar(kind,
                                                hijos: hijo,
                                                &bloque)
  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>) (valor por defecto: nil) —

    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



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# Archivo 'lib/mongoid/interceptable.rb', línea 169

def ejecutar(kind, hijos: nulo, &bloque)
  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(&:resume)
end

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

Este método es parte de una API privada. Se debe evitar el uso de este método 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>) (valor por defecto: nil) —

    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.



202
203
204
205
206
207
208
209
210
211
212
213
214
 
# Archivo 'lib/mongoid/interceptable.rb', línea 202

def ejecutar(kind, hijos: nulo, &bloque)
  hijo ||= cascadable_children(kind)
  callback_list = ejecutar(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.



60
61
62
 
# Archivo 'lib/mongoid/interceptable.rb', línea 60

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.



73
74
75
 
# Archivo 'lib/mongoid/interceptable.rb', línea 73

def ¿in_callback_state?(kind)
  %i[Cree destruir].incluir?(kind) || nuevo_registro? || flagged_for_destroy? || ¿Cambiado?
end

#pending_callbacks ⇒ Array<Symbol>

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve los callbacks almacenados para ser ejecutados posteriormente.

Devuelve:

  • (arreglo<Symbol>) —

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



259
260
261
 
# Archivo 'lib/mongoid/interceptable.rb', línea 259

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

#pending_callbacks=(valor) ⇒ Array<Symbol>

Este método es parte de una API privada. Se debe evitar el uso de este método 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 (arreglo<Symbol>) —

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

Devuelve:

  • (arreglo<Symbol>) —

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



273
274
275
 
# Archivo 'lib/mongoid/interceptable.rb', línea 273

def pending_callbacks=(Valor)
  @pending_callbacks = 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.



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

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

#run_before_callbacks(*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.



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

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 document. Esto anula la funcionalidad de active support para realizar callbacks en cascada en los documentos incrustados que hayan sido marcados como tales.

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) (por defecto: true) —

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

  • skip_if (Proc | nil) (valor por defecto: nil) —

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



125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# Archivo 'lib/mongoid/interceptable.rb', línea 125

def run_callbacks(kind, with_children: true, skip_if: nulo, &bloque)
  return bloque&.llamar si skip_if&.llamar

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

#run_pending_callbacks ⇒ objeto

Este método es parte de una API privada. Se debe evitar el uso de este método 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.



282
283
284
285
286
287
288
289
290
291
 
# Archivo 'lib/mongoid/interceptable.rb', línea 282

def ejecutar_llamadas_pendientes
  pending_callbacks.cada hacer |cb|
    si %i[aplicar_predeterminados apply_post_processed_defaults].incluir?(cb)
      enviar(cb)
    else
      run_callbacks(cb, with_children: false)
    end
  end
  pending_callbacks.borrar
end