Módulo: Mongoid::Fields

Estendido por:
ActiveSupport::Concern
Incluído em:
Componível
Definido em:
build/mongoid-8.1/lib/mongoid/fields.rb,
build/mongoid-8.1/lib/mongoid/fields/standard.rb,
build/mongoid-8.1/lib/mongoid/fields/localized.rb,
build/mongoid-8.1/lib/mongoid/fields/foreign_key.rb,
build/mongoid-8.1/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: 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

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.

  • alaiased_fields (Hash)

    Os campos com nomes alternativos.

  • alaiased_associations (Hash)

    As associações com nomes alternativos.

Retorna:

  • (string)

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



407
408
409
410
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
437
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 407

def database_field_name(name, relações, aliased_fields, aliased_associations)
  se Mongoid.broken_alias_handling
    Método nada a menos que name
    Normalizado = name.to_s
    aliased_fields[Normalizado] || Normalizado
  mais
    Método nada 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
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

  • noum: bloco ; verb: bloquear (Proc)

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



292
293
294
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 292

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

.optionsHash

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



303
304
305
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 303

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

.traverse_association_tree(chave, campos, associações, aliased_associations) ➤ 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 disponíveis para iniciar a pesquisa.

  • noum: bloco ; verb: bloquear (Proc)

    O bloco contém três parâmetros, a meta atual, o campo ou a relação, e se o segundo parâmetro é 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.



332
333
334
335
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
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 332

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.



176
177
178
179
180
181
182
183
184
185
186
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 176

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


192
193
194
195
196
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 192

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.



163
164
165
166
167
168
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 163

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



151
152
153
154
155
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 151

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

#variable_namesArray<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



207
208
209
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 207

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.



220
221
222
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 220

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.



256
257
258
259
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 256

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.



233
234
235
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 233

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 .



245
246
247
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 245

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.



269
270
271
272
273
# Arquivo 'build/mongoid-8.1/lib/mongoid/fields.rb', linha 269

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