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

#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 (Hash) (predeterminado: nulo) —

    Los nuevos atributos a configurar.



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

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.



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 (String | Símbolo) —

    El nombre del atributo.

Devuelve:

  • (true | false) —

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



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

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

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

  • (encriptada) —

    Los atributos no convertidos.



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

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.



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

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.



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

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 forma parte de una API privada. Debe evitarlo 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 a obtener.

  • crudo (objeto) —

    El valor del atributo sin procesar.

  • Campo (Campo | nil) —

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

Devuelve:

  • (objeto) —

    El valor del atributo.



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

def process_raw_attribute(Nombre, crudo, Campo)
  Valor = Campo ? Campo.desmongoizar(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:

Lee un atributo.

person.read_attribute(:title)

Leer un atributo (sintaxis alternativa.)

person[:title]

Parámetros:

  • Nombre (String | 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.to_s]
  crudo = read_raw_attribute(Nombre)
  process_raw_attribute(Nombre.to_s, crudo, Campo)
end

#read_attribute_before_type_cast(name) ⇒ 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:

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 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.to_s
  si attributes_before_type_cast.key?(attr)
    attributes_before_type_cast[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:

Remover el atributo.

person.remove_attribute(:title)

Parámetros:

  • Nombre (String | Símbolo) —

    El nombre del atributo que se removerá.

Aumenta:



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

def eliminar_atributo(Nombre)
  validate_writable_field_name!(Nombre.to_s)
  como_atributo_modificable!(Nombre) hacer |Acceso|
    asignando hacer
      ¡El atributo cambiará!(Acceso)
      puestas de sol atómicas retrasadas[atomic_attribute_name(Acceso)] = [] a menos que nuevo_registro?
      atributos.borrar(Acceso)
    end
  end
end

#atributos_tipificados ⇒ 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.



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

def typed_attributes
  nombres de atributos.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.")

Escribe 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 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 write_attribute(Nombre, Valor)
  validate_writable_field_name!(Nombre.to_s)

  field_name = database_field_name(Nombre)

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

  si attribute_writable?(field_name)
    asignando hacer
      localizado = campos[field_name].intentar(:localizado?)
      attributes_before_type_cast[Nombre.to_s] = Valor
      valor_tipado = typed_value_for(field_name, Valor)
      a menos que atributos[field_name] == valor_tipado || ¿atributo_cambiado?(field_name)
        ¡El atributo cambiará!(field_name)
      end
      si localizado
        presente = campos[field_name].intentar(:localizar_presente?)
        loc_key, valor_loc = valor_tipado.primero
        si presente && valor_loc.blank?
          atributos[field_name]&.borrar(loc_key)
        else
          atributos[field_name] ||= {}
          atributos[field_name].¡unir!(valor_tipado)
        end
      else
        atributos[field_name] = valor_tipado
      end

      # al escribir un atributo, también remuévelo de los no establecidos,
      # para que al eliminar y luego escribir no se produzca una eliminación.
      puestas de sol atómicas retrasadas.borrar(field_name)

      valor_tipado
    end
  else
    # TODO: MONGOID-5072
  end
end

#write_attributes(attrs = 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.")

Escribe los atributos (sintaxis alternativa).

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

Parámetros:

  • attrs (Hash) (predeterminado: nulo) —

    Los nuevos atributos a configurar.



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

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