Classe: Mongoid::Association::Referenced::HasMany::Proxy

Herda:
Muitos
  • Objeto
mostrar tudo
Estendido por:
Encaminhável, ClassMethods
Definido em:
lib/mongoid/association/referenced/has_many/proxy.rb

Visão geral

Proxy transparente para associações has_many. Uma instância dessa classe é retornada ao chamar o método de getter de associação no documento do assunto. Esta classe herda de Mongoid::Association::Proxy e encaminha a maioria de seus métodos para o destino da associação, ou seja, a array de documentos na collection do lado oposto que deve ser carregada.

Definido sob namespace

Módulos: Métodos de classe

Resumo constante

Constantes herdadas do Proxy

Proxy::KEEPER_METHODS

Resumo do atributo de instância

Atributos herdados do proxy

#_association, #_base, #_target

Recolhimento do Resumo do método de instância

Métodos incluídos do ClassMethods

missing_loader, incorporado?

Métodos herdados de Muitos

#em branco?, #create, #create!, #find_or_create_by, #find_or_create_by!, #find_or_initialize_by, #nil?, #respond_to?, #scoped, #serializable_hash

Métodos herdados do Proxy

apply_ordering, #extend_proxies, #klass, #reset_unloaded, #substitutable

Métodos incluídos noMarshable

.

Detalhes do construtor

#inicializar(base, destino, associação) ➤ Proxy

Crie uma instância de uma nova associação reference_many. Definirá a chave estrangeira e a base no objeto inverso.

Exemplos:

Crie a nova associação.

Referenced::Many.new(base, target, association)

Parâmetros:



51
52
53
54
55
56
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 51

def inicializar(base, Alvo, associação)
  enum = Tem muitos::Enumerável.Novo(Alvo, base, associação)
  super(base, enum, associação) fazer
    create_mixed se classe.incorporado? && !classe.cíclica?
  end
end

Manipulação de métodos dinâmicos

Esta classe lida com métodos dinâmicos através do método method_missing

#method_missing ➤ Critérios | Objeto (privado)

Se a array de destino não responder ao método fornecido, tente encontrar um escopo nomeado ou critérios na classe e envie a chamada para lá.

Se o método existir na array, use o comportamento de proxy padrão.

TODO: verificar se estamos usando consistentemente respond_to_missing

anywhere we define method_missing.

rubocop:disable Estilo/MissingRespondToMissing

Parâmetros:

  • name (Símbolo | string) —

    O nome do método.

  • *args (Objeto...) —

    O método argumenta

  • &block —

    Bloco opcional a ser aprovado.

Retorna:

  • (Critérios | Objeto) —

    Um critério ou valor de retorno do destino.



468
469
470
471
472
473
474
475
476
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 468

ruby2_keywords def method_missing(name, *Args, &noum: bloco ; verb: bloquear)
  se _target.respond_to?(name)
    _target.enviar(name, *Args, &noum: bloco ; verb: bloquear)
  mais
    classe.enviar(:with_scope, critério) fazer
      critério.public_send(name, *Args, &noum: bloco ; verb: bloquear)
    end
  end
end

Detalhes do método de instância

#<<(*args) ➤ Array<Document> Também conhecido como: push

Anexa um documento ou array de documentos à associação. Definirá o principal e atualizará o índice no processo.

Exemplos:

Anexar um documento.

person.posts << post

Empurre um documento.

person.posts.push(post)

Concat com outros documentos.

person.posts.concat([ post_one, post_two ])

Parâmetros:

  • *args (Documento...) —

    Qualquer número de documentos.

Retorna:

  • (Array <Document>) —

    Os Docs carregados .



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 73

def <<(*Args)
  Docs = Args.achatar
  Método concat(Docs) se Docs.Tamanho > 1

  se (doc = Docs.primeiro)
    acrescentar(doc)
    doc.Salvar se persistente? && !_assigning? && !doc.validado?
  end
  auto
end

#build(attributes = {}, type = nil) ⇒ Document Também conhecido como: novo

Crie um novo documento a partir dos atributos e anexe-o a esta associação sem salvar.

Exemplos:

Criar um novo documento sobre a associação.

person.posts.build(:title => "A new post")

Parâmetros:

  • attributes (Hash) (padrão para: {}) —

    Os atributos do novo documento.

  • type (Classe) (padrão para: nil) —

    A subclasse opcional a ser construída.

Retorna:



118
119
120
121
122
123
124
125
126
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 118

def COMPILAR(attributes = {}, type = nada)
  Factory.execute_build(type || classe, attributes, execute_callbacks: false).toque fazer |doc|
    acrescentar(doc)
    doc.apply_post_processed_defaults
    rendimento doc se block_given?
    doc.run_pending_callbacks
    doc.run_callbacks(:build) { doc }
  end
end

#concat(documents) ➤ Array<Document>

Anexa uma array de documentos à associação. Executa uma inserção em lote dos documentos em vez de persistir um de cada vez.

Exemplos:

Concat com outros documentos.

person.posts.concat([ post_one, post_two ])

Parâmetros:

  • documentos (Array <Document>) —

    Os Docs a serem adicionados.

Retorna:



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 95

def concat(documentos)
  Docs, Inserções = [], []
  documentos.cada fazer |doc|
    próximo a menos que doc

    acrescentar(doc)
    save_or_delay(doc, Docs, Inserções) se persistente?
  end

  persist_delayed(Docs, Inserções)
  auto
end

#delete(document) ➤ Documento também conhecido como: delete_one

Exclua o documento da associação. Isso definirá a chave estrangeira no documento como nula. Se as opções dependentes na associação forem :delete_all ou :destroy, a remoção apropriada ocorrerá.

Exemplos:

Exclua o documento.

person.posts.delete(post)

Parâmetros:

  • documento (Documento) —

    O documento a ser removido.

Retorna:

  • (Documento) —

    O documento correspondente.



140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 140

def excluir(documento)
  execute_callbacks_round(:remove, documento) fazer
    Resultado = _target.excluir(documento) fazer |doc|
      se doc
        unbind_one(doc)
        cascata!(doc) a menos que _assigning?
      end
    end

    Resultado.toque { reinício_unloaded }
  end
end

#delete_all(condição = nil) ➤ Inteiro

Exclui todos os documentos relacionados do banco de dados, dadas as condições fornecidas.

Exemplos:

Exclua todos os documentos na associação.

person.posts.delete_all

Exclua condicionalmente todos os documentos da associação.

person.posts.delete_all({ :title => "Testing" })

Parâmetros:

  • condições (Hash) (padrão para: nil) —

    Condições opcionais para excluir.

Retorna:

  • (Inteiro) —

    O número de documentos excluídos.



169
170
171
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 169

def delete_all(condições = nada)
  remove_all(condições, :delete_all)
end

#Destruir_all(condição = nil) ➤ Inteiro

Destrói todos os documentos relacionados do banco de dados, dadas as condições fornecidas.

Exemplos:

Destrua todos os documentos da associação.

person.posts.destroy_all

Destruir condicionalmente todos os documentos da associação.

person.posts.destroy_all({ :title => "Testing" })

Parâmetros:

  • condições (Hash) (padrão para: nil) —

    Condições opcionais para destruir.

Retorna:

  • (Inteiro) —

    O número de documentos destruídos.



185
186
187
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 185

def Destruir_all(condições = nada)
  remove_all(condições, :destroy_all)
end

#cada(&bloco) ➤ Array<Documento>

Observação:

Isso carregará toda a associação na memória.

Iterar sobre cada documento na associação e produzir para o bloco fornecido.

Exemplos:

Iterar sobre os documentos.

person.posts.each do |post|
  post.save
end

Retorna:

  • (Array <Document>) —

    Os Docs carregados .



200
201
202
203
204
205
206
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 200

def cada(&noum: bloco ; verb: bloquear)
  se noum: bloco ; verb: bloquear
    _target.cada(&noum: bloco ; verb: bloquear)
  mais
    to_enum
  end
end

#existe?(id_or_ conditions = :none) ➤ true | false

Determine se algum documento nesta associação existe no banco de dados.

Se a associação contiver documentos, mas todos os documentos existirem apenas no aplicativo, ou seja, não tiverem sido persistentes no banco de dados, esse método retornará falso.

Este método consulta o banco de dados de dados em cada invocação, mesmo que a associação já esteja carregada na memória.

Exemplos:

Existem documentos persistentes?

person.posts.exists?

Parâmetros:

  • id_or_ conditions (:none | nil | false | Hash | Objeto) (padrão para: :none) —

    Quando :none (o padrão), retorna verdadeiro se houver algum documento persistente na associação. Quando nulo ou falso, isso sempre retornará falso. Quando um Hash é fornecido, ele consulta os documentos da associação em busca daqueles que correspondem às condições fornecidas e retorna verdadeiro se houver correspondência. Qualquer outro argumento é interpretado como um ID, e é feita a query da existência de documentos na associação com um _id correspondente .

Retorna:

  • (verdadeiro | falso) —

    Verdadeiro se documentos persistentes existem, falso se não.



230
231
232
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 230

def existe?(id_or_ conditions = : none)
  critério.existe?(id_or_ conditions)
end

#find(*args) {|Object| ... } ⇒ Document | Array<Document> | nil

Observação:

Cada argumento pode ser um ID individual, uma array de ids ou uma array agrupada. Cada array será achatada.

Observação:

Isso manterá os documentos correspondentes na memória para iteração posterior.

Encontre o documento correspondente na associação, com base no ID ou nas condições.

Este método delega para Mongoid::Criteria#find. Se este método não receber um bloqueio, ele retornará um ou vários documentos para os valores de _id fornecidos.

Se esse método receber um bloco, ele retornará o primeiro documento daqueles encontrados pelo objeto Criteria atual para o qual o bloco retornará um valor verdadeiro.

Exemplos:

Encontrar por um ID.

person.posts.find(BSON::ObjectId.new)

Encontrar por vários IDs.

person.posts.find([ BSON::ObjectId.new, BSON::ObjectId.new ])

Encontra o primeiro documento correspondente usando um bloco.

person.addresses.find { |addr| addr.state == 'CA' }

Parâmetros:

  • *args ([ Object | Array<Object> ]...) —

    Os ids.

  • &block —

    Bloco opcional a ser aprovado.

Rendimento:

  • (Objeto) —

    Fornece cada elemento enumerável para o bloco.

Retorna:



265
266
267
268
269
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 265

def find(*Args, &noum: bloco ; verb: bloquear)
  correspondência = critério.find(*Args, &noum: bloco ; verb: bloquear)
  Array(correspondência).cada { |doc| _target.push(doc) }
  correspondência
end

#nullify ➤ Objeto também conhecido como: nullify_all

Remove todas as associações entre o documento base e os documentos de destino, excluindo as chaves estrangeiras e as referências, deixando os documentos de destino órfãos no processo.

Exemplos:

Anular a associação.

person.posts.nullify


277
278
279
280
281
282
283
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 277

def anular
  critério.update_all(foreign_key => nada)
  _target.Limpar fazer |doc|
    unbind_one(doc)
    doc.change_attributes.excluir(foreign_key)
  end
end

#expurgo ⇒ Muitos Também conhecido como: limpar

Limpe a associação. Excluirá os documentos do banco de dados se eles já forem persistentes.

Exemplos:

Limpe a associação.

person.posts.clear

Retorna:

  • (Muitos) —

    A associação esvaziou-se.



294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 294

def limpar
  Método anular a menos que _association.destrutivo?

  after_remove_error = nada
  critério.delete_all
  muitos = _target.Limpar fazer |doc|
    execute_callback :before_remove, doc
    unbind_one(doc)
    doc.destruído = true
    começar
      execute_callback :after_remove, doc
    salvar StandardError => e
      after_remove_error = e
    end
  end

  aumentar after_remove_error se after_remove_error

  muitos
end

#substituto(substituição) ➤ Muitos

Substitui os documentos de destino fornecidos pelos documentos existentes na associação. Se o novo destino for nulo, execute a exclusão necessária.

Exemplos:

Substitua a associação.

person.posts.substitute([ new_post ])

Parâmetros:

  • substituição (Array <Document>) —

    O alvo de substituição.

Retorna:

  • (Muitos) —

    A associação.



327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 327

def substituir(substituição)
  se substituição
    new_docs, Docs = substituição.compactar, []
    new_ids = new_docs.map(&:_id)
    remove_not_in(new_ids)
    new_docs.cada fazer |doc|
      Docs.push(doc) se doc.enviar(foreign_key) != _base.enviar(_association.primary_key)
    end
    concat(Docs)
  mais
    limpar
  end
  auto
end

#sem escopo ➤ Critérios

Obtenha um critério para os documentos sem o escopo padrão aplicado.

Exemplos:

Obtenha os critérios sem escopo.

person.posts.unscoped

Retorna:



349
350
351
 
# File 'lib/mongoid/association/referenced/has_many/proxy.rb', linha 349

def sem escopo
  classe.sem escopo.ONDE(foreign_key => _base.enviar(_association.primary_key))
end