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.



244
245
246
247
248
249
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 244

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.



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 220

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]
    se (netos = criança.enviar(:cascadable_children, kind))
      _mongoid_run_child_before_callbacks(kind, filhos: netos, chamada de resposta_lista: chamada de resposta_lista)
    end
  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
 
# 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

Observação:

Esse método está sujeito a erros de Stack Overflow se o documento tiver um grande número de documentos incorporados. É recomendável evitar o uso de chamadas de resposta para documentos incorporados até que uma solução adequada seja implementada.

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



175
176
177
178
179
180
181
182
183
184
185
186
187
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 175

def _mongoid_run_child_callbacks_with_round(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  criança, *cauda = (crianças || cascadable_children(kind))
  with_children = !Mongoid::Config.write_multiple_calls_of_embedded_callbacks
  se criança.nada?
    noum: bloco ; verb: bloquear&.Chame
  elsif cauda.vazio?
    criança.run_callbacks(child_callback_type(kind, criança), with_children: with_children, &noum: bloco ; verb: bloquear)
  mais
    criança.run_callbacks(child_callback_type(kind, criança), with_children: with_children) fazer
      _mongoid_run_child_callbacks_with_round(kind, filhos: cauda, &noum: bloco ; verb: bloquear)
    end
  end
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.



198
199
200
201
202
203
204
205
206
207
208
209
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 198

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.



256
257
258
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 256

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.



270
271
272
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 270

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.



279
280
281
282
283
284
285
286
287
288
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 279

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