Clase: Mongoid::Association::Referenced::HasMany::Enumerable

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Enumerable, Extraíble
Definido en:
lib/mongoid/association/referenced/has_many/enumerable.rb

Overview

Esta clase es el contenedor para todas las asociaciones referenciadas que tienen un destino que puede ser un criterio o un arreglo de documentos _cargados. Esto gestiona ambos casos o una combinación de los dos.

Resumen de atributos de la instancia colapsar

Resumen del método de instancia colapsar

Detalles del Constructor

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

Inicializa el nuevo enumerable con criterios o un arreglo.

Ejemplos:

Inicializar el enumerable con criterios.

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

Inicializa el enumerable con un arreglo.

Enumerable.new([ post ])

Parámetros:



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

def inicializar(Objetivo, base = nulo, asociación = nulo)
  @_base = base
  @_association = asociación
  si Objetivo.is_a?(Criterios)
    @_añadido, @executed, @_cargado, @_unloaded = {}, false, {}, Objetivo
  else
    @_añadido, @executed = {}, true
    @_cargado = Objetivo.each_with_object({}) hacer |doc, _target|
      _target[doc._id] = doc si doc
    end
  end
end

Detalles de atributo de instancias

#_added ⇒ objeto

Las tres principales variables de instancia son colecciones de documentos.



22
23
24
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

def _agregado
  @_añadido
end

#_added Documentos que se han anexado.(Documentsthathavebeenappended.) ⇒ Objeto

Las tres principales variables de instancia son colecciones de documentos.



22
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

attr_accessor añadido, _cargado, :_unloaded

#_loaded ⇒ Object

Las tres principales variables de instancia son colecciones de documentos.



22
23
24
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

def _loaded
  @_cargado
end

#_loaded Documentos persistidos que se han _loaded.(Documentospersistidosquesehan_loaded.) ⇒ objeto

Las tres principales variables de instancia son colecciones de documentos.



22
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

attr_accessor añadido, _cargado, :_unloaded

#_unloaded ⇒ objeto

Las tres principales variables de instancia son colecciones de documentos.



22
23
24
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

def descargado
  @_unloaded
end

#_unloaded Un criterio que representa documentos almacenados de modo persistente.(Uncriterioquerepresentadocumentosalmacenadosdemodopersistente.) ⇒ objeto

Las tres principales variables de instancia son colecciones de documentos.



22
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 22

attr_accessor añadido, _cargado, :_unloaded

Detalles del método de instancia

#<<(documento) ⇒ Documento También conocido como: push

Adjunta un documento al enumerable.

Ejemplos:

Agrega el documento.

enumerable << document

Parámetros:

  • Documento (documento) —

    El documento a adjuntar.

Devuelve:



63
64
65
66
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 63

def <<(Documento)
  _agregado[Documento._id] = Documento
  sí mismo
end

#==(another) ⇒ verdadero | falso

Verifique si el enumerable es igual al otro objeto.

Ejemplos:

Comprobar la igualdad.

enumerable == []

Parámetros:

Devuelve:

  • (true | false) —

    Si los objetos son iguales.



34
35
36
37
38
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 34

def ==(Otros)
  return false a menos que Otros.respond_to?(entradas:)

  entradas == Otros.entradas
end

#===(otro) ⇒ verdadero | falso

Verifica la igualdad del enumerable con el objeto proporcionado para instrucciones case.

Ejemplos:

Comprobar la igualdad de mayúsculas y minúsculas.

enumerable === Array

Parámetros:

  • Otros (objeto) —

    El objeto para comprobar.

Devuelve:

  • (true | false) —

    Si los objetos son iguales en un caso.



49
50
51
52
53
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 49

def ===(Otros)
  return false a menos que Otros.respond_to?(entradas:)

  entradas === Otros.entradas
end

#_cargado? ⇒ true | false

¿Se ha _cargado el enumerable? Esto será cierto si se ha ejecutado el criterio o si cargamos manualmente todo el proceso.

Ejemplos:

¿Está cargada la colección enumerable?

enumerable._loaded?

Devuelve:

  • (true | false) —

    Si la colección enumerable se ha _cargado.



351
352
353
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 351

def ¿cargado?
  !!@executed
end

#any?(*args) ⇒ true | false

Devuelve si la asociación tiene algún documento, opcionalmente sujeto a los filtros proporcionados.

Este método devuelve verdadero si la asociación tiene documentos persistidos y si tiene documentos que aún no se han persistido.

Si la asociación ya está cargada, este método inspecciona los documentos cargados y no query la base de datos. Si la asociación no está cargada, la versión sin argumentos ni bloques no carga la asociación; las otras versiones (que delegan en Enumerable) pueden o no cargar completamente la asociación dependiendo de si se itera hasta la finalización.

Este método puede tomar un parámetro y un bloque. El comportamiento con el parámetro o el bloque se delega al módulo de librería estándar Enumerable.

Ten en cuenta que cuando el método any? de Enumerable se invoca con tanto un bloque como un patrón, solo se usa el patrón.

Parámetros:

  • *args (objeto...) —

    La condición que deben cumplir los documentos. Consulte la documentación de Enumerable para obtener más detalles.

Devuelve:

  • (true | false) —

    Si la asociación tiene algún documento.



223
224
225
226
227
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 223

def any?(*args)
  return super si args.any? || ¿block_given?

  !¿vacío?
end

#as_json(options = {}) ⇒ Hash

Envíe #as_json a las entradas, sin codificar.

Ejemplos:

Obtener el enumerable como json.

enumerable.as_json

Parámetros:

  • opciones (encriptada) (por defecto: {}) —

    Parámetros opcionales.

Devuelve:

  • (encriptada) —

    Las entradas todas cargadas como un hash.



504
505
506
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 504

def as_json(opciones = {})
  entradas.as_json(opciones)
end

#avg(campo) ⇒ Float | nil

Obtén el promedio del campo proporcionado para todos los document en el enumerable. Cuando se carga la asociación, se computa en memoria sin consultar la base de datos.

Ejemplos:

Obtén el promedio de un campo.

enumerable.avg(:likes)

Parámetros:

  • Campo (Símbolo) —

    El campo a promediar.

Devuelve:

  • (Float | nil) —

    El valor promedio o nulo si no hay documentos.



534
535
536
537
538
539
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 534

def promedio(Campo)
  values = valores_campo_para(Campo)
  return nulo si values.¿vacío?

  values.suma / values.Tamaño.to_f
end

#clear(&block) ⇒ Array<Document>

Borra todos los documentos en esta enumeración. Si se registra un bloque, se cederá a cada documento que esté en la memoria.

Ejemplos:

Vaciar el enumerable.

enumerable.clear

Limpie el enumerable con un bloque.

enumerable.clear do |doc|
  doc.unbind
end

Devuelve:

  • (Array<documento>) —

    Se eliminaron los _docs. añadidos.



82
83
84
85
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 82

def borrar(&bloque)
  en memoria(&bloque) si ¿block_given?
  _loaded.borrar y  _agregado.borrar
end

#clone ⇒ Array<Document>

Nota:

Esto carga todos los documentos en la memoria.

Clona cada documento del enumerable.

Ejemplos:

Clona el enumerable.

enumerable.clone

Devuelve:

  • (Array<documento>) —

    Un clon del arreglo del enumerable.



95
96
97
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 95

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

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

Borra el documento proporcionado del enumerador.

Ejemplos:

Borrar el documento.

enumerable.delete(document)

Parámetros:

  • Documento (documento) —

    El documento a borrar.

Rendimientos:

  • (doc)

Devuelve:



107
108
109
110
111
112
113
114
115
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 107

def borrar(Documento)
  doc = _loaded.borrar(Documento._id) || _agregado.borrar(Documento._id)
  si !doc && descargado && descargado.dónde(_id: Documento._id).¿existe?
    rendimiento(Documento) si ¿block_given?
    return Documento
  end
  rendimiento(doc) si ¿block_given?
  doc
end

#delete_if(&block) ⇒ arreglo<documento>

Nota:

Esta operación carga todos los documentos de la base de datos.

Elimina todos los documentos en el enumerador para los cuales el bloque retorna verdadero.

Ejemplos:

Borrar todos los documentos que coincidan.

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

Devuelve:



128
129
130
131
132
133
134
135
136
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 128

def delete_if(&bloque)
  cargar_todo!
  deleted = en memoria.Seleccionar(&bloque)
  deleted.cada hacer |doc|
    _loaded.borrar(doc._id)
    _agregado.borrar(doc._id)
  end
  sí mismo
end

#each ⇒ true

Iterar sobre este enumerable tiene que gestionar algunos escenarios diferentes.

Si el enumerable tiene sus criterios _cargados en memoria entonces cede a todos los _docs _cargados y a todos los _docs _añadidos.

Si el enumerable no ha _cargado los criterios, entonces itera sobre el cursor mientras carga los documentos y luego itera sobre los _added docs.

Si no se pasa ningún bloque, devolverá un enumerador que contiene todos los Docs.

Ejemplos:

Itera el objeto enumerable.

enumerable.each do |doc|
  puts doc
end

devuelve un enumerador que contenga todos los Docs


a = enumerable.each

Devuelve:

  • (cierto) —

    Que lo enumerable ahora esté _cargado.



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

def cada
  return to_enum a menos que ¿block_given?

  si ¿cargado?
    _loaded.each_pair hacer |_id, doc|
      Documento = _agregado.borrar(doc._id) || doc
      set_base(Documento)
      rendimiento(Documento)
    end
  else
    unloaded_documents.cada hacer |doc|
      Documento = _agregado.borrar(doc._id) || _loaded.borrar(doc._id) || doc
      _loaded[Documento._id] = Documento
      set_base(Documento)
      rendimiento(Documento)
    end
  end
  _agregado.each_pair hacer |_id, doc|
    rendimiento(doc)
  end
  @executed = true
end

#empty? ⇒ true | false

¿Está el enumerable vacío? Se determinará si el recuento es cero en función de si está _loaded o no.

Ejemplos:

¿Está vacío el enumerable?

enumerable.empty?

Devuelve:

  • (true | false) —

    Si el enumerable está vacío.



191
192
193
194
195
196
197
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 191

def ¿vacío?
  si ¿cargado?
    en memoria.¿vacío?
  else
    _agregado.¿vacío? && !descargado.¿existe?
  end
end

#first(limit = nil) ⇒ Document

Nota:

Agregar automáticamente una ordenación en _id cuando no se define ninguna otra ordenación en los criterios tiene el potencial de causar problemas de rendimiento graves. Si experimenta un rendimiento inesperadamente deficiente al utilizar #first o #last, utilice #take en su lugar. Tenga en cuenta que #tome no garantiza el orden.

Obtén el primer documento en el enumerable. Primero comprobará los documentos persistidos. No carga la totalidad del enumerable.

Ejemplos:

Obtén el primer documento.

enumerable.first

Parámetros:

  • limit (Integer) (valor por defecto: nil) —

    El número de documentos a devolver.

Devuelve:

  • (documento) —

    El primer documento encontrado.



244
245
246
247
248
249
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 244

def primero(limit = nulo)
  _loaded.intentar(:values).intentar(primero) ||
    _agregado[(ul = descargado.intentar(primero, limit)).intentar(::_id)] ||
    ul ||
    _agregado.values.intentar(primero)
end

#in_memory ⇒ Array<Document>

Nota:

Al pasarle un bloque, se ejecuta para cada documento.

Devuelve todos los documentos en el enumerable que se han _cargado o _agregado.

Ejemplos:

Obtén los Docs en memoria.

enumerable.in_memory

Devuelve:

  • (Array<documento>) —

    Los Docs en memoria.



307
308
309
310
311
312
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 307

def en memoria
  docs = (_loaded.values + _agregado.values)
  docs.cada hacer |doc|
    rendimiento(doc) si ¿block_given?
  end
end

#include?(doc) ⇒ true | false

¿El objetivo incluye el documento proporcionado?

Ejemplos:

¿El objetivo incluye el documento?

enumerable.include?(document)

Parámetros:

  • doc (documento) —

    El documento a comprobar.

Devuelve:

  • (true | false) —

    Si el documento está en el destino.



281
282
283
284
285
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 281

def incluir?(doc)
  return super a menos que descargado

  descargado.dónde(_id: doc._id).¿existe? || _agregado.has_key?(doc._id)
end

#inspect ⇒ String

La inspección simplemente inspeccionará las entradas para una impresión elegante al estilo de arreglo.

Ejemplos:

Inspeccionar el enumerable.

enumerable.inspect

Devuelve:

  • (string) —

    El enum inspeccionado.



294
295
296
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 294

def inspeccionar
  entradas.inspeccionar
end

#last(limit = nil) ⇒ Document

Nota:

Agregar automáticamente una ordenación en _id cuando no se define ninguna otra ordenación en los criterios tiene el potencial de causar problemas de rendimiento graves. Si experimenta un rendimiento inesperadamente deficiente al utilizar #first o #last, utilice #take en su lugar. Tenga en cuenta que #tome no garantiza el orden.

Obtén el último documento del enumerable. Comprobará primero los nuevos documentos. No carga todo el enumerable.

Ejemplos:

Obtener el último documento.

enumerable.last

Parámetros:

  • limit (Integer) (valor por defecto: nil) —

    El número de documentos a devolver.

Devuelve:

  • (documento) —

    El último documento encontrado.



329
330
331
332
333
334
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 329

def último(limit = nulo)
  _agregado.values.intentar(:último) ||
    _loaded.intentar(:values).intentar(:último) ||
    _agregado[(ul = descargado.intentar(:último, limit)).intentar(::_id)] ||
    ul
end

#marshal_dump ⇒ arreglo<Object>

Proporciona los datos necesarios para Marshal.vaciado de un proxy enumerable.

Ejemplos:

Descargue el proxy.

Marshal.dump(proxy)

Devuelve:

  • (arreglo<Object>) —

    Los datos volcados.



361
362
363
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 361

def marshal_dump
  [ _agregado, _loaded, descargado, @executed ]
end

#marshal_load(data) ⇒ arreglo<Object>

Carga los datos necesarios para Marshal.load en un proxy enumerable.

Ejemplos:

Cargue el proxy.

Marshal.load(proxy)

Devuelve:

  • (arreglo<Object>) —

    Los datos volcados.



371
372
373
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 371

def marshal_load(Datos)
  @_añadido, @_cargado, @_unloaded, @executed = Datos
end

#max(field = nil) ⇒ Numeric | nil

Obtener el valor máximo del campo proporcionado para todos los documentos en el enumerable. Cuando se carga la asociación, se computa en memoria sin consultar la base de datos.

Ejemplos:

Obtené el máximo de un campo.

enumerable.max(:likes)

Parámetros:

  • Campo (Símbolo) (valor por defecto: nil) —

    El campo al máximo.

Devuelve:

  • (Numeric | nil) —

    El valor máximo o nulo si no hay documentos.



567
568
569
570
571
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 567

def máximo(Campo = nulo)
  return super() si ¿block_given?

  valores_campo_para(Campo).máximo
end

#min(field = nil) ⇒ Numeric | nil

Obtén el valor mínimo del campo proporcionado para todos los documentos del enumerable. Cuando se carga la asociación, se computa en memoria sin consultar la base de datos.

Ejemplos:

Obten el mínimo de un campo.

enumerable.min(:likes)

Parámetros:

  • Campo (Símbolo) (valor por defecto: nil) —

    El campo a min.

Devuelve:

  • (Numeric | nil) —

    El valor mínimo o "nil" si no hay documentos.



551
552
553
554
555
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 551

def min(Campo = nulo)
  return super() si ¿block_given?

  valores_campo_para(Campo).min
end

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

Extrae los nombres de campo dados de los documentos en el objetivo. Si se ha cargado la colección, se selecciona de los document cargados; de lo contrario, se selecciona de los criterios no cargados. En cualquier caso, también extrae de cualquier document agregado.

Parámetros:

  • *campo (Symbol...) —

    Los nombres de los campos a extraer.

Devuelve:

  • (Array | Array<Array>) —

    El arreglo de valores de campo. Si se proporcionan varios campos, se devuelve un arreglo de arreglos.



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
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 384

def pluck(*claves)
  [].tocar hacer |Resultados|
    si ¿cargado? || _agregado.any?
      klass = @_association.klass
      preparado = prepare_pluck(claves, document_class: klass)
    end

    si ¿cargado?
      docs = _loaded.values.map { |v| BSON::Documento.Nuevo(v.atributos) }
      Resultados.concat extraer de documentos(docs, preparado[Nombres de campos], document_class: klass)
    elsif descargado
      criterios = si _agregado.any?
                   ids_to_exclude = _agregado.claves
                   descargado.no(::_id.in => ids_to_exclude)
                 else
                   descargado
                 end

      Resultados.concat criterios.pluck(*claves)
    end

    si _agregado.any?
      docs = _agregado.values.map { |v| BSON::Documento.Nuevo(v.atributos) }
      Resultados.concat extraer de documentos(docs, preparado[Nombres de campos], document_class: klass)
    end
  end
end

#reset ⇒ false

Restablece el elemento enumerable a su estado persistente.

Ejemplos:

Restablece el enumerable.

enumerable.reset

Devuelve:

  • (false) —

    Siempre falso.



418
419
420
421
422
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 418

def restablecer
  _loaded.borrar
  _agregado.borrar
  @executed = false
end

#reset_unloaded(criteria) ⇒ Objeto

Reinicia el objeto subyacente de criterios descargados con uno nuevo. Usé mis asociaciones HABTM para mantener el arreglo subyacente sincronizado.

Ejemplos:

Restablecer los documentos descargados.

enumerable.reset_unloaded(criteria)

Parámetros:

  • criterios (Criterios) —

    El criterio a reemplazar.



431
432
433
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 431

def restablecer_descargado(criterios)
  @_unloaded = criterios si descargado.is_a?(Criterios)
end

#respond_to?(nombre, include_private = false) ⇒ true | false

¿Este enumerable responde al método proporcionado?

Ejemplos:

¿El enumerable responde al método?

enumerable.respond_to?(:sum)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del método.

  • incluir_privada (true | false) (por defecto: false) —

    Si incluir métodos privados.

Devuelve:

  • (true | false) —

    Ya sea que el enumerable responda.



445
446
447
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 445

def respond_to?(Nombre, incluir_privada = false)
  [].respond_to?(Nombre, incluir_privada) || super
end

#size ⇒ Integer También conocido como: longitud

Obtiene el tamaño total de este enumerable. Esta es una combinación de todos los documentos persistidos y no persistidos.

Ejemplos:

Obtén el tamaño.

enumerable.size

Devuelve:

  • (Número entero) —

    El tamaño del enumerable.



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
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 456

def Tamaño
  # Si _unloaded está presente, coincidirá con el conjunto de documentos
  # que pertenecen a esta asociación, que ya han sido almacenados de forma persistente
  # a la base de datos. Este conjunto de documentos debe ser considerado cuando
  # calculando el tamaño de la asociación, junto con cualquier cosa que tenga
  # se agregó desde entonces.
  si descargado
    si _agregado.any?
      # Ten en cuenta que _added puede incluir registros que _unloaded ya
      # coincidencias. Este es el caso si a la asociación se le asigna un arreglo
      # de elementos y algunos ya formaban parte de la asociación.
      #
      # por lo tanto, tenemos que asegurarnos de que _unloaded.count excluya cualquier elemento
      # que ya existen en _added.

      count = descargado.no(::_id.in => _agregado.values.map(&:id)).count
      count + _agregado.values.count
    else
      descargado.count
    end

  else
    _loaded.count + _agregado.count
  end
end

#suma(campo = nil) ⇒ Numérico

Obtenga la suma del campo proporcionado para todos los documentos en el enumerable. Cuando se carga la asociación, se computa en memoria sin consultar la base de datos.

Ejemplos:

Obtenga la suma de un campo.

enumerable.sum(:likes)

Parámetros:

  • Campo (Símbolo) (valor por defecto: nil) —

    El campo a sumar.

Devuelve:

  • (Numérico) —

    El valor total.



518
519
520
521
522
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 518

def suma(Campo = nulo)
  return super(Campo || 0) si ¿block_given?

  valores_campo_para(Campo).suma || 0
end

#to_json(options = {}) ⇒ String

Envía #to_json a las entradas.

Ejemplos:

Obtener el enumerable como json.

enumerable.to_json

Parámetros:

  • opciones (encriptada) (por defecto: {}) —

    Parámetros opcionales.

Devuelve:

  • (string) —

    Todas las entradas _cargadas como una string.



492
493
494
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 492

def to_json(opciones = {})
  entradas.to_json(opciones)
end

#uniq ⇒ Array<Document>

Nota:

Esta operación carga todos los documentos de la base de datos.

Devuelve todos los documentos únicos en lo enumerable.

Ejemplos:

Obtén todos los documentos únicos.

enumerable.uniq

Devuelve:

  • (Array<documento>) —

    Los documentos únicos.



581
582
583
 
# Archivo 'lib/mongoid/association/referenced/has_many/enumerable.rb', línea 581

def uniq
  entradas.uniq
end