Módulo: Mongoid::Association::Relatable

Inclui:
Restrita, opções
Incluído em:
Embedded::EmbeddedIn, Embedded::EmbedsMany, Embedded::EmbedsOne, Mongoid::Association::Referenced::BelongsTo, Mongoid::Association::Referenced::HasAndBelongsToMany, Mongoid::Association::Referenced::HasMany, Mongoid: :Association::Referenced::HasOne
Definido em:
lib/mongoid/association/relatable.rb

Visão geral

Este módulo fornece comportamentos compartilhados entre tipos de associação.

Colapsode resumo constante

SHARED_OPTIONS =

As opções compartilhadas entre todos os tipos de associação.

Retorna:

  • (Array<Símbolo><Symbol>) —

    As opções compartilhadas.

[
  :class_name,
  :inverse_of,
  :validate,
  :extend
].congelar
PRIMARY_KEY_DEFAULT =

O padrão da chave primária.

Retorna:

  • (string) —

    O padrão do campo de chave primária.

'_id'.congelar

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de instância

Métodos incluídos em Opções

#as, #autoconstrução?, #autosave, #cascadeing_callbacks?, #counter_cached?, #cíclica?, #depende, #forced_nil_inverse?, #indexado?, #inverse_of, #order, #polymorphic?. , #type

Métodos incluídos no Constrainable

#convert_to_foreign_key

Detalhes do atributo da instância

#name ➤ Símbolo (somente leitura)

O nome da associação.

Retorna:

  • (Símbolo) —

    O nome da associação.



33
34
35
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 33

def name
  @name
end

#opções ➤ Hash (somente leitura)

As opções nesta associação.

Retorna:

  • (Hash) —

    As opções.



38
39
40
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 38

def opções
  @opções
end

#parent_inclusions ➤ Array<String>

As associações acima desta na árvore de inclusão.

Retorna:

  • (Array<String>) —

    As associações.



306
307
308
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 306

def parent_incluses
  @parent_incluses
end

Detalhes do método de instância

#==(outro) ➤ Objeto

Compare esta associação com outra.

Retorna:

  • (Objeto) —

    O objeto para comparar com esta associação.



62
63
64
65
66
67
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 62

def ==(Outro)
  relação_class_name == Outro.relação_class_name &&
    inverse_class_name == Outro.inverse_class_name &&
      name == Outro.name &&
        opções == Outro.opções
end

#vinculável?(doc) ➤ verdadeiro | false

Se a tentativa de vincular um objeto usando essa associação deve gerar um erro.

Parâmetros:

  • doc (Documento) —

    O documento a ser vinculado.

Retorna:

  • (verdadeiro | falso) —

    Se o documento pode ser vinculado.



93
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 93

def vinculável?(doc); false; end

count string

Obtenha o nome da coluna de cache do contador.

Retorna:

  • (string) —

    O nome da coluna de cache do contador.



270
271
272
273
274
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 270

def counter_cache_column_name
  @counter_cache_column_name ||= (@opções[:counter_cache].is_a?(String) ||
      @opções[:counter_cache].is_a?(Símbolo)) ?
      @opções[:counter_cache] : "#{inverse || inverse_class_name.demofulize.sublinhado.pluralize}_count"
end

#create_relation(dono, destino) ➤ Proxy

Crie um objeto proxy de associação usando o proprietário e o destino.

Parâmetros:

  • Proprietário(a) (Documento) —

    O documento do qual esta associação depende.

  • Alvo (Documento | Array <Documento>) —

    O destino (principal) da associação.

Retorna:



256
257
258
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 256

def create_relation(Proprietário(a), Alvo)
  relação.Novo(Proprietário(a), Alvo, auto)
end

#destrutivo? ➤ verdadeiro | false

Se o método dependente é destrutivo.

Retorna:

  • (verdadeiro | falso) —

    Se o método dependente for destrutivo.



263
264
265
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 263

def destrutivo?
  @destructive ||= !!(dependente && (dependente == :delete_all || dependente == :destroy))
end

#extensão ➤ Módulo

Obtenha a extensão.

Retorna:

  • (Módulo) —

    O módulo de extensão, se houver.



279
280
281
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 279

def extensão
  @extensão ||= @opções[:extend]
end

#foreign_key_check ➤ string

Obtenha o nome do método para verificar se a chave estrangeira foi alterada.

Exemplos:

Obtenha o método de verificação de chave estrangeira.

association.foreign_key_check

Retorna:

  • (string) —

    A verificação de chave estrangeira.



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

def foreign_key_check
  @foreign_key_check ||= "#{foreign_key}_previously_changed?" se (stores_foreign_key? && foreign_key)
end

#foreign_key_setter ➤ string

O nome do método definidor de chave estrangeira.

Retorna:

  • (string) —

    O nome do setter de chave estrangeira.



215
216
217
218
219
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 215

def foreign_key_setter
  # nota: não é possível verificar se esta associação armazena chave estrangeira
  # Veja a ligação HasOne e HasMany, elas referenciaram foreign_key_setter
  @foreign_key_setter ||= "#{foreign_key}=" se foreign_key
end

#get_callbacks(callback_type) ➤ Array<Proc | Símbolo>

Obtenha as chamadas de resposta para um determinado tipo.

Parâmetros:

  • callback_type (Símbolo) —

    O tipo de chamada de resposta.

Retorna:

  • (Array <Proc | Símbolo>) —

    Uma lista dos retornos de chamada, nomes de método ou Procs.



75
76
77
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 75

def get_callbacks(callback_type)
  Array(opções[callback_type])
end

#in_to? ➤ verdadeiro | false

Esta associação é uma associação embedded_in ou requires_to?

Retorna:

  • (verdadeiro | falso) —

    true se for uma associação embedded_in ou requires_to, false se não for.



333
334
335
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 333

def in_to?
  [Referenciado::Pertence a, Embedded::Incorporado em].algum? { |uma| auto.is_a?(uma) }
end

#inicializar(_class, nome, opts = {}, &block) ➤ Objeto

Inicialize a associação.

Parâmetros:

  • _class (Classe) —

    A classe do modelo que possui esta associação.

  • name (Símbolo) —

    O nome da associação.

  • opciona (Hash) (padrão para: {}) —

    As opções de associação.

  • noum: bloco ; verb: bloquear (Bloco) —

    O bloco opcional.



46
47
48
49
50
51
52
53
54
55
56
57
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 46

def inicializar(_class, name, opciona = {}, &noum: bloco ; verb: bloquear)
  @ Owner_class = _class
  @name = name
  @opções = opciona
  @extensão = nada

  @module_path = _class.name ? _class.name.dividir('::')[0..-2].juntar('::') : ''
  @module_path << '::' a menos que @module_path.vazio?

  create_extention!(&noum: bloco ; verb: bloquear)
  validar!
end

#inverso(outro = nil) ➤ Símbolo

Obtenha o nome inverso.

Retorna:

  • (Símbolo) —

    O nome inverso.



286
287
288
289
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 286

def inverso(Outro = nada)
  candidatos = inversos(Outro)
  candidatos.detectar { |C| C } se candidatos
end

#inverse_association(OTHER = nil) ➤ Mongoid::Association::Relatable

Obtenha os metadados de associação do inverso.

Parâmetros:

  • Outro (Objeto) (padrão para: nil) —

    A outra classe de modelo ou objeto de modelo a ser usado ao determinar inversas.

Retorna:



118
119
120
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 118

def inverse_association(Outro = nada)
  (Outro || concern_class).relações[inverso(Outro)]
end

#inverse_class ➤ string Também conhecido como: inverse_klass

A classe do objeto que possui esta associação.

Retorna:

  • (string) —

    A classe de objetos proprietários.



185
186
187
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 185

def inverse_class
  @ Owner_class
end

#inverse_class_name ➤ string

O nome da classe do objeto que possui esta associação.

Retorna:

  • (string) —

    O nome da classe dos objetos proprietários.



178
179
180
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 178

def inverse_class_name
  @inverse_class_name ||= @ Owner_class.name
end

#inverse_setter(outro = nil) ➤ string

O nome do método setter inverso.

Retorna:

  • (string) —

    O nome do setter inverso.



208
209
210
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 208

def inverse_setter(Outro = nada)
  @inverse_setter ||= "#{inversos(outro).primeiro}=" a menos que inversos(Outro).em branco?
end

#inverse_type ➤ nil

Obtenha o tipo inverso.

Retorna:

  • (nil) —

    O padrão é nulo para uma associação.



125
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 125

def inverse_type; end

#inverse_type_setter ➤ string

Obtém o configurador para o campo que define o tipo de documento em uma associação polimórfica.

Exemplos:

Obtenha o configurador de tipo inverso.

association.inverse_type_setter

Retorna:

  • (string) —

    O nome do configurador.



235
236
237
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 235

def inverse_type_setter
  @inverse_type_setter ||= "#{inverse_type}=" se inverse_type
end

#inversos(outros = nil) ➤ Array<Símbolo><Symbol>

Obtenha os nomes inversos.

Parâmetros:

  • Outro (Objeto) (padrão para: nil) —

    A outra classe de modelo ou objeto de modelo a ser usado ao determinar inversas.

Retorna:

  • (Array<Símbolo><Symbol>) —

    A lista de nomes inversos.



101
102
103
104
105
106
107
108
109
110
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 101

def inversos(Outro = nada)
  Método [ inverse_of ] se inverse_of
  Método [] se @opções.chave?(:inverse_of) && !inverse_of

  se polimórfico?
    polymorphic_inverses(Outro)
  mais
    determinar_inverses(Outro)
  end
end

#chave ➤ Símbolo | string

O campo de chave estrangeira se esta associação armazenar uma chave estrangeira. Caso contrário, a chave primária.

Retorna:

  • (Símbolo | string) —

    A chave primária.



194
195
196
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 194

def chave
  stores_foreign_key? ? foreign_key : primary_key
end

#muitos? ➤ verdadeiro | false

Esta associação é uma associação embeds_many ou has_many?

Retorna:

  • (verdadeiro | falso) —

    true se for uma associação *_many; false se não for.



318
319
320
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 318

def muitos?
  [Referenciado::Tem muitos, Embedded::Incorpora muitos].algum? { |uma| auto.is_a?(uma) }
end

#um? ➤ verdadeiro | false

Esta associação é uma associação embeds_one ou has_one?

Retorna:

  • (verdadeiro | falso) —

    true se for uma associação *_one, false se não for.



325
326
327
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 325

def um?
  [Referenciado::Tem um, Embedded::Incorpora um].algum? { |uma| auto.is_a?(uma) }
end

#caminho(documento) ➤ Mongoid::Atomic::Paths::Root

O caminho atômico para esta associação.

Retorna:



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

def caminho(documento)
  relação.caminho(documento)
end

#concern_class ➤ string Também conhecido como: klass

A classe do(s) objeto(s) de associação.

Este método retorna a instância de classe correspondente a relation_class_name, resolvido em relação à classe do documento host.

Se a classe não existir, esse método gerará NameError. Isso pode acontecer porque a classe de destino ainda não foi definida. Observe que associações polimórficas geralmente não têm uma classe de destino bem definida porque a classe de destino pode mudar de um objeto para outro, e chamar esse método em uma associação polimórfica geralmente falhará com um NameError ou produzirá resultados enganosos (se uma classe acontecer de ser definido com o mesmo nome que o nome da associação).

Retorna:

  • (string) —

    A classe de objetos de associação.



167
168
169
170
171
172
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 167

def concern_class
  @klass ||= começar
    cls_name = @opções[:class_name] || ActiveSupport::Infletor.classificar(name)
    resolve_name(inverse_class, cls_name)
  end
end

#relacional_class_name ➤ string Também conhecido como: class_name

Observação:

O valor de retorno deste método não deve ser utilizado para determinar se duas associações têm a mesma classe de destino, pois o valor de retorno nem sempre é um nome de classe totalmente qualificado. Para comparar classes, recupere a instância de classe do destino de associação utilizando o método relation_class .

O nome da classe, possivelmente não qualificado ou

prefixado, da associação

objeto(s).

Este método retorna o nome da classe conforme ele é usado na definição da associação. Se a opção :class_name for fornecida na associação, o valor exato dessa opção será retornado aqui. Se a opção :class_name não for fornecida, o nome da classe será calculado a partir do nome da associação, mas não será resolvido para a classe real.

O nome da classe retornado por esse método pode não corresponder a uma classe definida, porque a classe correspondente ainda não foi carregada ou porque a associação faz referência a uma classe inexistente completamente. Para obter a classe de associação, use o método relation_class .

Retorna:

  • (string) —

    O nome da classe dos objetos de associação.



148
149
150
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 148

def relação_class_name
  @class_name ||= @opções[:class_name] || ActiveSupport::Infletor.classificar(name)
end

#setter ➤ string

O nome do setter neste objeto para atribuir um objeto associado.

Retorna:

  • (string) —

    O nome do setter.



201
202
203
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 201

def setter
  @setter ||= "#{name}="
end

#type_setter ➤ string

Observação:

Relevante apenas para associações polimórficas que aceitam a opção :as.

Obtenha o configurador de tipos.

Retorna:

  • (string) —

    O método definidor de tipos.



83
84
85
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 83

def type_setter
  @type_setter ||= "#{tipo}=" se type
end

#validar? ➤ verdadeiro | false

Se o(s) objeto(s) associado(s) deve(m) ser validado(s).

Retorna:

  • (verdadeiro | falso) —

    Se o(s) objeto(s) associado(s) deverá(ão) ser validados.



295
296
297
298
299
300
301
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 295

def validar?
  @validate ||= se @opções[:validate].nada?
                  validation_default
                mais
                  !!@opções[:validate]
                end
end