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

Hereda:
Muchos
  • Objeto
Mostrar todo
Ampliado por:
ClassMethods
Incluye:
Procesable por lotes
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 constante

Constantes heredadas de Proxy

Proxy::KEEPER_METHODS

Resumen del atributo de la instancia

Atributos heredados de Proxy

#_association, #_base, #_target

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

#¿en blanco?, #crear, #¡crear!, #buscar_o_crear_por, #¡buscar_o_crear_por!, #buscar_o_inicializar_por, #¿nulo?, #¿responder_a?, #con ámbito, #hash_serializable

Métodos heredados de Proxy

apply_ordering, #extend_proxies, #klass, #reset_unloaded, #substitutable

Métodos incluidos de Marshalable

#marshal_dump, #marshal_load

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:



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

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

Gestión dinámica de métodos

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

#método_faltante ⇒ Criterios | Objeto (privado)

Si la matriz de destino no responde al método proporcionado, intente encontrar un ámbito o criterio con nombre en la clase y envíe la llamada allí.

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

TODO: Asegúrate de que estamos usando respond_to_missing de manera consistente.

anywhere we define method_missing.

rubocop:disable Style/MissingRespondToMissing

Parámetros:

  • Nombre (Symbol | string) —

    El nombre del método.

  • *argumentos (objeto...) —

    Los argumentos del método.

  • &bloque —

    Bloque opcional para pasar.

Devuelve:

  • (Criterios | Objeto) —

    Un Criteria o valor de retorno del objetivo.



551
552
553
554
555
556
557
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 551

ruby2_keywords def method_missing(Nombre, *args, Ybloque)
  return super si _objetivo.respond_to?(Nombre)

  klass.enviar(con: alcance, criterios) hacer
    criterios.public_send(Nombre, *args, Ybloque)
  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:

  • *argumentos (documento...) —

    Cualquier número de documentos.



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

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 forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Elimina un solo documento de la colección *solo en memoria*.No conservará el cambio.

Parámetros:

  • Documento (documento) —

    El documento a borrar.



236
237
238
239
240
241
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 236

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

#as_document ⇒ Matriz<Hash>

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

Ejemplos:

Convierte 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.



110
111
112
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 110

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 (Hash) (por defecto: {}) —

    Los atributos con los que compilar el documento.

  • tipo (Clase) (predeterminado: nulo) —

    Clase opcional para compilar el documento.

Devuelve:



138
139
140
141
142
143
144
145
146
147
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 138

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

#claro ⇒ yo mismo

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 conserva pero su _id coincide con un documento conservado, llamar a #clear en una asociación eliminará los documentos de la asociación de la base de datos, incluso aunque el conjunto de documentos 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 puede no contener ningún documento conservado en la asociación.

Ejemplos:

Limpiar la asociación.

person.addresses.clear

Devuelve:

  • (ser) -

    La asociación vacía.



165
166
167
168
169
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 165

def borrar
  limpieza por lotes(_objetivo.dup)
  update_attributes_hash
  sí mismo
end

#concat(docs) ⇒ Array<Document>

Añade una matriz de documentos a la asociación. Realiza una inserción por lotes de los documentos en lugar de conservarlos uno a uno.

Ejemplos:

Concatenar con otros documentos.

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

Parámetros:

  • docs (Array<documento>) —

    Los documentos para agregar.

Devuelve:



123
124
125
126
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 123

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

#count(*args, &block) ⇒ Integer

Devuelve un recuento de la cantidad de documentos de la asociación que realmente se han conservado 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:

Obtenga el recuento de documentos persistentes.

person.addresses.count

Obtenga el recuento de todos los documentos que coinciden 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:

  • *argumentos (objeto...) —

    Argumentos para delegar al destino.

Devuelve:

  • (Número entero) —

    El número total de documentos incrustados persistentes, según lo marcado por el método #persisted?.



193
194
195
196
197
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 193

def count(*args, Ybloque)
  return _objetivo.count(*args, Ybloque) si args.any? || bloque

  _objetivo.count(Y:¿persistente?)
end

#eliminar(documento) ⇒ 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.



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

def borrar(Documento)
  execute_callbacks_around(remover, Documento) hacer
    _objetivo.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:

Eliminar todos los documentos de la asociación.

person.addresses.delete_all

Eliminar condicionalmente documentos de la asociación.

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

Parámetros:

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

    Condiciones sobre las cuales borrar documentos.

Devuelve:

  • (Número entero) —

    El número de documentos borrados.



254
255
256
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 254

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:

Eliminar los documentos coincidentes.

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

Devuelve:

  • (EmbedsMany::Proxy | Enumerator) —

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



267
268
269
270
271
272
273
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 267

def delete_if
  return super a menos que ¿block_given?

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

  sí mismo
end

#destroy_all(conditions = {}) ⇒ Integer

Destruye todos los documentos de la asociación mientras se ejecutan devoluciones de llamadas.

Ejemplos:

Destruir 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 (Hash) (por defecto: {}) —

    Condiciones sobre los documentos a destruir.

Devuelve:

  • (Número entero) —

    El número de documentos destruidos.



286
287
288
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 286

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 :none (predeterminado), devuelve verdadero si existen documentos persistentes en la asociación. Cuando es nulo o falso, siempre devuelve falso. Al proporcionar un hash, se consultan los documentos de la asociación para encontrar aquellos que cumplan las condiciones dadas y devuelve verdadero si se ha persistido alguna coincidencia. Cualquier otro argumento se interpreta como un id y se consulta 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.



306
307
308
309
310
311
312
313
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 306

def ¿existe?(id_or_conditions = :ninguno)
  caso id_or_conditions
  Cuando :ninguno entonces _objetivo.any?(Y:¿persistente?)
  Cuando nulo, false entonces false
  Cuando Picadillo entonces dónde(id_or_conditions).any?(Y:¿persistente?)
  else dónde(_id: id_or_conditions).any?(Y:¿persistente?)
  end
end

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

Encuentra un documento en esta asociación a través de varios métodos diferentes.

Este método delega en Mongoid::Criteria#find. Si este método no recibe un bloque, devuelve uno o varios documentos para los valores de _id proporcionados.

Si se le asigna un bloque a este método, devuelve el primer documento de los encontrados por el objeto Criteria actual para el cual el bloque devuelve un valor verdadero.

Ejemplos:

Encuentra un documento por su id.

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

Buscar documentos para múltiples IDs.

person.addresses.find([ BSON::ObjectId.new, BSON::ObjectId.new ])

Busca el primer documento coincidente utilizando un bloque.

person.addresses.find { |addr| addr.state == 'CA' }

Parámetros:

  • *argumentos (objeto...) —

    Varios argumentos.

  • &bloque —

    Bloque opcional para pasar.

Rendimientos:

  • (objeto) —

    Cede cada elemento enumerable al bloque.

Devuelve:

  • (Document | Array<Document> | nil) —

    Un documento o documentos coincidentes.



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

def buscar(...)
  criterios.buscar(...)
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:

Abre un solo documento.

relation.pop

Hacer estallar varios documentos.

relation.pop(3)

Parámetros:

  • count (Entero) (predeterminado: nulo) —

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

Devuelve:



365
366
367
368
369
370
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 365

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

  docs = _objetivo.ú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 (Entero) (predeterminado: nulo) —

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

Devuelve:



385
386
387
388
389
390
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 385

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

  docs = _objetivo.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:

Sustituir 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 apoderada.



401
402
403
404
405
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 401

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

#sin ámbito ⇒ Criterios

Devuelve la asociación con todo el alcance anterior eliminado. Esta es la representación exacta de la documentación en la base de datos.

Ejemplos:

Obtener los documentos sin ámbito.

person.addresses.unscoped

Devuelve:

  • (Criterios) —

    La asociación no delimitada.



414
415
416
417
418
419
 
# Archivo 'lib/mongoid/association/embedded/embeds_many/proxy.rb', línea 414

def sin alcance
  criterion = klass.sin alcance
  criterion.integrado = true
  criterion.Documentos = _unscoped.delete_if(Y:marked_for_destruction?)
  criterion
end