Módulo: Mongoid::Fields

Estendido por:
ActiveSupport::Concern
Incluído em:
Componível
Definido em:
lib/mongoid/fields.rb,
lib/mongoid/fields/standard.rb,
lib/mongoid/fields/encrypted.rb,
lib/mongoid/fields/localized.rb,
lib/mongoid/fields/foreign_key.rb,
lib/mongoid/fields/validators/macro.rb

Visão geral

Este módulo define o comportamento dos campos.

Definido sob namespace

Módulos: ClassMethods, Validator Classes: Encrypted, foreignKey, Localized, Standard

Colapsode resumo constante

StringifiedSymbol = 
Mongoid::StringifiedSymbol
Booleano = 
Mongoid::Boolean
TYPE_MAPPINGS =

Para campos definidos com símbolos, use a classe correta.

{
  matriz: Array,
  big_decimal: BigDecimal,
  binário: BSON::Binário,
  booleano: Mongoid::Boolean,
  data: Data,
  date_time: DateTime,
  float: Float,
  hash: Hash,
  inteiro: Inteiro,
  object_id: BSON::ObjectId,
  faixa: faixa,
  regexp: regexp,
  conjunto: definir,
  string: String,
  stringified_symbol: StringifiedSymbol,
  símbolo: Símbolo,
  tempo: Hora
}.with_indizer_access
IDS =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Constante para todos os nomes do campo _id em um documento.

Isso não inclui aliases do campo _id .

[ :_id, '_id' ].congelar
INVALID_BSON_CLASSES =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

Classes BSON que não são suportadas como tipos de campo

[ BSON::Decimal128, BSON::Int32, BSON::Int64 ].congelar
Translations_SFX =

Essa constante faz parte de uma API privada. Você deve evitar usar essa constante, se possível, pois ela pode ser removida ou alterada no futuro.

O sufixo para campos traduzidos gerados.

'_translations'

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Detalhes do método de classe

.database_field_name(nome, relações, aliased_fields, aliased_associations) ➤ string

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.

Obtenha o nome do campo fornecido conforme armazenado no banco de dados. Usado para determinar se o campo tem um nome alternativo ou não. Encontra recursivamente aliases para documentos e campos incorporados, delimitados por ponto "." personagem.

Observe que esse método retorna o nome das associações conforme elas são armazenadas no banco de dados, enquanto o hash relations usa seus aliases no código. Para verificar a associação no hash de relações, primeiro você teria que procurar a string retornada desse método no hash aliased_associations.

Este método não expandirá o alias de uma associação requires_to que não seja o último item. Por exemplo, se tivéssemos uma escola que has_many alunos, e o nome do campo passado fosse (da perspectiva do aluno):

school._id

O alias de uma associação requires_to é o campo _id desta associação. Portanto, expandir essa associação produziria:

school_id._id

Este não é o nome de campo correto, porque a intenção aqui não era obter uma propriedade do campo _id. A intenção era obter uma propriedade do document referenciado. Portanto, se uma parte do nome passado for uma associação requires_to que não seja a última parte do nome, não expandiremos seu alias e retornaremos:

school._id

Se a associação requires_to for a última parte do nome, passaremos de volta o campo _id .

Parâmetros:

  • name (string | Símbolo) —

    O nome a ser obtido.

  • relações (Hash) —

    As associações.

  • aliased_fields (Hash) —

    Os campos com nomes alternativos.

  • aliased_associations (Hash) —

    As associações com nomes alternativos.

Retorna:

  • (string) —

    O nome do campo conforme armazenado no banco de banco de dados.



411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
 
# Arquivo 'lib/mongoid/fields.rb', linha 411

def database_field_name(name, relações, aliased_fields, aliased_associations)
  Método '' a menos que name.presente?

  chave = name.to_s
  segmento, restante = chave.dividir('.', 2)

  # Não obtenha o alias para o campo quando uma associação requires_to
  # não é o último item. Portanto, obtenha o nome alternativo quando um dos
  # a seguir é verdadeiro:
  # 1. Este é o último item, ou seja, não há restante.
  # 2. Não é uma associação.
  # 3. Não é uma associação de domínio
  se !restante || !relações.chave?(segmento) || !relações[segmento].is_a?(associação::Referenciado::Pertence a)
    segmento = aliased_fields[segmento]&.dup || segmento
  end

  Método segmento a menos que restante

  relação = relações[aliased_associations[segmento] || segmento]
  se relação
    k = relação.classe
    "#{segment}.#{database_field_name(remaining, k.relationships, k.aliased_fields, k.aliased_associations)}"
  mais
    "#{segment}.#{remaining}"
  end
end

.opção(option_name, &block) ➤ Objeto

Armazena o bloco fornecido a ser executado quando o nome da opção especificado for definido em um campo.

Não é feita nenhuma suposição sobre a funcionalidade que o manipulador pode executar, portanto, ele sempre será chamado se a chave option_name for fornecida na definição de campo , mesmo que seja falsa ou nula.

Exemplos:

Mongoid::Fields.option :required do |model, field, value|
  model.validates_presence_of field if value
end

Parâmetros:

  • option_name (Símbolo) —

    o nome da opção a ser comparado

  • &block —

    o manipulador para executar quando a opção for fornecida.



294
295
296
 
# Arquivo 'lib/mongoid/fields.rb', linha 294

def opção(option_name, &noum: bloco ; verb: bloquear)
  opções[option_name] = noum: bloco ; verb: bloquear
end

.options ⇒ Hash

Retorne um mapa de nomes de opções personalizadas a seus manipuladores.

Exemplos:

Mongoid::Fields.options
# => { :required => #<Proc:0x00000100976b38> }

Retorna:

  • (Hash) —

    o mapa de opções



305
306
307
 
# Arquivo 'lib/mongoid/fields.rb', linha 305

def opções
  @opções ||= {}
end

.traverse_association_tree(chave, campos, associações, aliased_associations) {|O, O, Se| ... } ➤ Campo

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.

Percorra a árvore de associações e procure o campo para a chave fornecida. Para fazer isso, divisão a chave por '.' e para cada parte (met) da chave:

  • Se a meta for um campo, produza a meta, o campo e is_field como verdadeiros.
  • Se a meta for uma associação, atualize o klass para o klass da associação e produza a meta, klass e is_field como falsos.

A próxima iteração utilizará os campos e associações do klass para continuar atravessando a árvore.

Parâmetros:

  • chave (string) —

    A chave usada para pesquisar a árvore de associação.

  • Campos (Hash) —

    Os campos pelos quais iniciar a pesquisa.

  • Associações (Hash) —

    As associações com as quais iniciar a pesquisa.

  • aliased_associations (Hash) —

    As associações com nomes alternativos para iniciar a pesquisa.

  • &block —

    O bloco.

Parâmetros de rendimento:

  • O (Símbolo) —

    método atual.

  • O (Símbolo | string) —

    campo ou relação.

  • Se (verdadeiro | falso) —

    o segundo parâmetro de rendimento é um campo ou não.

Retorna:

  • (Campo) —

    O campo encontrado para a chave fornecida no final da pesquisa. Isso retornará nulo se a última coisa encontrada for uma associação ou nenhum campo for encontrado para a chave fornecida.



336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
 
# Arquivo 'lib/mongoid/fields.rb', linha 336

def traverse_association_tree(chave, Campos, Associações, aliased_associations)
  classe = nada
  Campo = nada
  chave.dividir('.').cada_com_index fazer |meth, i|
    fs = (i == 0) ? Campos : classe&.Campos
    rs = (i == 0) ? Associações : classe&.relações
    como = (i == 0) ? aliased_associations : classe&.aliased_associations

    # As associações podem ter duas "chaves", seu nome e seu alias.
    # O nome dos campos é o que é usado para armazená-lo nas relações do klass
    # e hashes de campo , e o alias é o que é usado para armazenar esse campo
    # no banco de banco de dados. A chave inserida para esta função é o nome alternativo
    # chave. Podemos convertê-los de volta para seus nomes procurando no
    # hash aliased_associations.
    aliased = meth
    se como && uma = como.buscar(meth, nada)
      aliased = uma.to_s
    end

    Campo = nada
    classe = nada
    se fs && f = fs[aliased]
      Campo = f
      rendimento(meth, f, true) se block_given?
    elsif rs && rel = rs[aliased]
      classe = rel.classe
      rendimento(meth, rel, false) se block_given?
    elsif block_given?
      rendimento(meth, nada, false)
    end
  end
  Campo
end

Detalhes do método de instância

#apply_default(name) ➤ Objeto

Aplica um único valor padrão para o nome fornecido.

Exemplos:

Aplique um único padrão.

model.apply_default("name")

Parâmetros:

  • name (string) —

    O nome do campo.



181
182
183
184
185
186
187
188
189
190
 
# Arquivo 'lib/mongoid/fields.rb', linha 181

def apply_default(name)
  Método se attributes.chave?(name)
  Método a menos que Campo = Campos[name]

  default = Campo.eval_default(auto)
  Método se default.nada? || Campo.preguiçoso?

  attribute_ will_change!(name)
  attributes[name] = default
end

#apply_defaults ➤ Objeto

Aplique todos os padrões de uma só vez.

Exemplos:

Aplique todos os padrões.

model.apply_defaults


196
197
198
199
200
 
# Arquivo 'lib/mongoid/fields.rb', linha 196

def apply_defaults
  pending_callbacks.excluir(:apply_defaults)
  apply_pre_processed_defaults
  apply_post_processed_defaults
end

#apply_post_processed_defaults ➤ Array<String>

Aplique todos os valores padrão ao documento que são procs.

Exemplos:

Aplique todos os padrões do proc.

model.apply_post_processed_defaults

Retorna:

  • (Array<String>) —

    Os nomes dos padrões do proc.



168
169
170
171
172
173
 
# Arquivo 'lib/mongoid/fields.rb', linha 168

def apply_post_processed_defaults
  pending_callbacks.excluir(:apply_post_processed_defaults)
  post_processed_defaults.cada fazer |name|
    apply_default(name)
  end
end

#apply_pre_processed_defaults ⇒ Array<String>

Aplique todos os valores padrão ao documento que não são procs.

Exemplos:

Aplique todos os padrões não relacionados ao processo.

model.apply_pre_processed_defaults

Retorna:

  • (Array<String>) —

    Os nomes dos padrões não relacionados ao proc.



156
157
158
159
160
 
# Arquivo 'lib/mongoid/fields.rb', linha 156

def apply_pre_processed_defaults
  pre_processed_defaults.cada fazer |name|
    apply_default(name)
  end
end

#variable_names ➤ Array<String>

Retorna uma array de nomes para os atributos disponíveis neste objeto.

Fornece os nomes dos campo de forma independente de ORM. Rails v3.1+ usa esse método para envolver automaticamente os parâmetros em solicitações JSON.

Exemplos:

Obtenha os nomes dos campos

document.attribute_names

Retorna:

  • (Array<String>) —

    Os nomes dos campo



211
212
213
 
# Arquivo 'lib/mongoid/fields.rb', linha 211

def Atributo_nomes
  auto.classe.Atributo_nomes
end

#database_field_name(name) ➤ string

Obtenha o nome do campo fornecido conforme armazenado no banco de dados. Usado para determinar se o campo tem um nome alternativo ou não.

Exemplos:

Obtenha o nome do campo do banco de dados de dados.

model.database_field_name(:authorization)

Parâmetros:

  • name (string | Símbolo) —

    O nome a ser obtido.

Retorna:

  • (string) —

    O nome do campo conforme armazenado no banco de dados.



224
225
226
 
# Arquivo 'lib/mongoid/fields.rb', linha 224

def database_field_name(name)
  auto.classe.database_field_name(name)
end

#dot_dollar_field?(nome) ➤ verdadeiro | false

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.

Este campo começa com um cifrão ($) ou contém um ponto/ponto final (.)?

Parâmetros:

  • name (string) —

    O nome do campo .

Retorna:

  • (verdadeiro | falso) —

    Se este campo estiver pontilhado ou em dólares.



260
261
262
263
 
# Arquivo 'lib/mongoid/fields.rb', linha 260

def dot_dollar_field?(name)
  n = aliased_fields[name] || name
  Campos.chave?(n) && (n.incluir?('.') || n.start_with?('$'))
end

#lazy_settable?(campo, valor) ➤ true | false

O campo fornecido é uma avaliação preguiçosa?

Exemplos:

Se o campo for de configuração lenta.

doc.lazy_settable?(field, nil)

Parâmetros:

  • Campo (Campo) —

    O campo.

  • valor (Objeto) —

    O valor atual.

Retorna:

  • (verdadeiro | falso) —

    Se definirmos o campo preguiçosamente.



237
238
239
 
# Arquivo 'lib/mongoid/fields.rb', linha 237

def lazy_settable?(Campo, valor)
  !congelado? && valor.nada? && Campo.preguiçoso?
end

#usando_object_ids? ➤ verdadeiro | false

Observação:

Refatorado do uso do delegado para o desempenho da carga de classe.

O documento está usando IDs de objeto ?

Exemplos:

O documento está usando IDs de objeto ?

model.using_object_ids?

Retorna:

  • (verdadeiro | falso) —

    Usando IDs de objeto .



249
250
251
 
# Arquivo 'lib/mongoid/fields.rb', linha 249

def usando_object_ids?
  auto.classe.usando_object_ids?
end

#validate_write_field_name!(nome) 3 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.

Valide se o campo começa ou não com um cifrão ($) ou contém um ponto/ponto final (.).

Parâmetros:

  • name (string) —

    O nome do campo .

Aumenta:

  • (InvalidDotDollarAssignment) —

    Se contém pontos ou começa com um dólar.



273
274
275
276
277
 
# Arquivo 'lib/mongoid/fields.rb', linha 273

def validate_write_field_name!(name)
  Método a menos que dot_dollar_field?(name)

  aumentar Errors::InvalidDotDollarAssignment.Novo(auto.classe, name)
end