Clase: Mongoid::ModelResolver

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Definido en:
lib/mongoid/model_resolver.rb

Overview

La clase predeterminada para resolver clases de modelo según claves discriminantes. Dada una clave, devolverá la clase de modelo correspondiente, si la hay. Por defecto, busca clases cuyos nombres coincidan con las claves dadas, pero se pueden proporcionar asignaciones adicionales.

También es posible crear instancias de múltiples resolutores (e incluso implementar los propios) para que diferentes conjuntos de clases puedan usar mecanismos de resolución independientes.

Colapso delresumen constante

INSTANCIA_MUTEX =

Esta constante forma parte de una API privada. Debe evitar usarla siempre que sea posible, ya que podría eliminarse o modificarse en el futuro.

La instancia de mutex utilizada para hacer que el método '.instance` sea seguro para subprocesos.

Mutex.Nuevo

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

Detalles del constructor

#inicializar ⇒ ModelResolver

Crea una nueva instancia de ModelResolver.



75
76
77
78
 
# Archivo 'lib/mongoid/model_resolver.rb', línea 75

def inicializar
  @key_to_model = {}
  @modelo_a_llaves = {}
end

Detalles del método de clase

.instancia ⇒ Mongoid::ModelResolver

Devuelve la instancia predeterminada de ModelResolver.

Devuelve:



27
28
29
 
# Archivo 'lib/mongoid/model_resolver.rb', línea 27

def instancia
  @instancia ||= MUTEX DE INSTANCIA.sincronizar { @instancia ||= Nuevo }
end

.register_resolver(resolver, nombre) ⇒ Objeto

Registre el resolver dado bajo el nombre dado.

Parámetros:

  • resolver (Mongoid::ModelResolver::Interface) —

    el solucionador que se va a registrar.

  • Nombre (Cadena | Símbolo) —

    el identificador que se utilizará para registrar el solucionador.



68
69
70
71
 
# Archivo 'lib/mongoid/model_resolver.rb', línea 68

def resolver_registro(resolver, Nombre)
  resolutores[Nombre.a_sym] = resolver
  yo
end

.resolver(identificador_u_objeto =:predeterminado) ⇒ Mongoid::ModelResolver::Interface

Devuelve la instancia de resolvedor que corresponde al argumento.

Parámetros:

  • identificador_o_objeto (nulo | verdadero | falso Símbolo | Cadena | Mongoid::ModelResolver::Interface) (predeterminado::predeterminado) —

    Si es nulo o falso, devuelve nulo. Si es verdadero o :default, corresponde al resolver predeterminado. Si es cualquier otro símbolo o cadena, corresponde al resolver registrado con ese identificador. De lo contrario, debe ser una instancia del resolver.

Devuelve:

  • (Mongoid::ModelResolver::Interface) —

    la instancia de resolución correspondiente al argumento dado.

Aumentos:

  • Mongoid::Errors::UnrecognizedResolver si el identificador dado es un símbolo o una cadena y no coincide con ningún solucionador registrado.



52
53
54
55
56
57
58
59
60
61
62
 
# Archivo 'lib/mongoid/model_resolver.rb', línea 52

def resolver(identificador_o_objeto = :por defecto)
  caso identificador_o_objeto
  Cuando nulo, false entonces nulo
  Cuando true, :por defecto entonces instancia
  Cuando String, Símbolo
    resolutores.Fetch(identificador_o_objeto.a_sym) hacer |clave|
      propagar Mongoid::Errors::Resolver no reconocido, clave
    end
  else identificador_o_objeto
  end
end

.resolvers ⇒ Hash<Símbolo => Mongoid::ModelResolver::Interfaz>

Devuelve el mapa de los resolutores registrados. El resolutor predeterminado no se incluye aquí.

Devuelve:

  • (Hash<Symbol => Mongoid::ModelResolver::Interface>) —

    el hash de las instancias del solucionador, mapeado por identificador de símbolo.



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

def resolutores
  @resolvers ||= {}
end

Detalles del método de instancia

#registro(clase, *claves) ⇒ Objeto

Registra la clase del modelo dada con las claves especificadas. Además de las claves especificadas, se incluirá el nombre de la clase como clave para identificarla. Las claves se asignan en orden de prioridad, comenzando por la de mayor prioridad y terminando por la de menor prioridad. Si no se especifica explícitamente, el nombre de la clase siempre tiene la prioridad más baja.

Si se llama más de una vez, las claves más recientes tienen mayor prioridad que las antiguas. Se eliminarán todas las claves duplicadas.

Parámetros:

  • klass (Mongoid::Documento) —

    la clase de documento a registrar

  • *llaves (Matriz<String>) —

    la lista de claves para usar como alias (opcional)



90
91
92
93
94
95
96
97
98
99
100
101
 
# Archivo 'lib/mongoid/model_resolver.rb', línea 90

def registro(klass, *claves)
  clave_predeterminada = klass.Nombre

  @modelo_a_llaves[klass] = [ *claves, *@modelo_a_llaves[klass], clave_predeterminada ].único
  @key_to_model[clave_predeterminada] = klass

  claves.cada hacer |clave|
    @key_to_model[clave] = klass
  end

  yo
end