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.

Colapso delresumen constante

SHARED_OPTIONS =

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

Devuelve:

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

    Las opciones compartidas.

[
  class_name:,
  :inverso_de,
  : valide,
  :extender
].freeze
PRIMARY_KEY_DEFAULT =

La clave principal predeterminada.

Devuelve:

  • (string) —

    El campo de clave principal predeterminado.

'_id'.freeze

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

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

  • (encriptada) —

    Las opciones.



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

def opciones
  @options
end

#inclusiones_padres ⇒ Matriz<String>

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

Devuelve:

  • (arreglo<String>) —

    Las asociaciones.



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

def parent_inclusions
  @inclusiones_parentales
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.



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

def ==(Otros)
  relation_class_name == Otros.relation_class_name &&
    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:

  • (true | false) —

    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:

  • (string) —

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



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

def nombre_columna_cache_conteo
  @counter_cache_column_name ||= (@options[:counter_cache].is_a?(String) ||
      @options[:counter_cache].is_a?(Símbolo)) ?
      @options[:counter_cache] : "#{inverse || inverse_class_name.demodulize.underscore.pluralize}_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 que depende esta asociación.

  • Objetivo (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, Objetivo)
  relación.Nuevo(propietario, Objetivo, sí mismo)
end

#¿destructivo? ⇒ verdadero | falso

Si el método dependiente es destructivo.

Devuelve:

  • (true | false) —

    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 == :destroy))
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
  @extension ||= @options[:extender]
end

#comprobación_de_clave_externa ⇒ Cadena

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



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

def foreign_key_check
  @foreign_key_check ||= "#{clave_extranjera}_¿cambiado_previamente?" si (¿stores_foreign_key? && foreign_key)
end

#definidor_de_clave_externa ⇒ Cadena

El nombre del método setter de clave externa.

Devuelve:

  • (string) —

    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
  # Consulta el enlace HasOne y HasMany, hacen referencia a foreign_key_setter
  @configurador_de_claves_extranjeras ||= "#{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 devolución de llamada (Símbolo) —

    El tipo de función de retorno.

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 get_callbacks(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:

  • (true | false) —

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



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

def en_a?
  [Referenciado::BelongsTo, Embedded::EmbeddedIn].any? { |un(a)| sí mismo.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.

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

    Las opciones de la asociación.

  • bloque (Bloqueo) —

    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(clase, Nombre, opta = {}, Ybloque)
  @owner_class = clase
  @name = Nombre
  @options = opta
  @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!(Ybloque)
  validate!
end

#inverso(otro = nulo) ⇒ Símbolo

Obtenga el nombre inverso.

Devuelve:

  • (Símbolo) —

    El nombre inverso.



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

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

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

Obtenga los metadatos de asociación de la inversa.

Parámetros:

  • Otros (Objeto) (predeterminado: nulo) —

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

Devuelve:



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

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.



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

def clase_inversa
  @owner_class
end

#inverse_class_name ⇒ String

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

Devuelve:

  • (string) —

    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 ||= @owner_class.Nombre
end

#inverse_setter(other = nil) ⇒ String

El nombre del método setter inverso.

Devuelve:

  • (string) —

    El nombre del setter inverso.



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

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

#inverse_type ⇒ nil

Obtenga el tipo inverso.

Devuelve:

  • (nil) —

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



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

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



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

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

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

Obten los nombres inversos.

Parámetros:

  • Otros (Objeto) (predeterminado: nulo) —

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

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



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

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.



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

def ¿muchos?
  [Referenciado::Tiene muchos, Embedded::Incrusta muchos].any? { |un(a)| sí mismo.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.



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

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

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

La ruta atómica 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 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 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:

  • (string) —

    La clase de objetos de asociación.



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

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

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.



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

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



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

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

#type_setter ⇒ String

Nota:

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

Obtener el configurador de tipos.

Devuelve:

  • (string) —

    El método del creador de tipos.



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

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

#¿validar? ⇒ verdadero | falso

Si los objetos asociados deben ser validados.

Devuelve:

  • (true | false) —

    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 @options[: valide].nil?
                  validation_default
                else
                  !!@options[: valide]
                end
end