Módulo: Mongoid::Attributes

Ampliado por:
ActiveSupport::Preocupación
Incluye:
Anidado, Procesando, Sololectura
Incluido en:
Componible
Definido en:
lib/mongoid/attributes.rb,
lib/mongoid/attributes/nested.rb,
lib/mongoid/attributes/dynamic.rb,
lib/mongoid/attributes/embedded.rb,
lib/mongoid/attributes/readonly.rb,
lib/mongoid/attributes/projector.rb,
lib/mongoid/attributes/processing.rb

Overview

Este módulo contiene la lógica para manejar el hash de atributos internos y cómo obtener y establecer valores.

Definido en el espacio de nombres

Modules: Clases de métodos, dinámicas, integradas, anidadas, deprocesamiento yde solo lectura: Proyector

Colapso delresumen de atributos de instancia

Colapso del resumen del método de instancia

Métodos incluidos de Readonly

#atributo_escribible?

Métodos incluidos en el Procesamiento

#atributos_del_proceso

Detalles de los atributos de instancia

#atributos ⇒ Objeto (solo lectura) También conocido como: raw_attributes

Devuelve el valor del atributo atributos.



22
23
24
 
# Archivo 'lib/mongoid/attributes.rb', línea 22

def atributos
  @atributos
end

Detalles del método de instancia

#asignar_atributos(attrs = nulo) ⇒ Objeto

Permite establecer todos los atributos de un rol de seguridad específico para la asignación masiva pasando un hash de atributos con claves que coincidan con los nombres de los atributos (que, a su vez, coinciden con los nombres de las columnas) y el nombre del rol utilizando la opción :as . Para evitar la seguridad de asignación masiva puedes usar la opción :without_protection => true .

Ejemplos:

Asignar los atributos.

person.assign_attributes(:title => "Mr.")

Asignar los atributos (con un rol).

person.assign_attributes({ :title => "Mr." }, :as => :admin)

Parámetros:

  • attrs (Hash) (predeterminado: nulo) —

    Los nuevos atributos a establecer.



218
219
220
221
222
 
# Archivo 'lib/mongoid/attributes.rb', línea 218

def asignar_atributos(attrs = nulo)
  _asignación hacer
    process_attributes(attrs)
  end
end

#atributo_faltante?(nombre) ⇒ verdadero | falso

Determinar si el atributo falta en el documento, debido a que se cargó desde la base de datos con campos faltantes.

Ejemplos:

¿Falta el atributo?

document.attribute_missing?("test")

Parámetros:

  • Nombre (Cadena) -

    El nombre del atributo.

Devuelve:

  • (verdadero | falso) —

    Si falta el atributo.



249
250
251
 
# Archivo 'lib/mongoid/attributes.rb', línea 249

def ¿atributo_faltante?(Nombre)
  !Proyector.Nuevo(__selected_fields).attribute_or_path_allowed?(Nombre)
end

#attribute_present?(nombre) ⇒ true | false

Determinar si un atributo está presente.

Ejemplos:

¿Está presente el atributo?

person.attribute_present?("title")

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (verdadero | falso) —

    Verdadero si está presente, falso si no.



33
34
35
36
37
38
 
# Archivo 'lib/mongoid/attributes.rb', línea 33

def atributo_presente?(Nombre)
  atributo = read_raw_attribute(Nombre)
  !atributo.blank? || atributo == false
rescate Mongoid::Errors::Atributo no cargado
  false
end

#atributos_antes_de_la_conversión_de_tipo ⇒ Hash

Obtenga los atributos que no han sido convertidos.

Ejemplos:

Obtenga los atributos antes de la conversión de tipos.

document.attributes_before_type_cast

Devuelve:

  • (Hash) —

    Los atributos no convertidos.



46
47
48
 
# Archivo 'lib/mongoid/attributes.rb', línea 46

def atributos_antes_de_la_conversión_de_tipo
  @atributos_antes_de_la_conversión_de_tipo ||= {}
end

#tiene_atributo?(nombre) ⇒ verdadero | falso

¿El documento tiene el atributo proporcionado?

Ejemplos:

¿El documento tiene el atributo?

model.has_attribute?(:name)

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (verdadero | falso) —

    Si la clave está presente en los atributos.



58
59
60
 
# Archivo 'lib/mongoid/attributes.rb', línea 58

def tiene_atributo?(Nombre)
  atributos.key?(Nombre.a_s)
end

#tiene_atributo_antes_de_la_conversión_de_tipo?(nombre) ⇒ verdadero | falso

¿El documento tiene el atributo proporcionado antes de ser asignado y tener un tipo convertido?

Ejemplos:

¿El documento tiene el atributo antes de ser asignado?

model.has_attribute_before_type_cast?(:name)

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (verdadero | falso) —

    Si la clave está presente en los atributos_antes_de_type_cast.



72
73
74
 
# Archivo 'lib/mongoid/attributes.rb', línea 72

def ¿tiene_atributo_antes_de_la_conversión_de_tipo?(Nombre)
  atributos_antes_de_la_conversión_de_tipo.key?(Nombre.a_s)
end

#process_raw_attribute(nombre, raw, campo) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Procesar los valores de atributos sin procesar recién leídos de los atributos de los documentos.

Parámetros:

  • Nombre (Cadena) -

    El nombre del atributo a obtener.

  • crudo (Objeto) -

    El valor del atributo sin procesar.

  • Campo (Campo | nulo) —

    El campo a utilizar para demonización o nulo.

Devuelve:

  • (Objeto) -

    El valor del atributo.



105
106
107
108
109
 
# Archivo 'lib/mongoid/attributes.rb', línea 105

def atributo_raw_del_proceso(Nombre, crudo, Campo)
  valor = Campo ? Campo.demonizar(crudo) : crudo
  ¡El atributo cambiará!(Nombre) Si valor.¿redimensionable?
  valor
end

#read_attribute(nombre) ⇒ Objeto También conocido como: []

Lee un valor de los atributos del documento. Si el valor no existe, devolverá "nil".

Ejemplos:

Leer un atributo.

person.read_attribute(:title)

Leer un atributo (sintaxis alternativa).

person[:title]

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo a obtener.

Devuelve:

  • (Objeto) -

    El valor del atributo.



88
89
90
91
92
 
# Archivo 'lib/mongoid/attributes.rb', línea 88

def read_attribute(Nombre)
  Campo = campos[Nombre.a_s]
  crudo = read_raw_attribute(Nombre)
  atributo_raw_del_proceso(Nombre.a_s, crudo, Campo)
end

#read_attribute_before_type_cast(nombre) ⇒ Objeto

Lee un valor de los atributos antes de la conversión de tipo. Si el valor aún no se ha asignado, se devolverá el valor existente del atributo mediante read_raw_attribute.

Ejemplos:

Leer un atributo antes de convertir el tipo.

person.read_attribute_before_type_cast(:price)

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo a obtener.

Devuelve:

  • (Objeto) -

    El valor del atributo antes de la conversión de tipo, si está disponible. De lo contrario, el valor del atributo.



122
123
124
125
126
127
128
129
 
# Archivo 'lib/mongoid/attributes.rb', línea 122

def leer_atributo_antes_de_la_conversión_de_tipo(Nombre)
  attr = Nombre.a_s
  Si atributos_antes_de_la_conversión_de_tipo.key?(attr)
    atributos_antes_de_la_conversión_de_tipo[attr]
  else
    read_raw_attribute(attr)
  end
end

#remove_attribute(nombre) ⇒ Objeto

Eliminar un valor de los atributos Document. Si el valor no existe, la operación fallará correctamente.

Ejemplos:

Eliminar el atributo.

person.remove_attribute(:title)

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo a eliminar.

Aumentos:



141
142
143
144
145
146
147
148
149
150
 
# Archivo 'lib/mongoid/attributes.rb', línea 141

def eliminar_atributo(Nombre)
  ¡validar_nombre_del_campo_escribible!(Nombre.a_s)
  como_atributo_modificable!(Nombre) hacer |Acceso|
    _asignación hacer
      ¡El atributo cambiará!(Acceso)
      puestas de sol atómicas retrasadas[nombre_del_atributo_atómico(Acceso)] = [] a no ser que ¿nuevo_registro?
      atributos.borrar(Acceso)
    end
  end
end

#atributos_tipificados ⇒ Objeto

Devuelve atributos convertidos en tipos.

Ejemplos:

Atributos de tipo convertido.

document.typed_attributes

Devuelve:

  • (Objeto) -

    El hash con claves y valores de los atributos convertidos en tipos.



259
260
261
 
# Archivo 'lib/mongoid/attributes.rb', línea 259

def typed_attributes
  nombres de atributos.map { |Nombre| [Nombre, Enviar(Nombre)] }.a_h
end

#write_attribute(nombre, valor) ⇒ Objeto También conocido como: []=

Escribe un solo atributo en el hash de atributos del documento. Esto también activará las devoluciones de llamada antes y después de la actualización, y realizará cualquier conversión de tipos necesaria.

Ejemplos:

Escribe el atributo.

person.write_attribute(:title, "Mr.")

Escribe el atributo (sintaxis alternativa).

person[:title] = "Mr."

Parámetros:

  • Nombre (Cadena | Símbolo) —

    El nombre del atributo a actualizar.

  • valor (Objeto) -

    El valor que se establecerá para el atributo.



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# Archivo 'lib/mongoid/attributes.rb', línea 164

def atributo de escritura(Nombre, valor)
  ¡validar_nombre_del_campo_escribible!(Nombre.a_s)

  nombre_del_campo = nombre_del_campo_de_base_de_datos(Nombre)

  Si ¿atributo_faltante?(nombre_del_campo)
    propagar Mongoid::Errors::Atributo no cargado.Nuevo(yo.clase, nombre_del_campo)
  end

  Si ¿atributo_escribible?(nombre_del_campo)
    _asignación hacer
      localizado = campos[nombre_del_campo].intentar(:localizado?)
      atributos_antes_de_la_conversión_de_tipo[Nombre.a_s] = valor
      valor_tipado = typed_value_for(nombre_del_campo, valor)
      a no ser que atributos[nombre_del_campo] == valor_tipado || ¿atributo_cambiado?(nombre_del_campo)
        ¡El atributo cambiará!(nombre_del_campo)
      end
      Si localizado
        presente = campos[nombre_del_campo].intentar(:localizar_presente?)
        tecla de bloqueo, valor_local = valor_tipado.primera
        Si presente && valor_local.blank?
          atributos[nombre_del_campo]&.borrar(tecla de bloqueo)
        else
          atributos[nombre_del_campo] ||= {}
          atributos[nombre_del_campo].¡unir!(valor_tipado)
        end
      else
        atributos[nombre_del_campo] = valor_tipado
      end

      # al escribir un atributo, también elimínelo de los no conjuntos,
      # para que al eliminar y luego escribir no se produzca una eliminación.
      puestas de sol atómicas retrasadas.borrar(nombre_del_campo)

      valor_tipado
    end
  else
    # TODO: MONGOID-5072
  end
end

#write_attributes(attrs = nil) ⇒ Objeto También conocido como: atributos=

Escribe el hash de los atributos proporcionados en el documento. Esto solo sobrescribirá los atributos existentes si están presentes en el nuevo Hash; todos los demás se conservarán.

Ejemplos:

Escribe los atributos.

person.write_attributes(:title => "Mr.")

Escribe los atributos (sintaxis alternativa).

person.attributes = { :title => "Mr." }

Parámetros:

  • attrs (Hash) (predeterminado: nulo) —

    Los nuevos atributos a establecer.



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

def atributos de escritura(attrs = nulo)
  asignar_atributos(attrs)
end