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

Hereda:
Muchos
  • Objeto
Mostrar todo
Ampliado por:
Transferible, ClassMethods
Definido en:
lib/mongoid/association/referenced/has_many/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 del método de instancia colapsar

Métodos incluidos de ClassMethods

eager_loader, embedded?

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) ⇒ 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 = HasMany::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 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.



485
486
487
488
489
490
491
492
493
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 485

ruby2_keywords def method_missing(Nombre, *args, &bloque)
  si _target.respond_to?(Nombre)
    _target.enviar(Nombre, *args, &bloque)
  else
    klass.enviar(con: alcance, criterios) hacer
      criterios.public_send(Nombre, *args, &bloque)
    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:

  • *args (documento...) —

    Cualquier cantidad 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 guardar.

Ejemplos:

Elabora un nuevo documento sobre la asociación.

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

Parámetros:

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

    Los atributos del nuevo documento.

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

    La subclase opcional para compilar.

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.apply_post_processed_defaults
    rendimiento doc si ¿block_given?
    doc.ejecutar_llamadas_pendientes
    doc.run_callbacks(compilar) { doc }
  end
end

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

Parámetros:

  • Documentos (Array<documento>) —

    Los Docs que añadir.

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|
    Next a menos que doc

    adjuntar(doc)
    ahorrar_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:

Borrar 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 = _target.borrar(Documento) hacer |doc|
      si doc
        unbind_one(doc)
        cascade!(doc) a menos que ¿_asignando?
      end
    end

    Resultado.tocar { restablecer_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 (encriptada) (valor por defecto: nil) —

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

Ejemplos:

Destruir todos los documentos en 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 (encriptada) (valor por defecto: nil) —

    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 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(&bloque)
  si bloque
    _target.cada(&bloque)
  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) —

    True si existen documentos almacenados, false si no existen.



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

def ¿existe?(id_or_conditions = none)
  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 proporciona 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)

Encontrar por múltiples identificadores.

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:

  • *args ([objeto | arreglo<Object> ]...) —

    Las identificaciones.

  • &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
267
268
269
270
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 262

def buscar(*args, &bloque)
  si ¿block_given? && args.¿vacío?
    detectar(&bloque)
  else
    coincidente = criterios.buscar(*args, &bloque)
    Arreglo(coincidente).cada { |doc| _target.push(doc) }
    coincidente
  end
end

#nullify ⇒ objeto También conocido como: nullify_all

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

Ejemplos:

Anule la asociación.

person.posts.nullify


278
279
280
281
282
283
284
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 278

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

#pluck(*fields) ⇒ Array | Array<Array>

Extrae los nombres de campos dados de los documentos en la asociación. Es seguro usarlo independientemente de si la asociación está cargada o no, y de si hay documentos no guardados en la asociación o no.

Ejemplos:

Extrae los títulos de todas las publicaciones.

person.posts.pluck(:title)

Parámetros:

  • *campo (Symbol...) —

    Los nombres de los campos a extraer.

Devuelve:

  • (Array | Array<Array>) —

    El arreglo de valores de campo. Si se proporcionan varios campos, se devuelve un arreglo de arreglos.



300
301
302
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 300

def pluck(*Campos)
  _target.pluck(*Campos)
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:

Despeje la asociación.

person.posts.clear

Devuelve:

  • (Muchos) —

    La asociación se vació.



311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 311

def depuración
  return anular a menos que _association.¿destructivo?

  Se ha producido un error al eliminar. = nulo
  criterios.delete_all
  muchos = _target.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
      Se ha producido un error al eliminar. = e
    end
  end

  propagar Se ha producido un error al eliminar. si Se ha producido un error al eliminar.

  muchos
end

#substitute(reemplazo) ⇒ Muchos

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

Ejemplos:

Reemplazar la asociación.

person.posts.substitute([ new_post ])

Parámetros:

  • reemplazo (Array<documento>) —

    El objetivo de reemplazo.

Devuelve:

  • (Muchos) —

    La asociación.



344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 344

def sustituir(reemplazo)
  si reemplazo
    new_docs, docs = reemplazo.compact, []
    nuevos_ids = new_docs.map(&::_id)
    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
    depuración
  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:



366
367
368
 
# Archivo 'lib/mongoid/association/referenced/has_many/proxy.rb', línea 366

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