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 mais...

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 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 documento 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.

[Ver fonte]

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

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.

Nenhuma suposição é feita sobre a funcionalidade que o manipulador pode executar, portanto, ele sempre será chamado se a chave 'option_name' for fornecida na definição do 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.

[Ver fonte]

298
299
300
 
# Arquivo 'lib/mongoid/fields.rb', linha 298

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

[Ver fonte]

309
310
311
 
# Arquivo 'lib/mongoid/fields.rb', linha 309

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.

[Ver fonte]

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
369
370
371
372
 
# Arquivo 'lib/mongoid/fields.rb', linha 340

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?
    mais
      rendimento(meth, nada, false) se block_given?
    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.

[Ver fonte]

183
184
185
186
187
188
189
190
191
192
193
 
# Arquivo 'lib/mongoid/fields.rb', linha 183

def apply_default(name)
  a menos que attributes.chave?(name)
    se Campo = Campos[name]
      default = Campo.eval_default(auto)
      a menos que default.nada? || Campo.preguiçoso?
        attribute_ will_change!(name)
        attributes[name] = default
      end
    end
  end
end

#apply_defaults ➤ Objeto

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

Exemplos:

Aplique todos os padrões.

model.apply_defaults
[Ver fonte]

199
200
201
202
203
 
# Arquivo 'lib/mongoid/fields.rb', linha 199

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.

[Ver fonte]

170
171
172
173
174
175
 
# Arquivo 'lib/mongoid/fields.rb', linha 170

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.

[Ver fonte]

158
159
160
161
162
 
# Arquivo 'lib/mongoid/fields.rb', linha 158

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

[Ver fonte]

214
215
216
 
# Arquivo 'lib/mongoid/fields.rb', linha 214

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.

[Ver fonte]

227
228
229
 
# Arquivo 'lib/mongoid/fields.rb', linha 227

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.

[Ver fonte]

263
264
265
266
 
# Arquivo 'lib/mongoid/fields.rb', linha 263

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.

[Ver fonte]

240
241
242
 
# Arquivo 'lib/mongoid/fields.rb', linha 240

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 .

[Ver fonte]

252
253
254
 
# Arquivo 'lib/mongoid/fields.rb', linha 252

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.

[Ver fonte]

276
277
278
279
280
 
# Arquivo 'lib/mongoid/fields.rb', linha 276

def validate_write_field_name!(name)
  se dot_dollar_field?(name)
    aumentar Errors::InvalidDotDollarAssignment.Novo(auto.classe, name)
  end
end