Módulo: Mongoid::Association::Relatable

Incluye:
Restringible, Opciones
Incluido en:
Embedded::EmbeddedIn, Embedded::EmbedsMany, Embedded::EmbedsOne, Mongoid::Association::Referenced::BelongsTo, Mongoid::Association::Referenced::HasAndBelongsToMany, Mongoid::Association::Referenced::HasMany, Mongoid::Association::Referenced::HasOne
Definido en:
lib/mongoid/association/relatable.rb

Overview

Este módulo proporciona comportamientos compartidos entre los tipos de Asociación.

Resumen de constantes colapsar

SHARED_OPTIONS =

Las opciones compartidas entre todos los tipos de asociación.

Devuelve:

  • (arreglo<Symbol>) —

    Las opciones compartidas.

%i[
  nombre_de_clase
  inverse_of
  validar
  Extender
].freeze
PRIMARY_KEY_DEFAULT =

La clave primaria por defecto.

Devuelve:

  • (string) —

    El valor por defecto del campo clave primaria.

'_id'

Resumen de atributos de la instancia colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Opciones

#as, #autobuilding?, #autosave, #cascading_callbacks?, #counter_cached?, #cyclic?, #dependent, #forced_nil_inverse?, #índice?, #inverse_of, #order, #polymorphic?, #primary_key, #store_as, #touch_field, #touchable?, #type

Métodos incluidos de Constrainable

#convert_to_foreign_key

Detalles de atributo de instancias

#nombre ⇒ Símbolo (solo lectura)

El nombre de la asociación.

Devuelve:

  • (Símbolo) —

    El nombre de la asociación.



31
32
33
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 31

def Nombre
  @name
end

#opciones ⇒ Hash (solo lectura)

Las opciones de esta asociación.

Devuelve:

  • (encriptada) —

    Las opciones.



36
37
38
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 36

def opciones
  @options
end

#owner_class ⇒ Class (solo lectura)

La clase que posee esta asociación.

Devuelve:

  • (clase) —

    La clase propietaria.



41
42
43
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 41

def owner_class
  @owner_class
end

#parent_inclusions ⇒ Array<String>

Las asociaciones por encima de esta en el árbol de inclusión.

Devuelve:

  • (arreglo<String>) —

    Las asociaciones.



319
320
321
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 319

def parent_inclusions
  @parent_inclusions ||= []
end

Detalles del método de instancia

#==(otra) ⇒ Objeto

Compara esta asociación con otra.

Devuelve:

  • (objeto) —

    El objeto a comparar con esta asociación.



65
66
67
68
69
70
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 65

def ==(Otros)
  relation_class_name == Otros.relation_class_name &&
    inverse_class_name == Otros.inverse_class_name &&
    Nombre == Otros.Nombre &&
    opciones == Otros.opciones
end

#¿vinculable?(_doc) ⇒ true | false

Si intentar vincular un objeto mediante esta asociación debe generar un error.

Parámetros:

  • doc (documento) —

    El documento que debe ser encuadernado.

Devuelve:

  • (true | false) —

    Si el documento se puede encuadernar.



96
97
98
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 96

def ¿se puede vincular?(_doc)
  false
end

#counter_cache_column_name ⇒ String

Obtén el nombre de la columna de la caché de contadores.

Devuelve:

  • (string) —

    El nombre de la columna de la caché del contador.



275
276
277
278
279
280
281
282
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 275

def nombre_columna_cache_conteo
  @counter_cache_column_name ||= si @options[contador_cache].is_a?(String) ||
                                    @options[contador_cache].is_a?(Símbolo)
                                   @options[contador_cache]
                                 else
                                   "#{inverse || inverse_class_name.demodulize.underscore.pluralize}_count"
                                 end
end

#create_relation(propietario, objetivo) ⇒ Proxy

Cree un objeto proxy de asociación utilizando el propietario y el objetivo.

Parámetros:

  • propietario (documento) —

    El documento del que depende esta asociación.

  • Objetivo (Document | Array<Document>) —

    El destino (padre) de la asociación.

Devuelve:



261
262
263
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 261

def crear_relación(propietario, Objetivo)
  relación.Nuevo(propietario, Objetivo, sí mismo)
end

#¿destructivo? ⇒ true | false

Si el método dependiente es destructivo.

Devuelve:

  • (true | false) —

    Si el método dependiente es destructivo.



268
269
270
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 268

def ¿destructivo?
  @destructive ||= !!(dependiente && %i[delete_all destruir].incluir?(dependiente))
end

#extension ⇒ Module

Obtén la extensión.

Devuelve:

  • (Módulo) —

    El módulo de extensión, si se ha definido uno.



287
288
289
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 287

def Extensión
  @extension ||= @options[:ampliar]
end

#foreign_key_check ⇒ String

Obtener el nombre del método para verificar si la clave externa ha cambiado.

Ejemplos:

Obtén el método de verificación de clave foránea.

association.foreign_key_check

Devuelve:

  • (string) —

    La verificación de clave externa.



250
251
252
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 250

def foreign_key_check
  @foreign_key_check ||= "#{foreign_key}_previously_changed?" si ¿stores_foreign_key? && foreign_key
end

#foreign_key_setter ⇒ String

El nombre del método setter de clave externa.

Devuelve:

  • (string) —

    El nombre del configurador de clave externa.



220
221
222
223
224
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 220

def asignador_de_clave_foránea
  # note: No puedes comprobar si esta asociación almacena clave foránea
  # Consulta el enlace HasOne y HasMany, hacen referencia a foreign_key_setter
  @foreign_key_setter ||= "#{foreign_key}=" si foreign_key
end

#get_callbacks(callback_type) ⇒ arreglo<Proc | Símbolo>

Obtén las funciones de retorno para un tipo determinado.

Parámetros:

  • tipo_de_retorno (Símbolo) —

    El tipo de función de retorno.

Devuelve:

  • (Array<Proc | Symbol>) —

    Una lista de los callbacks, ya sea de nombres de métodos o de procedimientos (Procs).



78
79
80
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 78

def get_callbacks(tipo_de_retorno)
  Arreglo(opciones[tipo_de_retorno])
end

#in_to? ⇒ verdadero | falso

¿Esta asociación es una asociación embedded_in o belongs_to?

Devuelve:

  • (true | false) —

    verdadero si es una asociación embedded_in o belongs_to, falso si no lo es.



341
342
343
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 341

def en_a?
  [ Referenciado::BelongsTo, Embedded::EmbeddedIn ].any? { |un(a)| is_a?(un(a)) }
end

#initialize(_class, nombre, opts = {}, &block) ⇒ Objeto

Inicializa la Asociación.

Parámetros:

  • clase (clase) —

    La clase del modelo que posee esta asociación.

  • Nombre (Símbolo) —

    El nombre de la asociación.

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

    Las opciones de la asociación.

  • bloque (Bloqueo) —

    El bloque opcional.



49
50
51
52
53
54
55
56
57
58
59
60
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 49

def inicializar(clase, Nombre, opciones = {}, &bloque)
  @owner_class = clase
  @name = Nombre
  @options = opciones
  @extension = nulo

  @module_path = clase.Nombre ? clase.Nombre.división('::')[0..-2].unirse('::') : ''
  @module_path << '::' a menos que @module_path.¿vacío?

  crear_extensión!(&bloque)
  validate!
end

#inverse(other = nil) ⇒ Símbolo

Obtenga el nombre inverso.

Devuelve:

  • (Símbolo) —

    El nombre inverso.



294
295
296
297
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 294

def inversa(Otros = nulo)
  candidatos = inversos(Otros)
  candidatos.detectar { |C| C } si candidatos
end

#inverse_association(other = nil) ⇒ Mongoid::Association::Relatable

Obtén los metadatos de la asociación del inverso.

Parámetros:

  • Otros (objeto) (valor por defecto: nil) —

    La otra clase de modelo u objeto de modelo que se utilizará al determinar los inversos.

Devuelve:



123
124
125
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 123

def asociación inversa(Otros = nulo)
  (Otros || relation_class).relaciones[inversa(Otros)]
end

#inverse_class ⇒ String También conocido como: inverse_klass

La clase del objeto que posee esta asociación.

Devuelve:

  • (string) —

    La clase de los objetos propietarios.



190
191
192
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 190

def clase_inversa
  @owner_class
end

#inverse_class_name ⇒ String

El nombre de clase del objeto que posee esta asociación.

Devuelve:

  • (string) —

    El nombre de clase de los objetos propietarios.



183
184
185
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 183

def inverse_class_name
  @inverse_class_name ||= @owner_class.Nombre
end

#inverse_setter(other = nil) ⇒ String

El nombre del método setter inverso.

Devuelve:

  • (string) —

    El nombre del setter inverso.



213
214
215
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 213

def inverse_setter(Otros = nulo)
  @inverse_setter ||= "#{inversos(otro).primero}=" a menos que inversos(Otros).blank?
end

#inverse_type ⇒ nil

Obtén el tipo inverso.

Devuelve:

  • (nil) —

    El valor por defecto es nil para una asociación.



130
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 130

def inverse_type; end

#inverse_type_setter ⇒ String

Obtiene el setter para el campo que establece el tipo de documento en una asociación polimórfica.

Ejemplos:

Obtén el configurador de tipo inverso.

association.inverse_type_setter

Devuelve:

  • (string) —

    El nombre del *setter* (establecedor de valores o atributos).



240
241
242
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 240

def inverse_type_setter
  @inverse_type_setter ||= "#{inverse_type}=" si inverse_type
end

# inversos(otro = nil)⇒ arreglo<Símbolo><Symbol>

Obten los nombres inversos.

Parámetros:

  • Otros (objeto) (valor por defecto: nil) —

    La otra clase de modelo u objeto de modelo que se utilizará al determinar los inversos.

Devuelve:

  • (arreglo<Symbol>) —

    La lista de nombres inversos.



106
107
108
109
110
111
112
113
114
115
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 106

def inversos(Otros = nulo)
  return [ inverse_of ] si inverse_of
  return [] si @options.key?(:inverso_de) && !inverse_of

  si polimórfico?
    inversos polimórficos(Otros)
  else
    determinar_inversos(Otros)
  end
end

#clave ⇒ Símbolo | string

El campo de clave externa si esta asociación almacena una clave externa. De lo contrario, la llave primaria.

Devuelve:

  • (Symbol | string) —

    La llave primaria.



199
200
201
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 199

def llave
  ¿stores_foreign_key? ? foreign_key : clave_primaria
end

#muchos? ⇒ verdadero | falso

¿Esta asociación es una asociación embeds_many o has_many?

Devuelve:

  • (true | false) —

    verdadero si es una asociación *_many, falso si no lo es.



326
327
328
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 326

def ¿muchos?
  [ Referenciado::HasMany, Embedded::EmbedsMany ].any? { |un(a)| is_a?(un(a)) }
end

#¿one? ⇒ verdadero | falso

¿Esta asociación es una asociación embeds_one o has_one?

Devuelve:

  • (true | false) —

    verdadero si es una asociación *_one, falso si no lo es.



333
334
335
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 333

def ¿uno?
  [ Referenciado::HasOne, Embedded::EmbedsOne ].any? { |un(a)| is_a?(un(a)) }
end

#path(documento) ⇒ Mongoid::Atomic::Paths::Root

La ruta atómica para esta asociación.

Devuelve:



229
230
231
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 229

def ruta(Documento)
  relación.ruta(Documento)
end

#relation_class ⇒ string También conocido como: klass

La clase del(los) objeto(s) de la asociación.

Este método devuelve la instancia de clase correspondiente a relation_class_name, resuelta con relación a la clase de documento host.

Si la clase no existe, este método genera NameError. Esto puede suceder si la clase objetivo aún no ha sido definida. Tenga en cuenta que, en general, las asociaciones polimórficas no tienen una clase objetivo bien definida porque la clase objetivo puede cambiar de un objeto a otro, y llamar a este método en una asociación polimórfica generalmente fallará con un NameError o producirá resultados engañosos (si una clase resulta estar definida con el mismo nombre que el nombre de la asociación).

Devuelve:

  • (string) —

    La clase de los objetos de la asociación.



172
173
174
175
176
177
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 172

def relation_class
  @klass ||= begin
    cls_name = @options[class_name:] || ActiveSupport::Inflector.clasificar(Nombre)
    resolver_nombre(clase_inversa, cls_name)
  end
end

#relation_class_name ⇒ String También conocido como: class_name

Nota:

El valor de retorno de este método no debe utilizarse para determinar si dos asociaciones tienen la misma clase objetivo, ya que el valor de retorno no siempre es un nombre de clase completamente calificado. Para comparar clases, recupera la instancia de clase del objetivo de la asociación utilizando el método relation_class.

El nombre de la clase, posiblemente no calificado o

prefijada, de la asociación

objeto/s.

Este método retorna el nombre de la clase tal como se usa en la definición de la asociación. Si se proporciona la opción :class_name en la asociación, se retorna exactamente el valor de esa opción aquí. Si no se proporciona la opción :class_name, el nombre de la clase se calcula a partir del nombre de la asociación, pero no se resuelve a la clase real.

El nombre de clase que devuelve este método puede no corresponder a una clase definida, ya sea porque la clase correspondiente no se ha cargado aún, o porque la asociación hace referencia a una clase que no existe en absoluto. Para obtener la clase de asociación, utiliza el método relation_class.

Devuelve:

  • (string) —

    El nombre de clase de los objetos de asociación.



153
154
155
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 153

def relation_class_name
  @class_name ||= @options[class_name:] || ActiveSupport::Inflector.clasificar(Nombre)
end

#setter ⇒ String

El nombre del setter en este objeto para asignar un objeto asociado.

Devuelve:

  • (string) —

    El nombre del configurador.



206
207
208
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 206

def setter
  @setter ||= "#{name}="
end

#type_setter ⇒ String

Nota:

Solo es relevante para asociaciones polimórficas que toman la opción :as.

Obtener el configurador de tipos.

Devuelve:

  • (string) —

    El método de ajuste de tipo.



86
87
88
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 86

def type_setter
  @type_setter ||= "#{tipo}=" si tipo
end

#¿validar? ⇒ verdadero | falso

Si los objetos asociados deben ser validados.

Devuelve:

  • (true | false) —

    Si se deben validar los objetos asociados.



303
304
305
306
307
308
309
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 303

def validate?
  @validate ||= si @options[: valide].nil?
                  validation_default
                else
                  !!@options[: valide]
                end
end