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

Herda:
Muitos
  • Objeto
mostrar tudo
Estendido por:
Encaminhável, ClassMethods
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

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?, #cache_version, #create, #create!, #find_or_create_by, #find_or_create_by!, #find_or_initialize_by, #nil?, #respond_to?, #scoped, #serializable_hash

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:



70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 70

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 em qualquer lugar que definimos 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.



525
526
527
528
529
530
531
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 525

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.



92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 92

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 document da coleção apenas na memória. Ela não persistirá a alteração.

Parâmetros:

  • documento (Documento) —

    O documento a ser excluído.



239
240
241
242
243
244
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 239

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.



113
114
115
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 113

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:



141
142
143
144
145
146
147
148
149
150
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 141

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 documents da associação do banco de dados mesmo que o conjunto de documents no aplicativo (conforme carregado no host) seja diferente do que é no banco de dados, e o host também não pode conter nenhum document persistente na associação.

Exemplos:

Limpe a associação.

person.addresses.clear

Retorna:

  • (self) —

    A associação vazia.



168
169
170
171
172
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 168

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:



126
127
128
129
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 126

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.



196
197
198
199
200
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 196

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.



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

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.



257
258
259
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 257

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.



270
271
272
273
274
275
276
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 270

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.



289
290
291
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 289

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.



309
310
311
312
313
314
315
316
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 309

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

#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:



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

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:



359
360
361
362
363
364
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 359

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.



375
376
377
378
379
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 375

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:



388
389
390
391
392
393
 
# File 'lib/mongoid/association/embedded/embeds_many/proxy.rb', linha 388

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