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 = 
%i[
  after_build
  after_create
  after_destroy
  after_find
  after_initialize
  after_save
  after_toque
  after_update
  after_upsert
  after_validation
  near_create
  near_destroy
  near_save
  near_update
  near_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.



247
248
249
250
251
252
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 247

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.



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

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.



148
149
150
151
152
153
154
155
156
157
158
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 148

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



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

def _mongoid_run_child_callbacks_with_round(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  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.



202
203
204
205
206
207
208
209
210
211
212
213
214
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 202

def _mongoid_run_child_callbacks_without_round(kind, filhos: nada, &noum: bloco ; verb: bloquear)
  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.



60
61
62
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 60

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.



73
74
75
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 73

def in_callback_state?(kind)
  %i[criar destruir].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.



259
260
261
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 259

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.



273
274
275
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 273

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.



88
89
90
91
92
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 88

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.



105
106
107
108
109
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 105

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 do document. 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.



125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 125

def run_callbacks(kind, with_children: true, skip_if: nada, &noum: bloco ; verb: bloquear)
  Método noum: bloco ; verb: bloquear&.Chame se skip_if&.Chame

  se with_children
    cascadable_children(kind).cada fazer |criança|
      Método false se criança.run_callbacks(child_callback_type(kind, criança), with_children: with_children) == false
    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.



282
283
284
285
286
287
288
289
290
291
 
# Arquivo 'lib/mongoid/interceptable.rb', linha 282

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