Clase: Mongoid::Asociación::Incrustado::IncrustadosMuchos::Proxy

Hereda:
Muchos
  • Objeto
Mostrar todo
Ampliado por:
Métodos de clase
Incluye:
Procesable por lotes
Definido en:
lib/mongoid/asociación/incrustado/incrustaciones_muchas/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, el array de documentos hijos.

Definido en el espacio de nombres

Modules: Métodos de clase

Resumen constante

Constantes heredadas de Proxy

Proxy::MÉTODOS_KEEPER

Resumen de atributos de instancia

Atributos heredados de Proxy

#_association, #_base, #_target

Colapso del resumen del método de instancia

Métodos incluidos de ClassMethods

cargador ansioso, ¿incrustado?, sufijo de clave externa

Métodos incluidos en Batchable

#borrar_lote, #insertar_lote, #eliminar_lote, #reemplazar_lote

Métodos incluidos de Posicional

#posicionalmente

Métodos heredados de Many

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

#inicializar(base, objetivo, asociación) ⇒ Muchos

Crear 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, destino, asociación)
  Super hacer
    _objetivo.cada_con_índice hacer |doc, index|
      integrar(doc)
      doc._index = index
    end
    update_attributes_hash
    @_unscoped = _objetivo.dup
    @_objetivo = ámbito de aplicación(_objetivo)
  end
end

Manejo de métodos dinámicos

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: asegurarnos de que estemos usando consistentemente respond_to_missing

anywhere we define method_missing.

rubocop:deshabilitar Estilo/Respuesta faltante a faltante

Parámetros:

  • Nombre (Símbolo| Cadena) —

    El nombre del método.

  • *argumentos (Objeto...) -

    El método args.

  • &bloquear —

    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 método_faltante(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

Añade un documento o una matriz de documentos a la asociación. Establece el documento principal y actualiza el índice en el proceso.

Ejemplos:

Anexar un documento.

person.addresses << address

Empujar 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.aplanar
  return a no ser que docs.any?
  return concat(docs) Si docs.tamaño > 1

  docs.primera.grifo hacer |doc|
    añadir(doc)
    doc.guardar Si ¿persistente? && !¿_asignando?
  end

  yo
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 eliminar.



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

def _remove(Documento)
  _objetivo.delete_one(Documento)
  _sin ámbito.delete_one(Documento)
  update_attributes_hash
  reindex
end

#as_document ⇒ Matriz<Hash>

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

  • (Matriz<Hash>) —

    La asociación tal como está almacenada en la base de datos.



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

def como_documento
  como_atributos.collect { |attrs| BSON::Documento.Nuevo(attrs) }
end

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

Construir un nuevo documento sobre la asociación.

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

Parámetros:

  • atributos (Hash) (predeterminado: {}) —

    Los atributos con los que compilar el documento.

  • tipo (Clase) (predeterminado: nulo) —

    Clase opcional para construir 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 construir(atributos = {}, tipo = nulo)
  Fábrica.ejecutar_construcción(tipo || _asociación.klass, atributos, ejecutar_devoluciones de llamada: false).grifo hacer |doc|
    añadir(doc)
    doc.aplicar_valores_predeterminados_post_procesados
    rendimiento doc Si ¿bloque_dado?
    doc.ejecutar devoluciones de llamadas pendientes
    doc.ejecutar_devoluciones de llamadas(:construir) { doc }
    _base._reset_memoized_descendants!
  end
end

#claro ⇒ yo mismo

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

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
  yo
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 (Matriz) —

    Los documentos para agregar.

Devuelve:

  • (Matriz) —

    Los documentos.



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

def concat(docs)
  batch_insert(docs) a no ser que docs.¿vacío?
  yo
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.

Utilice #size si desea el número total de documentos.

Si hay argumentos o bloques presentes, #count delegará al método #count en target e incluirá documentos tanto persistentes como no persistentes.

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" }

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

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

Parámetros:

  • *argumentos (Objeto...) -

    Argumentos a delegar al objetivo.

Devuelve:

  • (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:¿persistió?)
end

#eliminar(documento) ⇒ Documento | nil También conocido como: delete_one

Elimina el documento proporcionado del destino. Este método se utiliza como proxy para reindexar la matriz después de la operación.

Ejemplos:

Eliminar el documento de la asociación.

person.addresses.delete(address)

Parámetros:

  • Documento (Documento) -

    El documento que se va a 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)
  ejecutar_devoluciones_de_llamadas_alrededor(:eliminar, Documento) hacer
    _objetivo.delete_one(Documento).grifo hacer |doc|
      Si doc && !_¿vinculante?
        _sin ámbito.delete_one(doc)
        Si ¿_asignando?
          _base.añadir_pull_atómico(doc)
        else
          doc.borrar(reprimir: true)
          unbind_one(doc)
        end
        update_attributes_hash
      end
      reindex
    end
  end
end

#delete_all(condiciones = {}) ⇒ Entero

Eliminar todos los documentos de la asociación sin ejecutar devoluciones de llamadas.

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) (predeterminado: {}) —

    Condiciones sobre qué documentos eliminar.

Devuelve:

  • (Entero) —

    El número de documentos borrados.



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

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

#delete_if ⇒ EmbedsMany::Proxy | Enumerador

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 | Enumerador) —

    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 eliminar_si
  return Super a no ser que ¿bloque_dado?

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

  yo
end

#destroy_all(condiciones = {}) ⇒ Entero

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

Destruir condicionalmente los documentos de la asociación.

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

Parámetros:

  • condiciones (Hash) (predeterminado: {}) —

    Condiciones sobre los documentos a destruir.

Devuelve:

  • (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, :destruir)
end

#¿existe?(id_or_conditions =:none) ⇒ verdadero | falso

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

Ejemplos:

¿Existen documentos persistentes?

person.posts.exists?

Parámetros:

  • id_o_condiciones (:none | nil | false | Hash | objeto) (predeterminado::ninguno) —

    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:

  • (verdadero | falso) —

    Verdadero si existen documentos persistentes, falso si no.



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

def ¿Existe?(id_o_condiciones = :ninguno)
  caso id_o_condiciones
  Cuando :ninguno entonces _objetivo.any?(Y:¿persistió?)
  Cuando nulo, false entonces false
  Cuando Picadillo entonces donde(id_o_condiciones).any?(Y:¿persistió?)
  else donde(_id: id_o_condiciones).any?(Y:¿persistió?)
  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 no se le asigna un bloque, devuelve uno o varios documentos para los valores _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:

Buscar un documento por su id.

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

Buscar documentos para múltiples identificaciones.

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

Encuentra el primer documento coincidente utilizando un bloque.

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

Parámetros:

  • *argumentos (Objeto...) -

    Varios argumentos.

  • &bloquear —

    Bloque opcional para pasar.

Rendimientos:

  • (Objeto) -

    Devuelve 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

Extraer documentos de la asociación. Puede ser un solo documento o varios, y los cambios se conservarán automáticamente.

Ejemplos:

Abre un solo documento.

relation.pop

Hacer estallar varios documentos.

relation.pop(3)

Parámetros:

  • count (Entero) (predeterminado: nulo) —

    La cantidad de documentos a extraer, 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.última(count || 1).cada { |doc| borrar(doc) }
  (count.nil? || docs.¿vacío?) ? docs.primera : docs
end

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

Desplazar documentos fuera de la asociación. Puede tratarse de uno o varios documentos, y los cambios se conservarán automáticamente.

Ejemplos:

Mover un solo documento.

relation.shift

Mover 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 cambio(count = nulo)
  return [] Si count&.zero?

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

#sustituto(docs) ⇒ Muchos

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

Ejemplos:

Sustituir el objetivo de la asociación.

person.addresses.substitute([ address ])

Parámetros:

  • docs (Matriz | Matriz<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
  yo
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:

Obtenga los documentos sin alcance.

person.addresses.unscoped

Devuelve:



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.incrustado = true
  criterion.Documentos = _sin ámbito.eliminar_si(Y:marcado_para_la_destrucción?)
  criterion
end