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.

%i[
  class_name
  inverse_of
  validar
  ampliar
].congelar
PRIMARY_KEY_DEFAULT =

O padrão da chave primária.

Retorna:

  • (string) —

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

'_id'

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.



31
32
33
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 31

def name
  @name
end

#opções ➤ Hash (somente leitura)

As opções nesta associação.

Retorna:

  • (Hash) —

    As opções.



36
37
38
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 36

def opções
  @opções
end

#proprietário_class ➤ Classe (somente leitura)

A classe que possui esta associação.

Retorna:

  • (Classe) —

    A classe do proprietário.



41
42
43
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 41

def proprietário_class
  @ Owner_class
end

#parent_inclusions ➤ Array<String>

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

Retorna:

  • (Array<String>) —

    As associações.



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

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.



65
66
67
68
69
70
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 65

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) ➤ true | 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.



96
97
98
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 96

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.



275
276
277
278
279
280
281
282
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 275

def counter_cache_column_name
  @counter_cache_column_name ||= se @opções[:counter_cache].is_a?(String) ||
                                    @opções[:counter_cache].is_a?(Símbolo)
                                   @opções[:counter_cache]
                                 mais
                                   "#{inverse || inverse_class_name.demofulize.sublinhado.pluralize}_count"
                                 end
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:



261
262
263
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 261

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.



268
269
270
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 268

def destrutivo?
  @destructive ||= !!(dependente && %i[delete_all destruir].incluir?(dependente))
end

#extensão ➤ Módulo

Obtenha a extensão.

Retorna:

  • (Módulo) —

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



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

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.



250
251
252
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 250

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.



220
221
222
223
224
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 220

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.



78
79
80
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 78

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.



341
342
343
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 341

def in_to?
  [ Referenciado::Pertence a, Embedded::Incorporado em ].algum? { |uma| 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.



49
50
51
52
53
54
55
56
57
58
59
60
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 49

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.



294
295
296
297
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 294

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:



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

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.



190
191
192
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 190

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.



183
184
185
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 183

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.



213
214
215
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 213

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.



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

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.



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

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.



106
107
108
109
110
111
112
113
114
115
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 106

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.



199
200
201
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 199

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.



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

def muitos?
  [ Referenciado::Tem muitos, Embedded::Incorpora muitos ].algum? { |uma| 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.



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

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

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

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

Retorna:



229
230
231
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 229

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 .



172
173
174
175
176
177
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 172

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.



153
154
155
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 153

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.



206
207
208
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 206

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.



86
87
88
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 86

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.



303
304
305
306
307
308
309
 
# Arquivo 'lib/mongoid/association/relatable.rb', linha 303

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