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

Hereda:
Muchos
  • Objeto
Mostrar todo
Ampliado por:
Reenviable, métodos de clase
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 asociación en el documento en cuestión. 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 de la colección del lado opuesto que debe cargarse.

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

eager_loader, ¿incrustado?

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, destino, asociación) ⇒ Proxy

Crea una nueva asociación references_many. Establece la clave externa 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, destino, asociación)
  enum = Tiene muchos::Enumerable.Nuevo(destino, base, asociación)
  Super(base, enum, asociación) hacer
    aumento_mixto Si klass.¿incorporado? && !klass.¿cíclico?
  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.



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

ruby2_keywords def método_faltante(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) ⇒ Array 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.posts << post

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

  • (Matriz) —

    Los documentos cargados.



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.aplanar
  return concat(docs) Si docs.tamaño > 1

  Si (doc = docs.primera)
    añadir(doc)
    doc.guardar Si ¿persistente? && !¿_asignando? && !doc.¿validado?
  end
  yo
end

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

Construir un nuevo documento sobre la asociación.

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

Parámetros:

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

    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 construir(atributos = {}, tipo = nulo)
  Fábrica.ejecutar_construcción(tipo || 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 }
  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 (Matriz) —

    Los documentos para agregar.

Devuelve:

  • (Matriz) —

    Los documentos.



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 no ser que doc

    añadir(doc)
    guardar_o_retrasar(doc, docs, inserts) Si ¿persistente?
  end

  persist_retrasado(docs, inserts)
  yo
end

#eliminar(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 a eliminar.

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)
  ejecutar_devoluciones_de_llamadas_alrededor(:eliminar, Documento) hacer
    resultado = _objetivo.borrar(Documento) hacer |doc|
      Si doc
        unbind_one(doc)
        cascade!(doc) a no ser que ¿_asignando?
      end
    end

    resultado.grifo { reinicio_descargado }
  end
end

#delete_all(condiciones = nulas) ⇒ Entero

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

Ejemplos:

Eliminar todos los documentos de 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 para eliminar con.

Devuelve:

  • (Entero) —

    El número de documentos borrados.



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

def eliminar_todo(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

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

  • (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

#cada(&bloque) ⇒ Matriz

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:

  • (Matriz) —

    Los documentos cargados.



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

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

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 solo en la aplicación, es decir, no se han conservado 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:

¿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 hay alguna coincidencia. Cualquier otro argumento se interpreta como un id y se consulta la existencia de documentos en la asociación con un _id coincidente.

Devuelve:

  • (verdadero | falso) —

    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_o_condiciones = :ninguno)
  criterios.¿Existe?(id_o_condiciones)
end

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

Nota:

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

Nota:

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

Encuentra el documento coincidente de la asociación, ya sea por identificación o por condiciones.

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 por un id.

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

Buscar por múltiples identificaciones.

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

    Los id.

  • &bloquear —

    Bloque opcional para pasar.

Rendimientos:

  • (Objeto) -

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

Anular 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(clave externa => nulo)
  _objetivo.borrar hacer |doc|
    unbind_one(doc)
    doc.atributos cambiados.borrar(clave externa)
  end
end

#purgar ⇒ Muchos También conocido como: limpiar

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

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 no ser que _asociación.¿destructivo?

  después de eliminar el error = nulo
  criterios.eliminar_todo
  muchos = _objetivo.borrar hacer |doc|
    ejecutar_devolución de llamada :antes_de_eliminar, doc
    unbind_one(doc)
    doc.destruido = true
    begin
      ejecutar_devolución de llamada :después de eliminar, doc
    rescate Error estándar => 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

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

    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(clave externa) != _base.Enviar(_asociación.clave_primaria)
    end
    concat(docs)
  else
    purga
  end
  yo
end

#sin ámbito ⇒ Criterios

Obtenga un criterio para los documentos sin el alcance predeterminado aplicado.

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.donde(clave externa => _base.Enviar(_asociación.clave_primaria))
end