Clase: Mongoid::Association::Embedded::EmbedsMany::Proxy

Hereda:
Muchos
  • Objeto
Mostrar todo
Ampliado por:
Transferible, ClassMethods
Incluye:
Agrupable
Definido en:
lib/mongoid/association/embedded/embeds_many/proxy.rb

Overview

Proxy transparente para asociaciones embeds_many. Se devuelve una instancia de esta clase al llamar al método getter de asociación en el documento padre. Esta clase hereda de Mongoid::Association::Proxy y reenvía la mayoría de sus métodos al destino de la asociación, es decir, al arreglo de documentos secundarios.

Definido bajo Namespace

Modules: ClassMethods

Resumen del método de instancia colapsar

Métodos incluidos de ClassMethods

eager_loader, embedded?, foreign_key_suffix

Métodos incluidos de Batchable

#batch_clear, #batch_insert, #batch_remove, #batch_replace

Métodos incluidos desde Positional

#posicionalmente

Métodos heredados de Muchos

#blank?, #cache_version, #create, #create!, #find_or_create_by, #find_or_create_by!, #find_or_initialize_by, #nil?, #respond_to?, #scoped, #serializable_hash

Detalles del Constructor

#initialize(base, target, association) ⇒ Muchos

Instancia una nueva asociación embeds_many.

Ejemplos:

Crear la nueva asociación.

Many.new(person, addresses, association)

Parámetros:



70
71
72
73
74
75
76
77
78
79
80
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 70

def inicializar(base, Objetivo, asociación)
  super hacer
    _target.each_with_index hacer |doc, index|
      integrar(doc)
      doc._index = index
    end
    update_attributes_hash
    @_unscoped = _target.dup
    @_objetivo = Alcance(_target)
  end
end

Gestión dinámica de métodos

Esta clase gestiona métodos dinámicos a través del método method_missing

#method_missing ⇒ Criterios | Objeto (privado)

Si el arreglo de destino no responde al método proporcionado, intenta encontrar un scope o criterio nombrado en la clase y envíar la llamada allí.

Si el método existe en el arreglo, utiliza el comportamiento proxy por defecto.

TODO: asegúrese de que estemos utilizando respond_to_missing de manera consistente en cualquier lugar donde definamos method_missing. rubocop:disable Style/MissingRespondToMissing

Parámetros:

  • Nombre (Symbol | string) —

    El nombre del método.

  • *args (objeto...) —

    Los argumentos del método.

  • &bloque —

    Bloque opcional para pasar.

Devuelve:

  • (Criterios | Objeto) —

    Un Criteria o valor de retorno del objetivo.



525
526
527
528
529
530
531
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 525

ruby2_keywords def method_missing(Nombre, *args, &bloque)
  return super si _target.respond_to?(Nombre)

  klass.enviar(con: alcance, criterios) hacer
    criterios.public_send(Nombre, *args, &bloque)
  end
end

Detalles del método de instancia

#<<(*args) ⇒ objeto También conocido como: push

Adjunta un documento o un arreglo de documentos a la asociación. Establecerá el elemento principal y actualizará el índice en el proceso.

Ejemplos:

Anexar un documento.

person.addresses << address

Sube un documento.

person.addresses.push(address)

Parámetros:

  • *args (documento...) —

    Cualquier cantidad de documentos.



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

def <<(*args)
  docs = args.nivelar
  return a menos que docs.any?
  return concat(docs) si docs.Tamaño > 1

  docs.primero.tocar hacer |doc|
    adjuntar(doc)
    doc.guardar si ¿persistente? && !¿_asignando?
  end

  sí mismo
end

#_remove(documento) ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Elimina un único document de la colección solo en la memoria. No persistirá el cambio.

Parámetros:

  • Documento (documento) —

    El documento a borrar.



239
240
241
242
243
244
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 239

def remover(Documento)
  _target.delete_one(Documento)
  _unscoped.delete_one(Documento)
  update_attributes_hash
  reindex
end

#as_document ⇒ Array<Hash>

Obtén esta asociación como su representación en la base de datos.

Ejemplos:

Convierta la asociación en un hash de atributos.

person.addresses.as_document

Devuelve:

  • (arreglo<Hash>) —

    La asociación tal como se almacena en la base de datos.



113
114
115
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 113

def as_document
  as_attributes.collect { |attrs| BSON::Documento.Nuevo(attrs) }
end

#compilar(atributos = {}, tipo = nil) ⇒ Documento También conocido como: nuevo

Compila un nuevo documento en la asociación y lo añade al destino. Acepta un tipo opcional si deseas especificar una subclase.

Ejemplos:

Elabora un nuevo documento sobre la asociación.

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

Parámetros:

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

    Los atributos con los que compilar el documento.

  • tipo (clase) (valor por defecto: nil) —

    Clase opcional para compilar el documento.

Devuelve:



141
142
143
144
145
146
147
148
149
150
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 141

def compilar(atributos = {}, tipo = nulo)
  Fábrica.execute_build(tipo || _association.klass, atributos, execute_callbacks: false).tocar hacer |doc|
    adjuntar(doc)
    doc.apply_post_processed_defaults
    rendimiento doc si ¿block_given?
    doc.ejecutar_llamadas_pendientes
    doc.run_callbacks(compilar) { doc }
    _base._reset_memoized_descendants!
  end
end

#limpiar ⇒ fuente

Borrar la asociación. Se borrarán los documentos de la base de datos si ya están guardados.

Si el documento host no se guarda, pero su _id coincide con un document guardado, al llamar a #clear en una asociación se removerán los documents de la asociación de la base de datos, aunque el conjunto de documents en la aplicación (tal como se carga en el host) sea diferente de lo que está en la base de datos, y el host tampoco pueda contener ningún document guardado en la asociación.

Ejemplos:

Despeje la asociación.

person.addresses.clear

Devuelve:

  • (self) —

    La asociación vacía.



168
169
170
171
172
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 168

def borrar
  batch_clear(_target.dup)
  update_attributes_hash
  sí mismo
end

#concat(docs) ⇒ Array<Document>

Anexa un arreglo de documentos a la asociación. Realiza una inserción por lotes de los documentos en lugar de guardar uno a la vez.

Ejemplos:

Concatenar con otros documentos.

person.addresses.concat([ address_one, address_two ])

Parámetros:

  • docs (Array<documento>) —

    Los Docs que añadir.

Devuelve:



126
127
128
129
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 126

def concat(docs)
  batch_insert(docs) a menos que docs.¿vacío?
  sí mismo
end

#count(*args, &block) ⇒ Integer

Devuelve un recuento del número de documentos en la asociación que realmente han sido almacenados en la base de datos.

Utiliza #size si quieres el número total de documentos.

Si hay argumentos o un bloque presentes, #count delegará en el método #count de target y se incluirán tanto los documentos que han sido guardados como los que no lo han sido.

Ejemplos:

Obtén el recuento de documentos almacenados.

person.addresses.count

Obtenga el recuento de todos los documentos que coincidan con un bloque.

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

Usa #persisted? dentro del bloque para contar los documentos persistidos.

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

Parámetros:

  • *args (objeto...) —

    Argumentos para delegar al destino.

Devuelve:

  • (Número entero) —

    El número total de Docs embebidos persistentes, según lo señalado por el indicador #persisted? método.



196
197
198
199
200
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 196

def count(*args, &bloque)
  return _target.count(*args, &bloque) si args.any? || bloque

  _target.count(&:¿persistente?)
end

#borrar(document) ⇒ Documento | nil También conocido como: delete_one

Borrar el documento proporcionado del destino. Este método se utiliza para volver a indexar el arreglo después de que ocurra la operación.

Ejemplos:

Borre el documento de la asociación.

person.addresses.delete(address)

Parámetros:

  • Documento (documento) —

    El documento que se eliminará.

Devuelve:

  • (Document | nil) —

    El documento eliminado o nil si no se eliminó nada.



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

def borrar(Documento)
  execute_callbacks_around(remover, Documento) hacer
    _target.delete_one(Documento).tocar hacer |doc|
      si doc && !¿_binding?
        _unscoped.delete_one(doc)
        si ¿_asignando?
          _base.add_atomic_pull(doc)
        else
          doc.borrar(suprimir: true)
          unbind_one(doc)
        end
        update_attributes_hash
      end
      reindex
    end
  end
end

#delete_all(condiciones = {}) ⇒ Integer

Eliminar todos los documentos en la asociación sin ejecutar callbacks.

Ejemplos:

Borrar todos los documentos de la asociación.

person.addresses.delete_all

Borrar condicionalmente documentos de la asociación.

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

Parámetros:

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

    Condiciones sobre las cuales borrar documentos.

Devuelve:

  • (Número entero) —

    El número de documentos borrados.



257
258
259
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 257

def delete_all(condiciones = {})
  eliminar_todo(condiciones, borrar)
end

#delete_if ⇒ EmbedsMany::Proxy | Enumerator

Borra todos los documentos para los que el bloque proporcionado devuelve verdadero.

Ejemplos:

Borre los documentos que coincidan.

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

Devuelve:

  • (EmbedsMany::Proxy | Enumerator) —

    El proxy o un enumerador si no se proporcionó un bloque.



270
271
272
273
274
275
276
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 270

def delete_if
  return super a menos que ¿block_given?

  _target.dup.cada { |doc| borrar(doc) si rendimiento doc }

  sí mismo
end

#destroy_all(conditions = {}) ⇒ Integer

Destruye todos los documentos de la asociación al ejecutar devoluciones de llamada.

Ejemplos:

Destruye todos los documentos de la asociación.

person.addresses.destroy_all

Destruye condicionalmente los documentos de la asociación.

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

Parámetros:

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

    Condiciones sobre los documentos a destruir.

Devuelve:

  • (Número entero) —

    El número de documentos destruidos.



289
290
291
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 289

def destruir_todo(condiciones = {})
  eliminar_todo(condiciones, :destroy)
end

#¿exists?(id_or_conditions = :none) ⇒ true | false

Determinar si existe algún documento de esta asociación en la base de datos.

Ejemplos:

¿Hay documentos persistentes?

person.posts.exists?

Parámetros:

  • id_or_conditions (:none | nil | false | Hash | objeto) (por defecto: :none) —

    Cuando es :none (el valor por defecto), devuelve verdadero si existe algún documento persistente en la asociación. Cuando sea nulo o falso, esto siempre devolverá falso. Cuando se proporciona un hash, este query los documentos en la asociación para aquellos que cumplan las condiciones dadas y devuelve verdadero si existe alguna coincidencia que se haya persistido. Cualquier otro argumento se interpreta como un ID, y se query la existencia de documentos persistentes en la asociación con un _id coincidente.

Devuelve:

  • (true | false) —

    Verdadero si existen documentos persistentes, falso si no existen.



309
310
311
312
313
314
315
316
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 309

def ¿existe?(id_or_conditions = none)
  caso id_or_conditions
  cuando none entonces _target.any?(&:¿persistente?)
  cuando nulo, false entonces false
  cuando encriptada entonces dónde(id_or_conditions).any?(&:¿persistente?)
  else dónde(_id: id_or_conditions).any?(&:¿persistente?)
  end
end

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

Extraiga documentos de la asociación. Esto puede ser un solo documento o varios, y se guardarán automáticamente los cambios.

Ejemplos:

Desencolar un solo documento.

relation.pop

Abrir múltiples documentos.

relation.pop(3)

Parámetros:

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

    El número de documentos a retirar, o 1 si no se proporciona.

Devuelve:



339
340
341
342
343
344
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 339

def pop(count = nulo)
  return [] si count&.zero?

  docs = _target.último(count || 1).cada { |doc| borrar(doc) }
  (count.nil? || docs.¿vacío?) ? docs.primero : docs
end

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

Desplaza los documentos fuera de la asociación. Esto puede ser un solo documento o varios, y se guardarán automáticamente los cambios.

Ejemplos:

Cambiar un único documento.

relation.shift

Cambie varios documentos.

relation.shift(3)

Parámetros:

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

    El número de documentos a desplazar, o 1 si no se proporciona.

Devuelve:



359
360
361
362
363
364
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 359

def turno(count = nulo)
  return [] si count&.zero?

  docs = _target.primero(count || 1).cada { |doc| borrar(doc) }
  (count.nil? || docs.¿vacío?) ? docs.primero : docs
end

#substitute(docs) ⇒ Many

Sustituye los documentos de destino proporcionados por los documentos existentes en la relación.

Ejemplos:

Sustituya el objetivo de la asociación.

person.addresses.substitute([ address ])

Parámetros:

  • docs (arreglo<Documento> | arreglo<Hash>) —

    Los docs de reemplazo.

Devuelve:

  • (Muchos) —

    La asociación proxy.



375
376
377
378
379
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 375

def sustituir(docs)
  reemplazo por lotes(docs)
  update_attributes_hash
  sí mismo
end

#sin ámbito ⇒ Criterios

Devuelve la asociación eliminando todo el alcance anterior. Esta es la representación exacta de los Docs en la base de datos.

Ejemplos:

Obtener los documentos sin ámbito.

person.addresses.unscoped

Devuelve:

  • (Criterios) —

    La asociación no delimitada.



388
389
390
391
392
393
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 388

def sin ámbito
  criterion = klass.sin ámbito
  criterion.integrado = true
  criterion.Documentos = _unscoped.delete_if(&:marked_for_destruction?)
  criterion
end