Classe: Mongoid::Association::Referenced::HasMany::Enumerable

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Enumerável, Aplicável
Definido em:
lib/mongoid/association/referenced/has_many/enumerable.rb

Visão geral

Essa classe é o wrapper de todas as associações referenciadas que têm um destino que pode ser um critério ou uma array de documentos carregados. Isso lida com ambos os casos ou uma combinação dos dois.

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Detalhes do construtor

#initialize(target, base = nil, association = nil) ⇒ Enumerable

Inicialize o novo enumerável com um critério ou uma array.

Exemplos:

Inicialize o enumerável com um critério.

Enumerable.new(Post.where(:person_id => id))

Inicialize o enumerável com uma array.

Enumerable.new([ post ])

Parâmetros:



260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 260

def inicializar(Alvo, base = nada, associação = nada)
  @_base = base
  @_association = associação
  se Alvo.is_a?(critério)
    @_added, @executed, @_loaded, @_unloaded = {}, false, {}, Alvo
  mais
    @_added, @executed = {}, true
    @_loaded = Alvo.cada_com_objeto({}) fazer |doc, _target|
      _target[doc._id] = doc se doc
    end
  end
end

Detalhes do atributo da instância

#_added ➤ Object

As três principais variáveis de instância são collections de documentos.



22
23
24
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

def _added
  @_added
end

#_added Documentos que foram anexados.(Documentosqueforamanexados.) ➤ Objeto

As três principais variáveis de instância são collections de documentos.



22
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

attr_accessor :_added, :_loaded, :_unloaded

#_loaded ➤ Object

As três principais variáveis de instância são collections de documentos.



22
23
24
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

def _loaded
  @_loaded
end

#_loaded Documentos persistentes que foram _loaded.(Documentos persistentes que foram carregados.) ➤ Objeto

As três principais variáveis de instância são collections de documentos.



22
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

attr_accessor :_added, :_loaded, :_unloaded

#_unloaded ➤ Object

As três principais variáveis de instância são collections de documentos.



22
23
24
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

def _unloaded
  @_unloaded
end

#_unloaded Um critério que representa Docs persistentes .(Os critérios estão representando documentos persistentes.) ➤ Objeto

As três principais variáveis de instância são collections de documentos.



22
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 22

attr_accessor :_added, :_loaded, :_unloaded

Detalhes do método de instância

#<<(documento) ➤ Documento Também conhecido como: push

Anexar um documento ao enumerável.

Exemplos:

Anexe o documento.

enumerable << document

Parâmetros:

  • documento (Documento) —

    O documento a ser anexado.

Retorna:



63
64
65
66
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 63

def <<(documento)
  _added[documento._id] = documento
  auto
end

#==(outro) ➤ verdadeiro | false

Verifique se o enumerável é igual ao outro objeto.

Exemplos:

Verifique a igualdade.

enumerable == []

Parâmetros:

Retorna:

  • (verdadeiro | falso) —

    Se os objetos forem iguais.



34
35
36
37
38
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 34

def ==(Outro)
  Método false a menos que Outro.respond_to?(:entries)

  entradas == Outro.entradas
end

#===(outro) ➤ verdadeiro | false

Verifique a igualdade do enumerável em relação ao objeto fornecido para declarações de caso .

Exemplos:

Verifique a igualdade de maiúsculas e minúsculas.

enumerable === Array

Parâmetros:

  • Outro (Objeto) —

    O objeto a ser verificado.

Retorna:

  • (verdadeiro | falso) —

    Se os objetos forem iguais em um caso .



49
50
51
52
53
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 49

def ===(Outro)
  Método false a menos que Outro.respond_to?(:entries)

  entradas === Outro.entradas
end

#_loaded? ➤ verdadeiro | false

O enumerável foi _loaded? Isso será verdade se os critérios tiverem sido executados ou carregarmos manualmente a coisa toda.

Exemplos:

O enumerável _loaded?

enumerable._loaded?

Retorna:

  • (verdadeiro | falso) —

    Se o enumerável tiver sido _loaded.



351
352
353
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 351

def _loaded?
  !!@executed
end

#algum?(*args) ➤ verdadeiro | false

Retorna se a associação tem algum documento, opcionalmente sujeito aos filtros fornecidos.

Este método retorna verdadeiro se a associação tiver algum documento persistente e se tiver algum documento ainda não persistente.

Se a associação já estiver carregada, esse método inspecionará os documentos carregados e não executará query no banco de banco de dados. Se a associação não for carregada, a versão sem argumentos e sem blocos não carregará a associação; as outras versões (que delegam ao Enumerable) podem ou não carregar a associação completamente, dependendo se ela é iterada para conclusão.

Este método pode receber um parâmetro e um bloco. O comportamento com o parâmetro ou o bloco é delegado ao módulo Enumerable da biblioteca padrão.

Observe que quando Enumerable's any? método é invocado com um bloco e um padrão, ele usa apenas o padrão.

Parâmetros:

  • *args (Objeto...) —

    A condição que os documentos devem satisfazer. Consulte a documentação do Enumerable para obter detalhes.

Retorna:

  • (verdadeiro | falso) —

    Se a associação tiver algum documento.



223
224
225
226
227
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 223

def algum?(*Args)
  Método super se Args.algum? || block_given?

  !vazio?
end

#as_json(options = {}) ➤ Hash

Enviar #as_json para as entradas, sem codificação.

Exemplos:

Obtenha o enumerável como JSON.

enumerable.as_json

Parâmetros:

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

    Parâmetros opcionais.

Retorna:

  • (Hash) —

    As entradas todas _loaded como um hash.



504
505
506
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 504

def as_json(opções = {})
  entradas.as_json(opções)
end

#avg(campo) ➤ float | nada

Obtenha a média do campo fornecido para todos os documentos no enumerável. Quando a associação é carregada, calcula na memória sem consultar o banco de dados.

Exemplos:

Obter a média de um campo.

enumerable.avg(:likes)

Parâmetros:

  • Campo (Símbolo) —

    O campo para média.

Retorna:

  • (Flutuante | nulo) —

    O valor médio ou nulo se não houver documentos.



534
535
536
537
538
539
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 534

def avg(Campo)
  values = field_values_for(Campo)
  Método nada se values.vazio?

  values.soma / values.Tamanho.to_f
end

#clear(&block) ➤ Array<Document>

Limpa todos os documentos neste enumerável. Se for passado um bloco, ele produzirá cada documento que está na memória.

Exemplos:

Limpe o enumerável.

enumerable.clear

Limpe o enumerável com um bloco.

enumerable.clear do |doc|
  doc.unbind
end

Retorna:

  • (Array <Document>) —

    Os _added Docs removidos .



82
83
84
85
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 82

def Limpar(&noum: bloco ; verb: bloquear)
  in_memory(&noum: bloco ; verb: bloquear) se block_given?
  _loaded.Limpar e a _added.Limpar
end

#clone ➤ Array<Document>

Observação:

Isso carrega todos os documentos na memória.

Clona cada documento no enumerável.

Exemplos:

Clone o enumerável.

enumerable.clone

Retorna:

  • (Array <Document>) —

    Um clone de array do enumerável.



95
96
97
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 95

def clonar
  coletar { |doc| doc.clonar }
end

#delete(document) {|doc| ... } ⇒ Document

Exclua o documento fornecido do enumerável.

Exemplos:

Exclua o documento.

enumerable.delete(document)

Parâmetros:

  • documento (Documento) —

    O documento a ser excluído.

Rendimento:

  • (doc)

Retorna:



107
108
109
110
111
112
113
114
115
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 107

def excluir(documento)
  doc = _loaded.excluir(documento._id) || _added.excluir(documento._id)
  se !doc && _unloaded && _unloaded.ONDE(_id: documento._id).existe?
    rendimento(documento) se block_given?
    Método documento
  end
  rendimento(doc) se block_given?
  doc
end

#delete_if(&block) ➤ Array<Document>

Observação:

Esta operação carrega todos os documentos do banco de banco de dados.

Exclui todos os documento no enumerável para onde o bloqueio retorna verdadeiro.

Exemplos:

Exclua todos os documentos correspondentes.

enumerable.delete_if do |doc|
  dod._id == _id
end

Retorna:

  • (Array <Document>) —

    Os Docs restantes .



128
129
130
131
132
133
134
135
136
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 128

def delete_if(&noum: bloco ; verb: bloquear)
  load_all!
  Excluído = in_memory.selecione(&noum: bloco ; verb: bloquear)
  Excluído.cada fazer |doc|
    _loaded.excluir(doc._id)
    _added.excluir(doc._id)
  end
  auto
end

#cada ➤ verdadeiro

A iteração sobre este enumerável tem que lidar com alguns cenários diferentes.

Se o enumerável tiver seus critérios _loaded na memória, ele produzirá todos os _loaded Docs e todos os _added Docs.

Se o enumerável não tiver _load os critérios, ele iterará sobre o cursor enquanto carrega os documentos e, em seguida, iterará sobre os _added Docs.

Se nenhum bloco for passado, ele retornará um enumerador contendo todos os Docs.

Exemplos:

Iterar sobre o enumerável.

enumerable.each do |doc|
  puts doc
end

retornar um enumerador contendo todos os Docs


a = enumerable.each

Retorna:

  • (verdadeiro) —

    Que o enumerável agora está _loaded.



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 161

def cada
  Método to_enum a menos que block_given?

  se _loaded?
    _loaded.cada_pair fazer |_id, doc|
      documento = _added.excluir(doc._id) || doc
      set_base(documento)
      rendimento(documento)
    end
  mais
    descarregado_documents.cada fazer |doc|
      documento = _added.excluir(doc._id) || _loaded.excluir(doc._id) || doc
      _loaded[documento._id] = documento
      set_base(documento)
      rendimento(documento)
    end
  end
  _added.cada_pair fazer |_id, doc|
    rendimento(doc)
  end
  @executed = true
end

#vazio? ➤ verdadeiro | false

O enumerável está vazio? Determinará se a contagem é zero com base no fato de ser _loaded ou não.

Exemplos:

O enumerável está vazio?

enumerable.empty?

Retorna:

  • (verdadeiro | falso) —

    Se o enumerável estiver vazio.



191
192
193
194
195
196
197
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 191

def vazio?
  se _loaded?
    in_memory.vazio?
  mais
    _added.vazio? && !_unloaded.existe?
  end
end

#first(limit = nil) ⇒ Document

Observação:

Adicionar automaticamente uma classificação no _id quando nenhuma outra classificação está definida nos critérios tem o potencial de causar problemas de desempenho ruins. Se você tiver um desempenho ruim inesperado ao usar #first ou #last, use #take em vez disso. Esteja ciente de que #take não garante o pedido.

Obtenha o primeiro documento no enumerável. Verificará primeiro os documentos persistentes. Não carrega o enumerável inteiro.

Exemplos:

Obtenha o primeiro documento.

enumerable.first

Parâmetros:

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

    O número de documentos a retornar.

Retorna:

  • (Documento) —

    O primeiro documento encontrado.



244
245
246
247
248
249
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 244

def primeiro(limit = nada)
  _loaded.tentar(:values).tentar(:first) ||
    _added[(ul = _unloaded.tentar(:first, limit)).tentar(:_id)] ||
    ul ||
    _added.values.tentar(:first)
end

#in_memory ➤ Array<Document>

Observação:

Quando passado um bloco , ele produz a cada documento.

Retornar todos os documentos no enumerável que foram carregados ou adicionados.

Exemplos:

Obtenha os Docs na memória .

enumerable.in_memory

Retorna:

  • (Array <Document>) —

    Os Docs armazenados na memória .



307
308
309
310
311
312
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 307

def in_memory
  Docs = (_loaded.values + _added.values)
  Docs.cada fazer |doc|
    rendimento(doc) se block_given?
  end
end

#incluir?(doc) ➤ verdadeiro | false

O destino inclui o documento fornecido?

Exemplos:

O destino inclui o documento?

enumerable.include?(document)

Parâmetros:

  • doc (Documento) —

    O documento a ser verificado.

Retorna:

  • (verdadeiro | falso) —

    Se o documento estiver no destino.



281
282
283
284
285
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 281

def incluir?(doc)
  Método super a menos que _unloaded

  _unloaded.ONDE(_id: doc._id).existe? || _added.has_key?(doc._id)
end

#inspecionar ➤ string

A inspeção apenas inspecionará as entradas quanto a uma boa impressão em estilo array.

Exemplos:

Inspecione o enumerável.

enumerable.inspect

Retorna:

  • (string) —

    O enumeração inspecionado.



294
295
296
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 294

def inspecionar
  entradas.inspecionar
end

#last(limit = nil) ⇒ Document

Observação:

Adicionar automaticamente uma classificação no _id quando nenhuma outra classificação está definida nos critérios tem o potencial de causar problemas de desempenho ruins. Se você tiver um desempenho ruim inesperado ao usar #first ou #last, use #take em vez disso. Esteja ciente de que #take não garante o pedido.

Obtenha o último documento no enumerável. Verificará os novos documentos primeiro. Não carrega o enumerável inteiro.

Exemplos:

Obtenha o último documento.

enumerable.last

Parâmetros:

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

    O número de documentos a retornar.

Retorna:

  • (Documento) —

    O último documento encontrado.



329
330
331
332
333
334
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 329

def último(limit = nada)
  _added.values.tentar(:last) ||
    _loaded.tentar(:values).tentar(:last) ||
    _added[(ul = _unloaded.tentar(:last, limit)).tentar(:_id)] ||
    ul
end

#marshard_dump ➤ Array<Object>

Fornece os dados necessários para um proxy enumerável a partir de um proxy enumerável.

Exemplos:

Despeje o proxy.

Marshal.dump(proxy)

Retorna:

  • (Array<Object>) —

    Os dados despejados.



361
362
363
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 361

def março_dump
  [ _added, _loaded, _unloaded, @executed ]
end

#março_load(data) ➤ Array<Object>

Carrega os dados necessários paraMarshard.load um proxy enumerável.

Exemplos:

Carregue o proxy.

Marshal.load(proxy)

Retorna:

  • (Array<Object>) —

    Os dados despejados.



371
372
373
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 371

def março_load(de dados)
  @_added, @_loaded, @_unloaded, @executed = de dados
end

#max(field = nil) ⇒ Numeric | nil

Obtenha o valor máximo do campo fornecido para todos os document no enumerável. Quando a associação é carregada, calcula na memória sem consultar o banco de dados.

Exemplos:

Obtenha o máximo de um campo.

enumerable.max(:likes)

Parâmetros:

  • Campo (Símbolo) (padrão para: nil) —

    O campo para o máximo.

Retorna:

  • (Numeric | nil) —

    O valor máximo ou nulo se não houver documentos.



567
568
569
570
571
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 567

def max(Campo = nada)
  Método super() se block_given?

  field_values_for(Campo).max
end

#min(field = nil) ⇒ Numeric | nil

Obtenha o valor mínimo do campo fornecido para todos os documentos no enumerável. Quando a associação é carregada, calcula na memória sem consultar o banco de dados.

Exemplos:

Obtenha o min de um campo.

enumerable.min(:likes)

Parâmetros:

  • Campo (Símbolo) (padrão para: nil) —

    O campo para min.

Retorna:

  • (Numeric | nil) —

    O valor mínimo ou nulo se não houver documentos.



551
552
553
554
555
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 551

def min(Campo = nada)
  Método super() se block_given?

  field_values_for(Campo).min
end

#pluck(*keys) ⇒ Array | Array<Array>

Arranca os nomes de campo fornecidos dos documentos no destino. Se a coleção tiver sido carregada, ela coletará dos documentos carregados; caso contrário, ele extrai dos critérios descarregados. Independentemente disso, ele também extrai de quaisquer `document` adicionados.

Parâmetros:

  • *fields (Símbolo...) —

    Os nomes dos campo a serem retirados.

Retorna:

  • (Array | Array<Array>) —

    A array de valores de campo . Se vários campos forem fornecidos, uma array de arrays será retornada.



384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 384

def raspar(*keys)
  [].toque fazer |Resultados|
    se _loaded? || _added.algum?
      classe = @_association.classe
      preparado = prepare_pluck(keys, document_class: classe)
    end

    se _loaded?
      Docs = _loaded.values.map { |v| BSON::Documento.Novo(v.attributes) }
      Resultados.concat pluck_from_documents(Docs, preparado[:field_names], document_class: classe)
    elsif _unloaded
      critério = se _added.algum?
                   ids_to_exclude = _added.keys
                   _unloaded.não(:_id.Em => ids_to_exclude)
                 mais
                   _unloaded
                 end

      Resultados.concat critério.raspar(*keys)
    end

    se _added.algum?
      Docs = _added.values.map { |v| BSON::Documento.Novo(v.attributes) }
      Resultados.concat pluck_from_documents(Docs, preparado[:field_names], document_class: classe)
    end
  end
end

#reset ⇒ false

Redefina o enumerável de volta ao seu estado persistente.

Exemplos:

Redefinir o enumerável.

enumerable.reset

Retorna:

  • (falso) —

    Sempre falso.



418
419
420
421
422
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 418

def reiniciar
  _loaded.Limpar
  _added.Limpar
  @executed = false
end

#reinício_unloaded(critérios) ➤ Objeto

Redefine o objeto de critérios descarregado subjacente com um novo. Usei minhas associações HABTM para manter a array subjacente sincronizada.

Exemplos:

Redefinir os documentos descarregados.

enumerable.reset_unloaded(criteria)

Parâmetros:

  • critério (Critérios) —

    Os critérios pelos quais substituir.



431
432
433
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 431

def reinício_unloaded(critério)
  @_unloaded = critério se _unloaded.is_a?(critério)
end

#respond_to?(nome, include_private = false) ➤ true | false

Este enumerável responde ao método fornecido?

Exemplos:

O enumerável responde ao método?

enumerable.respond_to?(:sum)

Parâmetros:

  • name (string | Símbolo) —

    O nome do método.

  • include_private (verdadeiro | falso) (padrão para: false) —

    Se incluir métodos privados.

Retorna:

  • (verdadeiro | falso) —

    Se o enumerável responde.



445
446
447
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 445

def respond_to?(name, include_private = false)
  [].respond_to?(name, include_private) || super
end

#tamanho ➤ Inteiro Também conhecido como: comprimento

Obtém o tamanho total deste enumerável. Esta é uma combinação de todos os documentos persistentes e não persistentes.

Exemplos:

Obtenha o tamanho.

enumerable.size

Retorna:

  • (Inteiro) —

    O tamanho do enumerável.



456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 456

def Tamanho
  # Se _unloaded estiver presente, ele corresponderá ao conjunto de documentos
  # que pertencem a esta associação, que já foram persistentes
  # para o banco de dados. Esse conjunto de documentos deve ser considerado quando
  # calculando o tamanho da associação, junto com qualquer coisa que tenha
  # já foi adicionado.
  se _unloaded
    se _added.algum?
      # Observe que _added pode incluir registros que _unloaded já
      # correspondências. Esse é o caso se a associação receber uma array
      # de itens e alguns deles já eram elementos da associação.
      #
      # portanto, precisamos garantir que _unloaded.count exclua quaisquer elementos
      # que já existe em _added.

      contar = _unloaded.não(:_id.Em => _added.values.map(&:id)).contar
      contar + _added.values.contar
    mais
      _unloaded.contar
    end

  mais
    _loaded.contar + _added.contar
  end
end

#soma(campo = nil) ➤ Numérico

Obtenha a soma do campo fornecido para todos os documentos no enumerável. Quando a associação é carregada, calcula na memória sem consultar o banco de dados.

Exemplos:

Obtenha a soma de um campo.

enumerable.sum(:likes)

Parâmetros:

  • Campo (Símbolo) (padrão para: nil) —

    O campo a ser somado.

Retorna:

  • (Numérico) —

    O valor da soma.



518
519
520
521
522
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 518

def soma(Campo = nada)
  Método super(Campo || 0) se block_given?

  field_values_for(Campo).soma || 0
end

#to_json(opções = {}) ➤ string

Enviar #to_json para as entradas.

Exemplos:

Obtenha o enumerável como JSON.

enumerable.to_json

Parâmetros:

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

    Parâmetros opcionais.

Retorna:

  • (string) —

    As entradas todas _loaded como uma string.



492
493
494
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 492

def to_json(opções = {})
  entradas.to_json(opções)
end

#uniq ⇒ Array<Document>

Observação:

Esta operação carrega todos os documentos do banco de banco de dados.

Retornar todos os documentos exclusivos no enumerável.

Exemplos:

Obtenha todos os documentos exclusivos.

enumerable.uniq

Retorna:

  • (Array <Document>) —

    Os documentos únicos.



581
582
583
 
# File 'lib/mongoid/association/referenced/has_many/enumerable.rb', linha 581

def uniq
  entradas.uniq
end