Módulo: Mongoid::Interceptable

Estendido por:
ActiveSupport::Concern
Incluído em:
Componível
Definido em:
lib/mongoid/interceptable.rb

Visão geral

Este módulo contém todos os ganchos de chamada de resposta de chamada para Mongoid.

Colapsode resumo constante

REQUESTIS = 
[
  :after_build,
  :after_create,
  :after_destroy,
  :after_find,
  :after_initialize,
  :after_save,
  :after_toque,
  :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,
].congelar

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#_mongoid_run_child_after_callbacks(callback_list: []) ⇒ Object

Execute as chamadas de resposta posteriores.

Parâmetros:

  • chamada de resposta_lista (Array <ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment>) (padrão para: []) —

    Lista de pares de sequência de chamada de resposta de resposta e ambiente.



250
251
252
253
254
255
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 250

def _mongoid_run_child_after_callbacks(chamada de resposta_lista: [])
  chamada de resposta_lista.Reverse_each fazer |Next_sequence, env|
    Next_sequence.invoke_after(env)
    Método false se env.interrompido
  end
end

#_mongoid_run_child_before_callbacks(tipo, crianças: [], callback_list: []) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Execute as chamadas de resposta anteriores de determinado tipo para documentos incorporados.

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta a ser executada.

  • crianças (Array <Documento>) (padrão para: []) —

    Filhos para executar retornos de chamada.

  • chamada de resposta_lista (Array <ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment>) (padrão para: []) —

    Lista de pares de sequência de chamada de resposta de resposta e ambiente. Esta lista será posteriormente usada para executar after callbacks em ordem inversa.



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

def _mongoid_run_child_before_callbacks(kind, filhos: [], chamada de resposta_lista: [])
  crianças.cada fazer |criança|
    chain = criança.__callbacks[child_callback_type(kind, criança)]
    env = ActiveSupport::Chamadas de resposta::Filtros::ambiente.Novo(criança, false, nada)
    Next_sequence = compile_callbacks(chain)
    a menos que Next_sequence.final?
      Mongoid.logger.AVISAR("As chamadas de resposta estão desativadas para documentos incorporados. Ignorando chamadas de resposta para #{filho.classe.nome}.")
      Mongoid.logger.AVISAR("Para ativar as chamadas de resposta para documentos incorporados, defina Mongoid::Config.round_callbacks_for_embeds como true.")
    end
    Next_sequence.invoke_before(env)
    Método false se env.interrompido
    env.valor = !env.interrompido
    chamada de resposta_lista << [Next_sequence, env]
  end
  chamada de resposta_lista
end

#_mongoid_run_child_callbacks(tipo, filhos: nil, &block) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Execute as chamadas de resposta para documentos incorporados.

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta a ser executada.

  • crianças (Array <Documento>) (padrão para: nil) —

    Filhos para executar retornos de chamada. Se nulo, os retornos de chamada serão executados em todos os filhos em cascata do documento.



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

def _mongoid_run_child_callbacks(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  se Mongoid::Config.near_callbacks_for_embeds
    _mongoid_run_child_callbacks_with_round(kind,
                                             filhos: crianças,
                                             &noum: bloco ; verb: bloquear)
  mais
    _mongoid_run_child_callbacks_without_round(kind,
                                                filhos: crianças,
                                                &noum: bloco ; verb: bloquear)
  end
end

#_mongoid_run_child_callbacks_with_round(tipo, filhos: nil, &block) ➤ Objeto

Execute as chamadas de resposta de determinado tipo para documentos incorporados, inclusive em torno de chamadas de resposta.

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta a ser executada.

  • crianças (Array <Documento>) (padrão para: nil) —

    Filhos para executar retornos de chamada. Se nulo, os retornos de chamada serão executados em todos os filhos em cascata do documento.

    @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
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 174

def _mongoid_run_child_callbacks_with_round(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  crianças = (crianças || cascadable_children(kind))
  with_children = !Mongoid::Config.write_multiple_calls_of_embedded_callbacks

  Método noum: bloco ; verb: bloquear&.Chame se crianças.vazio?

  Fibras = crianças.map fazer |criança|
    Fibra.Novo fazer
      criança.run_callbacks(child_callback_type(kind, criança), with_children: with_children) fazer
        Fibra.rendimento
      end
    end
  end

  Fibras.cada fazer |Fibra|
    Fibra.retomar
    aumentar Mongoid::Errors::InvalidAroundCallback a menos que Fibra.alive?
  end

  noum: bloco ; verb: bloquear&.Chame

  Fibras.reverter.cada(&:resume)
end

#_mongoid_run_child_callbacks_without_round(tipo, filhos: nil, &block) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Execute as chamadas de resposta de determinado tipo para documentos incorporados sem chamadas de resposta.

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta a ser executada.

  • crianças (Array <Documento>) (padrão para: nil) —

    Filhos para executar retornos de chamada. Se nulo, os retornos de chamada serão executados em todos os filhos em cascata do documento.



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

def _mongoid_run_child_callbacks_without_round(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  crianças = (crianças || cascadable_children(kind))
  chamada de resposta_lista = _mongoid_run_child_before_callbacks(kind, filhos: crianças)
  Método false se chamada de resposta_lista == false
  valor = noum: bloco ; verb: bloquear&.Chame
  chamada de resposta_lista.cada fazer |_next_sequence, env|
    env.valor &&= valor
  end
  Método false se _mongoid_run_child_after_callbacks(chamada de resposta_lista: chamada de resposta_lista) == false

  valor
end

#callback_executable?(espacial) ➤ verdadeiro | false

O tipo fornecido de chamada de resposta de resposta é executável por este documento?

Exemplos:

O chamada de resposta de chamada é executável?

document.callback_executable?(:save)

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta.

Retorna:

  • (verdadeiro | falso) —

    Se a chamada de resposta puder ser executada.



62
63
64
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 62

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

#in_callback_state?(espacial) ➤ verdadeiro | false

O documento está atualmente em um estado que pode exigir a execução de callbacks?

Exemplos:

O documento está em um estado de chamada de resposta de resposta?

document.in_callback_state?(:update)

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta.

Retorna:

  • (verdadeiro | falso) —

    Se o documento estiver em um estado de chamada de resposta de resposta.



75
76
77
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 75

def in_callback_state?(kind)
  [ :create, :destroy ].incluir?(kind) || new_record? || sinalizado_for_destroy? || mudou?
end

#pending_callbacks ➤ Array<Symbol>

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna as chamada de resposta armazenadas para serem executadas posteriormente.

Retorna:

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

    Símbolos de método das chamadas de resposta pendentes armazenadas.



262
263
264
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 262

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

#pending_callbacks=(value) ➤ Array<Symbol>

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Armazena chamadas de resposta para serem executadas posteriormente. Um bom caso de uso para isso é atrasar os retornos de chamada after_find e after_initialize até que as associações sejam definidas no documento. Isso também pode ser usado para atrasar a aplicação dos padrões em um documento.

Parâmetros:

  • valor (Array<Símbolo><Symbol>) —

    Símbolos de método das chamadas de resposta pendentes para armazenar.

Retorna:

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

    Símbolos de método das chamadas de resposta pendentes armazenadas.



276
277
278
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 276

def pending_callbacks=(valor)
  @pending_callbacks = valor
end

#run_after_callbacks(*tipos) ➤ Objeto

Observação:

O ActiveSupport não permite esse tipo de comportamento por padrão, então o Mongoid precisa contorná-lo e se implementar.

Execute somente as chamadas de resposta posteriores para o evento específico .

Exemplos:

Execute apenas as chamadas de resposta após salvar.

model.run_after_callbacks(:save)

Parâmetros:

  • *kinds (Símbolo...) —

    Os eventos que estão ocorrendo.

Retorna:

  • (Objeto) —

    O resultado da execução da cadeia.



90
91
92
93
94
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 90

def run_after_callbacks(*kinds)
  kinds.cada fazer |kind|
    run_targeted_callbacks(:after, kind)
  end
end

#run_before_callbacks(*tipos) ➤ Objeto

Observação:

O ActiveSupport não permite esse tipo de comportamento por padrão, então o Mongoid precisa contorná-lo e se implementar.

Execute somente as chamadas anteriores para o evento específico .

Exemplos:

Execute apenas as chamadas de resposta antes de salvar.

model.run_before_callbacks(:save, :create)

Parâmetros:

  • *kinds (Símbolo...) —

    Os eventos que estão ocorrendo.

Retorna:

  • (Objeto) —

    O resultado da execução da cadeia.



107
108
109
110
111
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 107

def run_before_callbacks(*kinds)
  kinds.cada fazer |kind|
    run_targeted_callbacks(:before, kind)
  end
end

#run_callbacks(tipo, with_children: true, skip_if: nil, &block) ➤ Objeto

Execute as chamadas de resposta para o documento. Isso substitui a funcionalidade do suporte ativo de chamar de resposta em cascata para documentos incorporados que foram sinalizados como tal.

Exemplos:

Execute os retornos de chamada.

run_callbacks :save do
  save!
end

Parâmetros:

  • kind (Símbolo) —

    O tipo de chamada de resposta de resposta a ser executada.

  • with_children (verdadeiro | falso) (padrão para: true) —

    O sinalizador especifica se as chamadas de resposta do documento incorporado devem ser executadas.

  • skip_if (Proc | nil) (padrão para: nil) —

    Se esse proc retornar verdadeiro, as chamadas de resposta não serão acionadas, enquanto o bloco fornecido ainda será chamado.



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

def run_callbacks(kind, with_children: true, skip_if: nada, &noum: bloco ; verb: bloquear)
  se skip_if&.Chame
    Método noum: bloco ; verb: bloquear&.Chame
  end
  se with_children
    cascadable_children(kind).cada fazer |criança|
      se criança.run_callbacks(child_callback_type(kind, criança), with_children: with_children) == false
        Método false
      end
    end
  end
  se callback_executable?(kind)
    super(kind, &noum: bloco ; verb: bloquear)
  mais
    true
  end
end

#run_pending_callbacks ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Execute as chamadas de resposta pendentes. Se a chamada de resposta de resposta for :apply_defaults, aplicaremos os padrões para este documento. Caso contrário, a chamada de resposta de resposta é passada para a função run_callbacks.



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

def run_pending_callbacks
  pending_callbacks.cada fazer |cb|
    se [:apply_defaults, :apply_post_processed_defaults].incluir?(cb)
      enviar(cb)
    mais
      auto.run_callbacks(cb, with_children: false)
    end
  end
  pending_callbacks.Limpar
end