Clase: Mongoid::Association::Referenced::HasMany::Proxy

Hereda:
Muchos Mostrar todo
Ampliado por:
Transferible, ClassMethods
Definido en:
lib/mongoid/asociación/referenciado/tiene_muchos/proxy.rb

Overview

Proxy transparente para asociaciones has_many. Se devuelve una instancia de esta clase al llamar al método getter de asociacitación en el documento del asunto. Esta clase hereda de Mongoid::Association::Proxy y reenvía la mayoría de sus métodos al objetivo de la asociación, es decir, al arreglo de documentos en la colección opuesta que debe ser cargada.

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?

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

#inicializar(base, destino, asociación) ⇒ Proxy

Instanciar una nueva asociación references_many. Establecerá la clave foránea y la base en el objeto inverso.

Ejemplos:

Crear la nueva asociación.

Referenced::Many.new(base, target, association)

Parámetros:



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

def inicializar(base, Objetivo, asociación)
  enum = Tiene muchos::Enumerable.Nuevo(Objetivo, base, asociación)
  super(base, enum, asociación) hacer
    raise_mixed si klass.¿Incorporado? && !klass.¿cíclico?
  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.



465
466
467
468
469
470
471
472
473
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 465

ruby2_keywords def method_missing(Nombre, *args, Ybloque)
  si _objetivo.respond_to?(Nombre)
    _objetivo.enviar(Nombre, *args, Ybloque)
  else
    klass.enviar(con: alcance, criterios) hacer
      criterios.public_send(Nombre, *args, Ybloque)
    end
  end
end

Detalles del método de instancia

#<<(*args) ⇒ arreglo<documento> 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.posts << post

Sube un documento.

person.posts.push(post)

Concatenar con otros documentos.

person.posts.concat([ post_one, post_two ])

Parámetros:

  • *argumentos (documento...) —

    Cualquier número de documentos.

Devuelve:



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

def <<(*args)
  docs = args.nivelar
  return concat(docs) si docs.tamaño > 1

  si (doc = docs.primero)
    adjuntar(doc)
    doc.guardar si ¿persistente? && !¿_asignando? && !doc.¿validado?
  end
  sí mismo
end

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

Cree un nuevo documento a partir de los atributos y añádalo a esta asociación sin guardarlo.

Ejemplos:

Elabora un nuevo documento sobre la asociación.

person.posts.build(:title => "A new post")

Parámetros:

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

    Los atributos del nuevo documento.

  • tipo (Clase) (predeterminado: nulo) —

    La subclase opcional a construir.

Devuelve:



115
116
117
118
119
120
121
122
123
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 115

def compilar(atributos = {}, tipo = nulo)
  Fábrica.execute_build(tipo || 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 }
  end
end

#concat(documents) ⇒ 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.posts.concat([ post_one, post_two ])

Parámetros:

  • Documentos (Array<documento>) —

    Los documentos para agregar.

Devuelve:



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

def concat(Documentos)
  docs, inserts = [], []
  Documentos.cada hacer |doc|
    siguiente a menos que doc

    adjuntar(doc)
    guardar_o_retrasar(doc, docs, inserts) si ¿persistente?
  end

  persist_delayed(docs, inserts)
  sí mismo
end

#borrar(documento) ⇒ Documento También conocido como: delete_one

Borra el documento de la asociación. Esto establecerá la clave externa del documento en nil. Si las opciones dependientes de la asociación son :delete_all o :destroy, se realizará la eliminación correspondiente.

Ejemplos:

Eliminar el documento.

person.posts.delete(post)

Parámetros:

  • Documento (documento) —

    El documento que se va a remover.

Devuelve:

  • (documento) —

    El documento correspondiente.



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

def borrar(Documento)
  execute_callbacks_around(remover, Documento) hacer
    Resultado = _objetivo.borrar(Documento) hacer |doc|
      si doc
        unbind_one(doc)
        cascade!(doc) a menos que ¿_asignando?
      end
    end

    Resultado.tocar { reinicio_descargado }
  end
end

#delete_all(condiciones = nil) ⇒ Integer

Elimina todos los documentos relacionados de la base de datos dadas las condiciones suministradas.

Ejemplos:

Borrar todos los documentos en la asociación.

person.posts.delete_all

Eliminar condicionalmente todos los documentos de la asociación.

person.posts.delete_all({ :title => "Testing" })

Parámetros:

  • condiciones (Hash) (predeterminado: nulo) —

    Condiciones opcionales con las que borrar.

Devuelve:

  • (Número entero) —

    El número de documentos borrados.



166
167
168
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 166

def delete_all(condiciones = nulo)
  eliminar_todo(condiciones, :borrar_todo)
end

#destroy_all(conditions = nil) ⇒ Integer

Destruye todos los documentos relacionados de la base de datos dadas las condiciones proporcionadas.

Ejemplos:

Destruir todos los documentos de la asociación.

person.posts.destroy_all

Destruye condicionalmente todos los documentos de la asociación.

person.posts.destroy_all({ :title => "Testing" })

Parámetros:

  • condiciones (Hash) (predeterminado: nulo) —

    Condiciones opcionales para destruir con.

Devuelve:

  • (Número entero) —

    El número de documentos destruidos.



182
183
184
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 182

def destruir_todo(condiciones = nulo)
  eliminar_todo(condiciones, destruir_todo)
end

#each(&block) ⇒ arreglo<Documento>

Nota:

Esto cargará toda la asociación en la memoria.

Iterar sobre cada documento en la asociación y ceder el paso al bloque proporcionado.

Ejemplos:

Iterar sobre los documentos.

person.posts.each do |post|
  post.save
end

Devuelve:



197
198
199
200
201
202
203
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 197

def cada(Ybloque)
  si bloque
    _objetivo.cada(Ybloque)
  else
    to_enum
  end
end

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

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

Si la asociación contiene documentos, pero todos los documentos existen solamente en la aplicación, es decir, no se han guardado en la base de datos, este método devuelve falso.

Este método consulta la base de datos en cada invocación incluso si la asociación ya está cargada en la memoria.

Ejemplos:

¿Hay documentos persistentes?

person.posts.exists?

Parámetros:

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

    Cuando :none (por defecto), devuelve true si existen documentos persistentes en la asociación. Cuando sea nil o false, esto siempre regresará false. Cuando se proporciona un Hash, este query los documentos en la asociación que coinciden con las condiciones dadas y devuelve true si hay alguna coincidencia. Cualquier otro argumento se interpreta como un id, y realiza consultas para la existencia de documentos en la asociación con un _id coincidente.

Devuelve:

  • (true | false) —

    Verdadero si existen documentos persistentes, falso si no.



227
228
229
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 227

def ¿existe?(id_or_conditions = :ninguno)
  criterios.¿existe?(id_or_conditions)
end

#find(*args) {|Object| ... } ⇒ Document | Array<Document> | nil

Nota:

Cada argumento puede ser un ID individual, un arreglo de IDs o un arreglo anidado. Cada arreglo se aplanará.

Nota:

Esto mantendrá los documentos coincidentes en memoria para iteraciones posteriores.

Encontrar el documento que coincida en la asociación, ya sea en función del id o de las condiciones.

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:

Buscar por un id.

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

Buscar por múltiples identificaciones.

person.posts.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 | arreglo<Object> ]...) —

    Los id.

  • &bloque —

    Bloque opcional para pasar.

Rendimientos:

  • (objeto) —

    Cede cada elemento enumerable al bloque.

Devuelve:

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

    Un documento o documentos coincidentes.



262
263
264
265
266
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 262

def buscar(*args, Ybloque)
  coincidencia = criterios.buscar(*args, Ybloque)
  Arreglo(coincidencia).cada { |doc| _objetivo.push(doc) }
  coincidencia
end

#nullify ⇒ objeto También conocido como: nullify_all

Elimina todas las asociaciones entre el documento base y los documentos de destino eliminando las claves externas y las referencias, dejando huérfanos los documentos de destino en el proceso.

Ejemplos:

Anule la asociación.

person.posts.nullify


274
275
276
277
278
279
280
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 274

def anular
  criterios.update_all(foreign_key => nulo)
  _objetivo.borrar hacer |doc|
    unbind_one(doc)
    doc.atributos_cambiados.borrar(foreign_key)
  end
end

#purgar ⇒ Muchos También conocido como: limpiar

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

Ejemplos:

Limpiar la asociación.

person.posts.clear

Devuelve:

  • (Muchos) -

    La asociación se vació.



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 291

def purga
  return anular a menos que _association.¿destructivo?

  después de eliminar el error = nulo
  criterios.delete_all
  muchos = _objetivo.borrar hacer |doc|
    execute_callback :before_remove, doc
    unbind_one(doc)
    doc.destruido = true
    begin
      execute_callback Después de quitar, doc
    rescate StandardError => e
      después de eliminar el error = e
    end
  end

  propagar después de eliminar el error si después de eliminar el error

  muchos
end

#substitute(reemplazo) ⇒ Muchos

Sustituye los documentos de destino proporcionados por los documentos existentes en la asociación. Si el nuevo destino es nulo, realiza la eliminación necesaria.

Ejemplos:

Reemplazar la asociación.

person.posts.substitute([ new_post ])

Parámetros:

  • sustitución (Array<documento>) —

    El objetivo de reemplazo.

Devuelve:



324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 324

def sustituir(sustitución)
  si sustitución
    new_docs, docs = sustitución.compact, []
    nuevos_ids = new_docs.map(Y:_identificación)
    eliminar_no_en(nuevos_ids)
    new_docs.cada hacer |doc|
      docs.push(doc) si doc.enviar(foreign_key) != _base.enviar(_association.clave_primaria)
    end
    concat(docs)
  else
    purga
  end
  sí mismo
end

#sin ámbito ⇒ Criterios

Obtén un criterio para los documentos sin la aplicación del alcance por defecto.

Ejemplos:

Obtener los criterios no acotados.

person.posts.unscoped

Devuelve:



346
347
348
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 346

def sin alcance
  klass.sin alcance.dónde(foreign_key => _base.enviar(_association.clave_primaria))
end