Módulo: Mongoid::Attributes

Estendido por:
ActiveSupport::Concern
Inclui:
Aninhado, em processamento, somente leitura
Incluído em:
Componível
Definido em:
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

Visão geral

Este módulo contém a lógica para lidar com o hash de atributos internos e como obter e definir valores.

Definido sob namespace

Módulos: ClassMethods, Dynamic, Embedded, Nested, Processing, Readonly Classes: Projector

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Métodos incluídos no Readonly

#attribute_writeable?

Métodos incluídos do Processamento

#process_attributes

Detalhes do atributo da instância

#attributes Objeto (somente leitura) Também conhecido como: bruto_attributes

Retorna o valor dos atributos do atributo.



20
21
22
 
# Arquivo 'lib/mongoid/attributes.rb', linha 20

def attributes
  @attributes
end

Detalhes do método de instância

#assign_attributes(attrs = nil) ➤ Objeto

Permite que você defina todos os atributos para uma role de segurança de atribuição em massa específica passando um hash de atributos com chaves correspondentes aos nomes dos atributos (que novamente corresponde aos nomes das colunas) e ao nome da role usando a opção :as. Para ignorar a segurança de atribuição em massa, você pode usar a opção :sem proteção => verdadeiro.

Exemplos:

Atribua os atributos.

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

Atribua os atributos (com uma função).

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

Parâmetros:

  • attrs (Hash) (padrão para: nil) —

    Os novos atributos a serem definidos.



214
215
216
217
218
 
# Arquivo 'lib/mongoid/attributes.rb', linha 214

def assign_attributes(attrs = nada)
  _assigning fazer
    process_attributes(attrs)
  end
end

#atributo_emfalta?(nome) ➤ verdadeiro | false

Determine se o atributo está ausente no documento, devido a carregá-lo do banco de banco de dados com campos ausentes.

Exemplos:

O atributo está ausente?

document.attribute_missing?("test")

Parâmetros:

  • name (string) —

    O nome do atributo.

Retorna:

  • (verdadeiro | falso) —

    Se o atributo estiver ausente.



245
246
247
 
# Arquivo 'lib/mongoid/attributes.rb', linha 245

def Atributo_em falta?(name)
  !Projetor.Novo(__selected_fields).Atributo_or_path_allowed?(name)
end

#atributo_present?(nome) ➤ verdadeiro | false

Determine se um atributo está presente.

Exemplos:

O atributo está presente?

person.attribute_present?("title")

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo.

Retorna:

  • (verdadeiro | falso) —

    Verdadeiro se presente, falso se não.



31
32
33
34
35
36
 
# Arquivo 'lib/mongoid/attributes.rb', linha 31

def Atributo_present?(name)
  atributo = read_raw_attribute(name)
  !atributo.em branco? || atributo == false
salvar Mongoid::Errors::AttributeNotLoaded
  false
end

#attributes_before_type_cast ➤ Hash

Obtenha os atributos que não foram convertidos.

Exemplos:

Obtenha os atributos antes da conversão do tipo.

document.attributes_before_type_cast

Retorna:

  • (Hash) —

    Os atributos não convertidos.



44
45
46
 
# Arquivo 'lib/mongoid/attributes.rb', linha 44

def atributos_before_type_cast
  @attributes_before_type_cast ||= {}
end

#has_attribute?(nome) ➤ verdadeiro | false

O documento tem o atributo fornecido?

Exemplos:

O documento tem o atributo?

model.has_attribute?(:name)

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo.

Retorna:

  • (verdadeiro | falso) —

    Se a chave estiver presente nos atributos.



56
57
58
 
# Arquivo 'lib/mongoid/attributes.rb', linha 56

def has_attribute?(name)
  attributes.chave?(name.to_s)
end

#has_attribute_before_type_cast?(nome) ➤ verdadeiro | false

O documento tem o atributo fornecido antes de ser atribuído e o tipo convertido?

Exemplos:

O documento tem o atributo antes de ser atribuído?

model.has_attribute_before_type_cast?(:name)

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo.

Retorna:

  • (verdadeiro | falso) —

    Se a chave estiver presente no atributos_before_type_cast.



70
71
72
 
# Arquivo 'lib/mongoid/attributes.rb', linha 70

def has_attribute_before_type_cast?(name)
  atributos_before_type_cast.chave?(name.to_s)
end

#process_raw_attribute(nome, bruto, campo) ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Processe os valores brutos dos atributos que você acabou de ler nos atributos dos documentos.

Parâmetros:

  • name (string) —

    O nome do atributo a ser obtido.

  • bruto (Objeto) —

    O valor do atributo bruto.

  • Campo (Campo | nulo) —

    O campo a ser usado para desmongoização ou nil.

Retorna:

  • (Objeto) —

    O valor do atributo.



102
103
104
105
106
107
 
# Arquivo 'lib/mongoid/attributes.rb', linha 102

def process_raw_attribute(name, bruto, Campo)
  valor = Campo ? Campo.desmongoizar(bruto) : bruto
  is_relation = relações.chave?(name)
  attribute_ will_change!(name) se valor.redimensionável? && !is_relation
  valor
end

#read_attribute(name) ➤ Objeto também conhecido como: []

Ler um valor dos atributos do documento. Se o valor não existir, ele retornará nulo.

Exemplos:

Ler um atributo.

person.read_attribute(:title)

Ler um atributo (sintaxe alternativa.)

person[:title]

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo a ser obtido.

Retorna:

  • (Objeto) —

    O valor do atributo.



86
87
88
89
90
 
# Arquivo 'lib/mongoid/attributes.rb', linha 86

def read_attribute(name)
  Campo = Campos[name.to_s]
  bruto = read_raw_attribute(name)
  process_raw_attribute(name.to_s, bruto, Campo)
end

#read_attribute_before_type_cast(name) ➤ Objeto

Leia um valor a partir dos atributos antes de digitar. Se o valor ainda não tiver sido atribuído, isso retornará o valor existente do atributo usando read_raw_attribute.

Exemplos:

Leia um atributo antes de digitar.

person.read_attribute_before_type_cast(:price)

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo a ser obtido.

Retorna:

  • (Objeto) —

    O valor do atributo antes da conversão do tipo, se disponível. Caso contrário, o valor do atributo.



120
121
122
123
124
125
126
127
 
# Arquivo 'lib/mongoid/attributes.rb', linha 120

def read_attribute_before_type_cast(name)
  atr = name.to_s
  se atributos_before_type_cast.chave?(atr)
    atributos_before_type_cast[atr]
  mais
    read_raw_attribute(atr)
  end
end

#remove_attribute(name) ➤ Objeto

Remova um valor dos atributos do Document . Se o valor não existir, ele falhará normalmente.

Exemplos:

Remova o atributo.

person.remove_attribute(:title)

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo a ser removido.

Aumenta:



139
140
141
142
143
144
145
146
147
148
 
# Arquivo 'lib/mongoid/attributes.rb', linha 139

def remove_attribute(name)
  validate_write_field_name!(name.to_s)
  as_writeable_attribute!(name) fazer |Acesso|
    _assigning fazer
      attribute_ will_change!(Acesso)
      delay_atomic_unsets[atomic_attribute_name(Acesso)] = [] a menos que new_record?
      attributes.excluir(Acesso)
    end
  end
end

#typed_attributes ➤ Objeto

Atributos convertidos por tipo de retorno.

Exemplos:

Atributos convertidos por tipo.

document.typed_attributes

Retorna:

  • (Objeto) —

    O hash com chaves e valores dos atributos convertidos em tipo.



255
256
257
 
# Arquivo 'lib/mongoid/attributes.rb', linha 255

def typed_attributes
  Atributo_nomes.map { |name| [ name, enviar(name) ] }.to_h
end

#write_attribute(name, value) ➤ Objeto também conhecido como: []=

Escreva um único atributo no hash de atributo do documento . Isso também acionará as chamadas de resposta antes e depois da atualização e executará qualquer digitação necessária.

Exemplos:

Escreva o atributo.

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

Escreva o atributo (sintaxe alternativa.)

person[:title] = "Mr."

Parâmetros:

  • name (string | Símbolo) —

    O nome do atributo a ser atualizado.

  • valor (Objeto) —

    O valor a ser definido para o 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
 
# Arquivo 'lib/mongoid/attributes.rb', linha 162

def write_attribute(name, valor)
  validate_write_field_name!(name.to_s)

  field_name = database_field_name(name)

  aumentar Mongoid::Errors::AttributeNotLoaded.Novo(auto.classe, field_name) se Atributo_em falta?(field_name)

  se Atributo_gravável?(field_name)
    _assigning fazer
      localizado = Campos[field_name].tentar(:localizado?)
      atributos_before_type_cast[name.to_s] = valor
      typed_value = typed_value_for(field_name, valor)
      a menos que attribute_ will_not_change?(field_name, typed_value) || atributo_changed?(field_name)
        attribute_ will_change!(field_name)
      end
      se localizado
        presente = Campos[field_name].tentar(:localize_present?)
        loc_key, loc_val = typed_value.primeiro
        se presente && loc_val.em branco?
          attributes[field_name]&.excluir(loc_key)
        mais
          attributes[field_name] ||= {}
          attributes[field_name].mesclar!(typed_value)
        end
      mais
        attributes[field_name] = typed_value
      end

      # ao escrever um atributo, remova-o também do unset,
      # para que a remoção e a gravação não resultem em uma remoção.
      delay_atomic_unsets.excluir(field_name)

      typed_value
    end
  mais
    # TODO: MONGOID-5072
  end
end

#write_attributes(attrs = nil) ➤ Objeto Também conhecido como: atributos=

Escreve o hash de atributos fornecido no documento. Isso só substituirá os atributos existentes se eles estiverem presentes no novo Hash, todos os outros serão preservados.

Exemplos:

Escreva os atributos.

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

Escreva os atributos ( sintaxe alternativa.)

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

Parâmetros:

  • attrs (Hash) (padrão para: nil) —

    Os novos atributos a serem definidos.



231
232
233
 
# Arquivo 'lib/mongoid/attributes.rb', linha 231

def write_attributes(attrs = nada)
  assign_attributes(attrs)
end