Módulo: Mongoid::Attributes

Ampliado por:
ActiveSupport::Concern
Incluye:
Anidado, procesamiento, Solo lectura
Incluido en:
Compuesto
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/procesamiento.rb

Overview

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

Definido bajo Namespace

Modules: Métodos de clase, Dinámico, Acoplado, Anidado, Procesamiento, Solo lectura Clases: Proyector

Resumen de atributos de la instancia colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Solo lectura

#attribute_writable?

Métodos incluidos de Procesamiento

#process_attributes

Detalles de atributo de instancias

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

Devuelve el valor del atributo atributos.



20
21
22
 
# Archivo 'lib/mongoid/attributes.rb', línea 20

def atributos
  @atributos
end

Detalles del método de instancia

#assignar_atributos(attrs = nil) ⇒ 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.")

Asigna los atributos (con un rol).

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

Parámetros:

  • attrs (encriptada) (valor por defecto: nil) —

    Los nuevos atributos a configurar.



214
215
216
217
218
 
# Archivo 'lib/mongoid/attributes.rb', línea 214

def asignar_atributos(attrs = nulo)
  asignando hacer
    process_attributes(attrs)
  end
end

#attribute_missing?(name) ⇒ true | false

Determina si falta el atributo en el documento debido a haberse cargado desde la base de datos con campos faltantes.

Ejemplos:

¿Falta el atributo?

document.attribute_missing?("test")

Parámetros:

  • Nombre (string) —

    El nombre del atributo.

Devuelve:

  • (true | false) —

    En caso de que falte el atributo.



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

def ¿falta_el_atributo?(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 (String | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (true | false) —

    Es verdadero si está presente, falso si no lo está.



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

def attribute_present?(Nombre)
  Atributo = read_raw_attribute(Nombre)
  !Atributo.blank? || Atributo == false
rescate Mongoid::Errors::AtributoNoCargado
  false
end

#attributes_before_type_cast ⇒ Hash

Obtén los atributos que no se han transformado.

Ejemplos:

Obtén los atributos antes de la conversión de tipo.

document.attributes_before_type_cast

Devuelve:

  • (encriptada) —

    Los atributos no convertidos.



44
45
46
 
# Archivo 'lib/mongoid/attributes.rb', línea 44

def attributes_before_type_cast
  @attributes_before_type_cast ||= {}
end

#has_attribute?(nombre) ⇒ verdadero | falso

¿El documento tiene el atributo proporcionado?

Ejemplos:

¿El documento tiene el atributo?

model.has_attribute?(:name)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (true | false) —

    Si la clave está presente en los atributos.



56
57
58
 
# Archivo 'lib/mongoid/attributes.rb', línea 56

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

#has_attribute_before_type_cast?(name) ⇒ true | false

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

Ejemplos:

¿Tiene el documento el atributo antes de que se asigne?

model.has_attribute_before_type_cast?(:name)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (true | false) —

    Si la clave está presente en attributes_before_type_cast.



70
71
72
 
# Archivo 'lib/mongoid/attributes.rb', línea 70

def has_attribute_before_type_cast?(Nombre)
  attributes_before_type_cast.key?(Nombre.to_s)
end

#process_raw_attribute(nombre, bruto, campo) ⇒ Objeto

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Procesa los valores brutos de los atributos que acaban de leerse en los atributos de los documentos.

Parámetros:

  • Nombre (string) —

    El nombre del atributo que se va a obtener.

  • crudo (objeto) —

    El valor bruto del atributo.

  • Campo (Campo | nil) —

    El campo a utilizar para la desmongoización o nulo.

Devuelve:

  • (objeto) —

    El valor del atributo.



102
103
104
105
106
107
 
# Archivo 'lib/mongoid/attributes.rb', línea 102

def process_raw_attribute(Nombre, crudo, Campo)
  Valor = Campo ? Campo.desmongoizar(crudo) : crudo
  is_relation = relaciones.key?(Nombre)
  attribute_will_change!(Nombre) si Valor.¿redimensionable? && !is_relation
  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:

Lee un atributo.

person.read_attribute(:title)

Leer un atributo (sintaxis alternativa.)

person[:title]

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo que se va a obtener.

Devuelve:

  • (objeto) —

    El valor del atributo.



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

def read_attribute(Nombre)
  Campo = Campos[Nombre.to_s]
  crudo = read_raw_attribute(Nombre)
  process_raw_attribute(Nombre.to_s, crudo, Campo)
end

#read_attribute_before_type_cast(name) ⇒ Objeto

Lea un valor de los atributos antes de hacer una conversión de tipo. Si el valor aún no se ha asignado, esto devolverá el valor existente del atributo utilizando read_raw_attribute.

Ejemplos:

Lea un atributo antes de realizar la conversión de tipo.

person.read_attribute_before_type_cast(:price)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo que se va 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.



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

def read_attribute_before_type_cast(Nombre)
  attr = Nombre.to_s
  si attributes_before_type_cast.key?(attr)
    attributes_before_type_cast[attr]
  else
    read_raw_attribute(attr)
  end
end

#eliminar_atributo(nombre) ⇒ Objeto

Remueve un valor de los atributos de Document. Si el valor no existe, fallará de manera predecible.

Ejemplos:

Remover el atributo.

person.remove_attribute(:title)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo que se removerá.

Aumenta:



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

def eliminar_atributo(Nombre)
  validate_writable_field_name!(Nombre.to_s)
  como_atributo_modificable!(Nombre) hacer |Acceso|
    asignando hacer
      attribute_will_change!(Acceso)
      delayed_atomic_unsets[atomic_attribute_name(Acceso)] = [] a menos que nuevo_registro?
      atributos.borrar(Acceso)
    end
  end
end

#typed_attributes ⇒ objeto

Retornar atributos con conversión de tipo.

Ejemplos:

Atributos de tipo casteado.

document.typed_attributes

Devuelve:

  • (objeto) —

    El "hash" con las claves y valores de los atributos convertidos por tipo.



255
256
257
 
# Archivo 'lib/mongoid/attributes.rb', línea 255

def typed_attributes
  attribute_names.map { |Nombre| [ Nombre, enviar(Nombre) ] }.to_h
end

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

Guardar un único atributo en la clave 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 que sea necesaria.

Ejemplos:

Escribe el atributo.

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

Guardar el atributo (sintaxis alternativa).

person[:title] = "Mr."

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo a actualizar.

  • Valor (objeto) —

    El valor que se debe establecer para el atributo.

Aumenta:



162
163
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
 
# Archivo 'lib/mongoid/attributes.rb', línea 162

def write_attribute(Nombre, Valor)
  validate_writable_field_name!(Nombre.to_s)

  field_name = database_field_name(Nombre)

  propagar Mongoid::Errors::AtributoNoCargado.Nuevo(sí mismo.clase, field_name) si ¿falta_el_atributo?(field_name)

  si attribute_writable?(field_name)
    asignando hacer
      localizado = Campos[field_name].intentar(:localized?)
      attributes_before_type_cast[Nombre.to_s] = Valor
      valor_escrito = typed_value_for(field_name, Valor)
      a menos que atributo_no_cambiará?(field_name, valor_escrito) || atributo_cambiado?(field_name)
        attribute_will_change!(field_name)
      end
      si localizado
        presente = Campos[field_name].intentar(:localize_present?)
        loc_key, valor_loc = valor_escrito.primero
        si presente && valor_loc.blank?
          atributos[field_name]&.borrar(loc_key)
        else
          atributos[field_name] ||= {}
          atributos[field_name].¡Actualizar!(valor_escrito)
        end
      else
        atributos[field_name] = valor_escrito
      end

      # al escribir un atributo, también remuévelo de los no establecidos,
      # para que remover y luego escribir no resulte en una eliminación.
      delayed_atomic_unsets.borrar(field_name)

      valor_escrito
    end
  else
    # TODO: MONGOID-5072
  end
end

#escribir_atributos(atrib = nil) ⇒ Objeto También conocido como: atributos =

Escribe el hash de atributos suministrados 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:

Guardar los atributos.

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

Escriba los atributos (sintaxis alternativa).

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

Parámetros:

  • attrs (encriptada) (valor por defecto: nil) —

    Los nuevos atributos a configurar.



231
232
233
 
# Archivo 'lib/mongoid/attributes.rb', línea 231

def write_attributes(attrs = nulo)
  asignar_atributos(attrs)
end