Módulo: Mongoid::Association::Relatable

Incluye:
Restringible, Opciones
Incluido en:
Incrustado::IncrustadoEn, Incrustado::IncrustaMuchos, Incrustado::IncrustaUno, Mongoid::Asociación::Referenciado::PerteneceA, Mongoid::Asociación::Referenciado::TieneYPerteneceAMuchos, Mongoid::Asociación::Referenciado::TieneMuchos, Mongoid::Asociación::Referenciado::TieneUno
Definido en:
lib/mongoid/asociación/relatable.rb

Overview

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

Colapso delresumen constante

OPCIONES_COMPARTIDAS =

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

Devuelve:

  • (Matriz<Símbolo><Symbol>) —

    Las opciones compartidas.

[
  :nombre_de_clase,
  :inverso_de,
  :validar,
  :extender
].freeze
PRIMARY_KEY_DEFAULT =

La clave principal predeterminada.

Devuelve:

  • (Cadena) -

    El campo de clave principal predeterminado.

'_id'.freeze

Colapso delresumen de atributos de instancia

Colapso del resumen del método de instancia

Métodos incluidos en Opciones

#como, #autoconstrucción?, #autoguardado, #devoluciones_de_llamadas_en_cascada?, #contador_en_caché?, #cíclico?, #dependiente, #inverso_nil_forzado?, #indexado?, #inverso_de, #orden, #polimórfico?, #clave_principal, #almacenar_como, #campo_táctil, #tocable?, #tipo

Métodos incluidos de Constrangible

#convertir_a_clave_extranjera

Detalles de los atributos de instancia

#nombre ⇒ Símbolo (solo lectura)

El nombre de la asociación.

Devuelve:

  • ( Símbolo) -

    El nombre de la asociación.



33
34
35
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 33

def Nombre
  @name
end

#opciones ⇒ Hash (solo lectura)

Las opciones de esta asociación.

Devuelve:

  • (Hash) —

    Las opciones.



38
39
40
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 38

def opciones
  @opciones
end

#inclusiones_padres ⇒ Matriz<String>

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

Devuelve:

  • (Matriz<String>) —

    Las asociaciones.



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

def inclusiones parentales
  @inclusiones_parentales
end

Detalles del método de instancia

#==(otro) ⇒ Objeto

Compare esta asociación con otra.

Devuelve:

  • (Objeto) -

    El objeto a comparar con esta asociación.



62
63
64
65
66
67
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 62

def ==(otros)
  nombre_de_clase_de_relación == otros.nombre_de_clase_de_relación &&
    inverse_class_name == otros.inverse_class_name &&
      Nombre == otros.Nombre &&
        opciones == otros.opciones
end

#enlazable?(doc) ⇒ verdadero | falso

Si intentar vincular un objeto mediante esta asociación debería generar un error.

Parámetros:

  • doc (Documento) -

    El documento que se va a encuadernar.

Devuelve:

  • (verdadero | falso) —

    Si el documento se puede encuadernar.



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

def ¿vinculable?(doc); false; end

#nombre_de_columna_de_caché_de_contador ⇒ Cadena

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

Devuelve:

  • (Cadena) -

    El nombre de la columna de caché del contador.



270
271
272
273
274
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 270

def nombre_de_columna_de_caché_de_contador
  @nombre_de_columna_de_caché_de_contador ||= (@opciones[:counter_cache].is_a?(String) ||
      @opciones[:counter_cache].is_a?(Símbolo)) ?
      @opciones[:counter_cache] : "#{inverso || nombre_de_clase_inversa.demodular. guión bajo. pluralizar }_count"
end

#create_relation(propietario, objetivo) ⇒ Proxy

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

Parámetros:

  • propietario (Documento) -

    El documento del cual cuelga esta asociación.

  • destino (Document | Array<Document>) —

    El objetivo (padre) de la asociación.

Devuelve:

  • (Apoderado) 


256
257
258
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 256

def crear_relación(propietario, destino)
  relación.Nuevo(propietario, destino, yo)
end

#¿destructivo? ⇒ verdadero | falso

Si el método dependiente es destructivo.

Devuelve:

  • (verdadero | falso) —

    Si el método dependiente es destructivo.



263
264
265
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 263

def ¿destructivo?
  @destructivo ||= !!(dependiente && (dependiente == :borrar_todo || dependiente == :destruir))
end

#extension ⇒ Module

Obtén la extensión.

Devuelve:

  • (Módulo) —

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



279
280
281
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 279

def extensión
  @extensión ||= @opciones[:extender]
end

#comprobación_de_clave_externa ⇒ Cadena

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

Ejemplos:

Obtenga el método de verificación de clave externa.

association.foreign_key_check

Devuelve:

  • (Cadena) -

    La comprobación de clave externa.



245
246
247
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 245

def comprobación de clave externa
  @verificación_de_clave_extranjera ||= "#{clave_extranjera}_¿cambiado_previamente?" Si (¿almacena_clave_extranjera? && clave externa)
end

#definidor_de_clave_externa ⇒ Cadena

El nombre del método establecedor de clave externa.

Devuelve:

  • (Cadena) -

    El nombre del generador de claves externas.



215
216
217
218
219
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 215

def definidor de clave externa
  # nota: No puedes comprobar si esta asociación almacena una clave externa
  # Ver enlace HasOne y HasMany, hacen referencia a foreign_key_setter
  @configurador_de_claves_extranjeras ||= "#{clave_externa}=" Si clave externa
end

#obtener_devoluciones_de_llamadas(tipo_de_devolución_de_llamada) ⇒ Matriz<Proc | Símbolo>

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

Parámetros:

  • tipo de devolución de llamada ( Símbolo) -

    El tipo de tipo de devolución de llamada.

Devuelve:

  • (Matriz<Proc | Símbolo>) —

    Una lista de las devoluciones de llamadas, ya sean nombres de métodos o procedimientos.



75
76
77
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 75

def obtener_devoluciones de llamadas(tipo de devolución de llamada)
  Arreglo(opciones[tipo de devolución de llamada])
end

#in_to? ⇒ verdadero | falso

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

Devuelve:

  • (verdadero | falso) —

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



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

def ¿en?
  [Referenciado::Pertenece a, Embedded::EmbeddedIn].any? { |un(a)| yo.is_a?(un(a)) }
end

#inicializar(_clase, nombre, opciones = {}, &bloque) ⇒ Objeto

Inicializar la asociación.

Parámetros:

  • _class (Clase) -

    La clase del modelo que posee esta asociación.

  • Nombre ( Símbolo) -

    El nombre de la asociación.

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

    Las opciones de asociación.

  • bloque (Bloquear) -

    El bloque opcional.



46
47
48
49
50
51
52
53
54
55
56
57
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 46

def inicializar(_class, Nombre, opta = {}, Ybloque)
  @propietario_clase = _class
  @name = Nombre
  @opciones = opta
  @extensión = nulo

  @module_path = _class.Nombre ? _class.Nombre.división('::')[0..-2].Join('::') : ''
  @module_path << '::' a no ser que @module_path.¿vacío?

  ¡crear_extensión!(Ybloque)
  validate!
end

#inverso(otro = nulo) ⇒ Símbolo

Obtener el nombre inverso.

Devuelve:

  • ( Símbolo) -

    El nombre inverso.



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

def inverso(otros = nulo)
  candidatos = inversas(otros)
  candidatos.detectar { |C| C } Si candidatos
end

#asociación_inversa(otro = nulo) ⇒ Mongoid::Asociación::Relacionable

Obtenga los metadatos de asociación de la inversa.

Parámetros:

  • otros (Objeto) (predeterminado: nulo) —

    La otra clase de modelo u objeto de modelo a utilizar al determinar inversas.

Devuelve:



118
119
120
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 118

def asociación inversa(otros = nulo)
  (otros || clase_de_relación).relaciones[inverso(otros)]
end

#inverse_class ⇒ String También conocido como: inverse_klass

La clase del objeto propietario de esta asociación.

Devuelve:

  • (Cadena) -

    La clase propietaria de los objetos.



185
186
187
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 185

def clase inversa
  @propietario_clase
end

#nombre_de_clase_inversa ⇒ Cadena

El nombre de la clase del objeto propietario de esta asociación.

Devuelve:

  • (Cadena) -

    Nombre de la clase de los objetos propietarios.



178
179
180
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 178

def inverse_class_name
  @nombre_de_clase_inversa ||= @propietario_clase.Nombre
end

#inverse_setter(other = nil) ⇒ String

El nombre del método setter inverso.

Devuelve:

  • (Cadena) -

    El nombre del colocador inverso.



208
209
210
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 208

def inverse_setter(otros = nulo)
  @inverse_setter ||= "#{inverses(other). first}=" a no ser que inversas(otros).blank?
end

#inverse_type ⇒ nil

Obtenga el tipo inverso.

Devuelve:

  • (nil) —

    El valor predeterminado es nulo para una asociación.



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

def inverse_type; end

#inverse_type_setter ⇒ String

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

Ejemplos:

Obtenga el establecedor de tipo inverso.

association.inverse_type_setter

Devuelve:

  • (Cadena) -

    El nombre del colocador.



235
236
237
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 235

def definidor de tipo inverso
  @inverse_type_setter ||= "#{tipo_inverso}=" Si inverse_type
end

#inversas(otras = nulas) ⇒ Array<Symbol>

Obtenga los nombres inversos.

Parámetros:

  • otros (Objeto) (predeterminado: nulo) —

    La otra clase de modelo u objeto de modelo a utilizar al determinar inversas.

Devuelve:

  • (Matriz<Símbolo><Symbol>) —

    La lista de nombres inversos.



101
102
103
104
105
106
107
108
109
110
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 101

def inversas(otros = nulo)
  return [ inverso_de ] Si inverso_de
  return [] Si @opciones.key?(:inverso_de) && !inverso_de

  Si polimórfico?
    inversos polimórficos(otros)
  else
    determinar_inversos(otros)
  end
end

#tecla ⇒ Símbolo | Cadena

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

Devuelve:

  • (Símbolo| Cadena) —

    La llave primaria.



194
195
196
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 194

def clave
  ¿almacena_clave_extranjera? ? clave externa : clave_primaria
end

#¿muchos? ⇒ verdadero | falso

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

Devuelve:

  • (verdadero | falso) —

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



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

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

#uno? ⇒ verdadero | falso

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

Devuelve:

  • (verdadero | falso) —

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



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

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

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

El camino atómico para esta asociación.

Devuelve:



224
225
226
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 224

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

#relación_clase ⇒ Cadena También conocido como: klass

La clase de los objetos de asociación.

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

Si la clase no existe, este método genera un error NameError. Esto puede ocurrir porque la clase de destino aún no se ha definido. Tenga en cuenta que las asociaciones polimórficas generalmente no tienen una clase de destino bien definida, ya que esta puede cambiar de un objeto a otro, y llamar a este método en una asociación polimórfica generalmente fallará con un error NameError o producirá resultados erróneos (si una clase está definida con el mismo nombre que la asociación).

Devuelve:

  • (Cadena) -

    La clase de objetos de asociación.



167
168
169
170
171
172
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 167

def clase_de_relación
  @klass ||= begin
    nombre_cls = @opciones[:nombre_de_clase] || Soporte activo::Inflector.clasificar(Nombre)
    nombre_de_resolución(clase inversa, nombre_cls)
  end
end

#relación_nombre_clase ⇒ Cadena También conocido como: nombre_clase

Nota:

El valor de retorno de este método no debe utilizarse para determinar si dos asociaciones tienen la misma clase de destino, ya que no siempre es un nombre de clase completo. Para comparar clases, recupere la instancia de la clase de destino de la asociación mediante el método relation_class.

El nombre de la clase, posiblemente no calificado o

prefijado, de la asociación

objeto/s.

Este método devuelve el nombre de la clase tal como se utiliza en la definición de la asociación. Si se especifica la opción :class_name en la asociación, se devuelve aquí su valor exacto. Si no se especifica 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 devuelto por este método podría no corresponder a una clase definida, ya sea porque la clase correspondiente aún no se ha cargado o porque la asociación hace referencia a una clase inexistente. Para obtener la clase de asociación, utilice el método relation_class.

Devuelve:

  • (Cadena) -

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



148
149
150
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 148

def nombre_de_clase_de_relación
  @nombre_de_clase ||= @opciones[:nombre_de_clase] || Soporte activo::Inflector.clasificar(Nombre)
end

#setter ⇒ String

El nombre del establecedor de este objeto para asignar un objeto asociado.

Devuelve:

  • (Cadena) -

    El nombre del setter.



201
202
203
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 201

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

#type_setter ⇒ String

Nota:

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

Obtenga el configurador tipográfico.

Devuelve:

  • (Cadena) -

    El método del creador de tipos.



83
84
85
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 83

def tipógrafo
  @tipógrafo ||= "#{tipo}=" Si tipo
end

#validar? ⇒ verdadero | falso

Si los objetos asociados deben validarse.

Devuelve:

  • (verdadero | falso) —

    Si los objetos asociados deben validarse.



295
296
297
298
299
300
301
 
# Archivo 'lib/mongoid/association/relatable.rb', línea 295

def validate?
  @validate ||= Si @opciones[:validar].nil?
                  validation_default
                else
                  !!@opciones[:validar]
                end
end