Classe: Mongoid::Association::Embedded::EmbedsMany::Proxy

Herda:
Muitos
  • Objeto
mostrar tudo
Estendido por:
Métodos de classe
Inclui:
Lotable
Definido em:
lib/mongoid/association/embedded/embeds_many/proxy.rb

Visão geral

Proxy transparente para associações embeds_many. Uma instância dessa classe é retornada ao chamar o método de getter de associação no documento pai. 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 filhos.

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?, foreign_key_suffix

Métodos incluídos no Lote

#batch_clear, #batch_insert, #batch_remove, #batch_replace

Métodos incluídos no Posicional

#positionalmente

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) ➤ Muitos

Crie uma instância de uma nova associação embeds_many.

Exemplos:

Crie a nova associação.

Many.new(person, addresses, association)

Parâmetros:



67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 67

def inicializar(base, Alvo, associação)
  super fazer
    _target.cada_com_index fazer |doc, index|
      integrar(doc)
      doc._index = index
    end
    update_attributes_hash
    @_unscoped = _target.dup
    @_target = escopo(_target)
  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 args.

  • &block —

    Bloco opcional a ser aprovado.

Retorna:

  • (Critérios | Objeto) —

    Um critério ou valor de retorno do destino.



490
491
492
493
494
495
496
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 490

ruby2_keywords def method_missing(name, *Args, &noum: bloco ; verb: bloquear)
  Método super se _target.respond_to?(name)

  classe.enviar(:with_scope, critério) fazer
    critério.public_send(name, *Args, &noum: bloco ; verb: bloquear)
  end
end

Detalhes do método de instância

#<<(*args) ➤ Objeto 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.addresses << address

Empurre um documento.

person.addresses.push(address)

Parâmetros:

  • *args (Documento...) —

    Qualquer número de documentos.



89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 89

def <<(*Args)
  Docs = Args.achatar
  Método a menos que Docs.algum?
  Método concat(Docs) se Docs.Tamanho > 1

  Docs.primeiro.toque fazer |doc|
    acrescentar(doc)
    doc.Salvar se persistente? && !_assigning?
  end

  auto
end

#_remove(document) ➤ 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.

Remove um único documento da coleção *somente na memória*. Ela não persistirá a alteração.

Parâmetros:

  • documento (Documento) —

    O documento a ser excluído.



236
237
238
239
240
241
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 236

def _remove(documento)
  _target.delete_one(documento)
  _unscoped.delete_one(documento)
  update_attributes_hash
  reIndexar
end

#as_document ➤ Array<Hash>

Obtenha esta associação como sua representação no banco de dados.

Exemplos:

Converta a associação em um hash de atributos.

person.addresses.as_document

Retorna:

  • (Array<Hash>) —

    A associação conforme armazenada no banco de dados.



110
111
112
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 110

def as_document
  as_attributes.coletar { |attrs| BSON::Documento.Novo(attrs) }
end

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

Cria um novo documento na associação e o anexa ao destino. Aceita um tipo opcional se você quiser especificar uma subclasse.

Exemplos:

Criar um novo documento sobre a associação.

person.people.build(:name => "Bozo")

Parâmetros:

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

    Os atributos com os quais construir o documento.

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

    Classe opcional com a qual construir o documento.

Retorna:



138
139
140
141
142
143
144
145
146
147
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 138

def COMPILAR(attributes = {}, type = nada)
  Factory.execute_build(type || _association.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 }
    _base._reset_memoized_descendentes!
  end
end

#clear → self

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

Se o documento do host não for persistente, mas seu _id corresponder a um documento persistente, chamar #clear em uma associação removerá os documentos da associação do banco de dados, mesmo que o conjunto de documentos no aplicativo (conforme carregado no host) seja diferente do que é no banco de dados, e o host também não pode conter nenhum documento persistente na associação.

Exemplos:

Limpe a associação.

person.addresses.clear

Retorna:

  • (self) —

    A associação vazia.



165
166
167
168
169
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 165

def Limpar
  batch_clear(_target.dup)
  update_attributes_hash
  auto
end

#concat(Docs) ➤ 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.addresses.concat([ address_one, address_two ])

Parâmetros:

  • Docs (Array <Document>) —

    Os Docs a serem adicionados.

Retorna:



123
124
125
126
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 123

def concat(Docs)
  batch_insert(Docs) a menos que Docs.vazio?
  auto
end

#count(*args, &block) ⇒ Integer

Retorna uma contagem do número de documentos na associação que realmente foram persistentes no banco de banco de dados.

Use #size se quiser o número total de documentos.

Se argumentos ou bloqueio estiverem presentes, #count delegará para o método #count em target e incluirá documentos persistentes e não persistentes.

Exemplos:

Obtenha a contagem de documentos persistentes.

person.addresses.count

Obtenha a contagem de todos os documentos correspondentes a um bloco.

person.addresses.count { |a| a.country == "FR" }

Você usa #persistente? bloco interno para contar documentos persistentes.

person.addresses.count { |a| a.persisted? && a.country == "FR" }

Parâmetros:

  • *args (Objeto...) —

    Args para delegar ao destino.

Retorna:

  • (Inteiro) —

    O número total de Docs incorporados persistentes , conforme sinalizado pelo #persisted? método.



193
194
195
196
197
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 193

def contar(*Args, &noum: bloco ; verb: bloquear)
  Método _target.contar(*Args, &noum: bloco ; verb: bloquear) se Args.algum? || noum: bloco ; verb: bloquear

  _target.contar(&:persistiu?)
end

#excluir(documento) ➤ Documento | nil Também conhecido como: delete_one

Exclua o documento fornecido do destino. Este método é proxy para reindexar a array após a ocorrência da operação.

Exemplos:

Exclua o documento da associação.

person.addresses.delete(address)

Parâmetros:

  • documento (Documento) —

    O documento a ser excluído.

Retorna:

  • (Document | nil) —

    O documento excluído ou nulo se nada for excluído.



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 208

def excluir(documento)
  execute_callbacks_round(:remove, documento) fazer
    _target.delete_one(documento).toque fazer |doc|
      se doc && !_binding?
        _unscoped.delete_one(doc)
        se _assigning?
          _base.add_atomic_pull(doc)
        mais
          doc.excluir(suprimir: true)
          unbind_one(doc)
        end
        update_attributes_hash
      end
      reIndexar
    end
  end
end

#delete_all(condição = {}) ➤ Inteiro

Exclua todos os documentos da associação sem executar chamadas de resposta.

Exemplos:

Exclua todos os documentos da associação.

person.addresses.delete_all

Exclua documentos condicionalmente da associação.

person.addresses.delete_all({ :street => "Bond" })

Parâmetros:

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

    Condições sobre quais documentos excluir.

Retorna:

  • (Inteiro) —

    O número de documentos excluídos.



254
255
256
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 254

def delete_all(condições = {})
  remove_all(condições, :delete)
end

#delete_if ➤ EmbedsMany::Proxy | Enumerador

Exclua todos os documentos para os quais o bloqueio fornecido retorna verdadeiro.

Exemplos:

Exclua os documentos correspondentes.

person.addresses.delete_if do |doc|
  doc.state == "GA"
end

Retorna:

  • (EmbedsMany::Proxy | Enumerador) —

    O proxy ou um enumerador se nenhum bloco foi fornecido.



267
268
269
270
271
272
273
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 267

def delete_if
  Método super a menos que block_given?

  _target.dup.cada { |doc| excluir(doc) se rendimento doc }

  auto
end

#Destruir_all(condição = {}) ➤ Inteiro

Destrua todos os documentos na associação enquanto executa callbacks.

Exemplos:

Destrua todos os documentos da associação.

person.addresses.destroy_all

Destrua condicionalmente documentos da associação.

person.addresses.destroy_all({ :street => "Bond" })

Parâmetros:

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

    Condições sobre quais documentos destruir.

Retorna:

  • (Inteiro) —

    O número de documentos destruídos.



286
287
288
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 286

def Destruir_all(condições = {})
  remove_all(condições, :destroy)
end

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

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

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 na associação em busca daqueles que correspondem às condições fornecidas e retorna verdadeiro se alguma correspondência tiver persistido. Qualquer outro argumento é interpretado como um ID, e é feita query da existência de documentos persistentes na associação com um _id correspondente .

Retorna:

  • (verdadeiro | falso) —

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



306
307
308
309
310
311
312
313
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 306

def existe?(id_or_ conditions = : none)
  caso id_or_ conditions
  quando : none então _target.algum?(&:persistiu?)
  quando nada, false então false
  quando Hash então ONDE(id_or_ conditions).algum?(&:persistiu?)
  mais ONDE(_id: id_or_ conditions).algum?(&:persistiu?)
  end
end

#find {|Object| ... } ⇒ Document | Array<Document> | nil

Encontra um documento nesta associação por meio de vários métodos diferentes.

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:

Encontre um documento por seu ID.

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

Encontre documentos para vários IDs.

person.addresses.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 (Objeto...) —

    Vários argumentos.

  • &block —

    Bloco opcional a ser aprovado.

Rendimento:

  • (Objeto) —

    Fornece cada elemento enumerável para o bloco.

Retorna:



340
341
342
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 340

def find(...)
  critério.find(...)
end

#pop(count = nil) ⇒ Document | Array<Document> | nil

Remova documentos da associação. Pode ser um único documento ou vários, e persistirá automaticamente as alterações.

Exemplos:

Abra um único documento.

relation.pop

Pop vários documentos.

relation.pop(3)

Parâmetros:

  • contar (Inteiro) (padrão para: nil) —

    O número de documentos a serem exibidos ou 1 , se não forem fornecidos.

Retorna:



365
366
367
368
369
370
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 365

def Pop(contar = nada)
  Método [] se contar&.zero?

  Docs = _target.último(contar || 1).cada { |doc| excluir(doc) }
  (contar.nada? || Docs.vazio?) ? Docs.primeiro : Docs
end

#shift(count = nil) ⇒ Document | Array<Document> | nil

Remova documentos da associação. Pode ser um único documento ou vários, e persistirá automaticamente as alterações.

Exemplos:

Deslocar um único documento.

relation.shift

Deslocar vários documentos.

relation.shift(3)

Parâmetros:

  • contar (Inteiro) (padrão para: nil) —

    O número de documentos a serem transferidos ou 1 se não forem fornecidos.

Retorna:



385
386
387
388
389
390
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 385

def mudança(contar = nada)
  Método [] se contar&.zero?

  Docs = _target.primeiro(contar || 1).cada { |doc| excluir(doc) }
  (contar.nada? || Docs.vazio?) ? Docs.primeiro : Docs
end

#replace(Docs) ➤ Muitos

Substitui os documentos de destino fornecidos pelos documentos existentes na relação.

Exemplos:

Substitua a meta da associação.

person.addresses.substitute([ address ])

Parâmetros:

  • Docs (Array <Documento> | Array<Hash>) —

    Os Docs substitutos .

Retorna:

  • (Muitos) —

    A associação proxy.



401
402
403
404
405
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 401

def substituir(Docs)
  batch_replace(Docs)
  update_attributes_hash
  auto
end

#sem escopo ➤ Critérios

Retorne a associação com todos os escopos anteriores removidos. Esta é a representação exata dos Docs no banco de banco de dados.

Exemplos:

Obtenha os documentos sem escopo.

person.addresses.unscoped

Retorna:



414
415
416
417
418
419
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 414

def sem escopo
  criterion = classe.sem escopo
  criterion.incorporado = true
  criterion.documentos = _unscoped.delete_if(&:marked_for_destruction?)
  criterion
end