Module: Mongoid::Association::Relatable

Includes:
Constrainable, Options
Included in:
Embedded::EmbeddedIn, Embedded::EmbedsMany, Embedded::EmbedsOne, Mongoid::Association::Referenced::BelongsTo, Mongoid::Association::Referenced::HasAndBelongsToMany, Mongoid::Association::Referenced::HasMany, Mongoid::Association::Referenced::HasOne
Defined in:
lib/mongoid/association/relatable.rb

Overview

This module provides behaviors shared between Association types.

Since:

  • 7.0

Constant Summary collapse

SHARED_OPTIONS =

The options shared between all association types.

Returns:

  • (Array<Symbol>) —

    The shared options.

Since:

  • 7.0

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

The primary key default.

Returns:

  • (String) —

    The primary key field default.

Since:

  • 7.0

'_id'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Options

#as, #autobuilding?, #autosave, #cascading_callbacks?, #counter_cached?, #cyclic?, #dependent, #forced_nil_inverse?, #indexed?, #inverse_of, #order, #polymorphic?, #primary_key, #store_as, #touch_field, #type

Methods included from Constrainable

#convert_to_foreign_key

Instance Attribute Details

#name ⇒ Symbol (readonly)

The name of the association.

Returns:

  • (Symbol) —

    The name of the relation.

Since:

  • 7.0



38
39
40
 
# File 'lib/mongoid/association/relatable.rb', line 38

def name
  @name
end

#options ⇒ Hash (readonly)

The options on this association.

Returns:

  • (Hash) —

    The options.

Since:

  • 7.0



45
46
47
 
# File 'lib/mongoid/association/relatable.rb', line 45

def options
  @options
end

Instance Method Details

#==(other) ⇒ Object

Compare this association to another.

Returns:

  • (Object) —

    The object to compare to this association.

Since:

  • 7.0



73
74
75
76
77
78
 
# File 'lib/mongoid/association/relatable.rb', line 73

def ==(other)
  relation_class_name == other.relation_class_name &&
    inverse_class_name == other.inverse_class_name &&
      name == other.name &&
        options == other.options
end

#bindable?(doc) ⇒ true, false

Whether trying to bind an object using this association should raise an error.

Parameters:

  • doc (Document) —

    The document to be bound.

Returns:

  • (true, false) —

    Whether the document can be bound.

Since:

  • 7.0



110
 
# File 'lib/mongoid/association/relatable.rb', line 110

def bindable?(doc); false; end

#counter_cache_column_name ⇒ String

Get the counter cache column name.

Returns:

  • (String) —

    The counter cache column name.

Since:

  • 7.0



328
329
330
331
332
 
# File 'lib/mongoid/association/relatable.rb', line 328

def counter_cache_column_name
  @counter_cache_column_name ||= (@options[:counter_cache].is_a?(String) ||
      @options[:counter_cache].is_a?(Symbol)) ?
      @options[:counter_cache] : "#{inverse || inverse_class_name.demodulize.underscore.pluralize}_count"
end

#create_relation(owner, target) ⇒ Proxy

Create a relation proxy object using the owner and target.

Parameters:

  • owner (Document) —

    The document this relation hangs off of.

  • target (Document, Array<Document>) —

    The target (parent) of the relation.

Returns:

Since:

  • 7.0



310
311
312
 
# File 'lib/mongoid/association/relatable.rb', line 310

def create_relation(owner, target)
  relation.new(owner, target, self)
end

#destructive? ⇒ true, false

Whether the dependent method is destructive.

Returns:

  • (true, false) —

    If the dependent method is destructive.

Since:

  • 7.0



319
320
321
 
# File 'lib/mongoid/association/relatable.rb', line 319

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

#extension ⇒ Module

Get the extension.

Returns:

  • (Module) —

    The extension module, if one has been defined.

Since:

  • 7.0



339
340
341
 
# File 'lib/mongoid/association/relatable.rb', line 339

def extension
  @extension ||= @options[:extend]
end

#foreign_key_check ⇒ String

Get the name of the method to check if the foreign key has changed.

Examples:

Get the foreign key check method.

association.foreign_key_check

Returns:

  • (String) —

    The foreign key check.

Since:

  • 7.0



297
298
299
 
# File 'lib/mongoid/association/relatable.rb', line 297

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

#foreign_key_setter ⇒ String

The name of the foreign key setter method.

Returns:

  • (String) —

    The name of the foreign key setter.

Since:

  • 7.0



261
262
263
264
265
 
# File 'lib/mongoid/association/relatable.rb', line 261

def foreign_key_setter
  # note: You can't check if this association stores foreign key
  # See HasOne and HasMany binding, they referenced foreign_key_setter
  @foreign_key_setter ||= "#{foreign_key}=" if foreign_key
end

#get_callbacks(callback_type) ⇒ Array<Proc, Symbol>

Get the callbacks for a given type.

Parameters:

  • callback_type (Symbol) —

    The type of callback type.

Returns:

  • (Array<Proc, Symbol>) —

    A list of the callbacks, either method names or Procs.

Since:

  • 7.0



88
89
90
 
# File 'lib/mongoid/association/relatable.rb', line 88

def get_callbacks(callback_type)
  Array(options[callback_type])
end

#initialize(_class, name, opts = {}, &block) ⇒ Object

Initialize the Association.

Parameters:

  • _class (Class) —

    The class of the model who owns this relation.

  • name (Symbol) —

    The name of the association.

  • opts (Hash) (defaults to: {}) —

    The relation options.

  • block (Block) —

    The optional block.

Since:

  • 7.0



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/mongoid/association/relatable.rb', line 55

def initialize(_class, name, opts = {}, &block)
  @owner_class = _class
  @name = name
  @options = opts
  @extension = nil

  @module_path = _class.name ? _class.name.split('::')[0..-2].join('::') : ''
  @module_path << '::' unless @module_path.empty?

  create_extension!(&block)
  validate!
end

#inverse(other = nil) ⇒ Symbol

Get the inverse name.

Returns:

  • (Symbol) —

    The inverse name.

Since:

  • 7.0



348
349
350
351
 
# File 'lib/mongoid/association/relatable.rb', line 348

def inverse(other = nil)
  candidates = inverses(other)
  candidates.detect { |c| c } if candidates
end

#inverse_association(other = nil) ⇒ Association

Get the inverse’s association metadata.

Parameters:

  • other (Object) (defaults to: nil) —

    The other model class or model object to use when determining inverses.

Returns:

  • (Association) —

    The inverse’s association metadata.

Since:

  • 7.0



137
138
139
 
# File 'lib/mongoid/association/relatable.rb', line 137

def inverse_association(other = nil)
  (other || relation_class).relations[inverse(other)]
end

#inverse_class ⇒ String Also known as: inverse_klass

The class of the object owning this relation.

Returns:

  • (String) —

    The owning objects’ class.

Since:

  • 7.0



223
224
225
 
# File 'lib/mongoid/association/relatable.rb', line 223

def inverse_class
  @owner_class
end

#inverse_class_name ⇒ String

The class name of the object owning this relation.

Returns:

  • (String) —

    The owning objects’ class name.

Since:

  • 7.0



214
215
216
 
# File 'lib/mongoid/association/relatable.rb', line 214

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

#inverse_setter(other = nil) ⇒ String

The name of the inverse setter method.

Returns:

  • (String) —

    The name of the inverse setter.

Since:

  • 7.0



252
253
254
 
# File 'lib/mongoid/association/relatable.rb', line 252

def inverse_setter(other = nil)
  @inverse_setter ||= "#{inverses(other).first}=" unless inverses(other).blank?
end

#inverse_type ⇒ nil

Get the inverse type.

Returns:

  • (nil) —

    Default is nil for an association.

Since:

  • 7.0



146
 
# File 'lib/mongoid/association/relatable.rb', line 146

def inverse_type; end

#inverse_type_setter ⇒ String

Gets the setter for the field that sets the type of document on a polymorphic relation.

Examples:

Get the inverse type setter.

association.inverse_type_setter

Returns:

  • (String) —

    The name of the setter.

Since:

  • 7.0



285
286
287
 
# File 'lib/mongoid/association/relatable.rb', line 285

def inverse_type_setter
  @inverse_type_setter ||= inverse_type.__setter__
end

#inverses(other = nil) ⇒ Array<Symbol>

Get the inverse names.

Parameters:

  • other (Object) (defaults to: nil) —

    The other model class or model object to use when determining inverses.

Returns:

  • (Array<Symbol>) —

    The list of inverse names.

Since:

  • 7.0



120
121
122
123
124
125
126
127
 
# File 'lib/mongoid/association/relatable.rb', line 120

def inverses(other = nil)
  return [ inverse_of ] if inverse_of
  if polymorphic?
    polymorphic_inverses(other)
  else
    determine_inverses(other)
  end
end

#key ⇒ Symbol, String

The foreign key field if this relation stores a foreign key. Otherwise, the primary key.

Returns:

  • (Symbol, String) —

    The primary key.

Since:

  • 7.0



234
235
236
 
# File 'lib/mongoid/association/relatable.rb', line 234

def key
  stores_foreign_key? ? foreign_key : primary_key
end

#path(document) ⇒ Mongoid::Atomic::Paths::Root

The atomic path for this relation.

Returns:

Since:

  • 7.0



272
273
274
 
# File 'lib/mongoid/association/relatable.rb', line 272

def path(document)
  relation.path(document)
end

#relation_class ⇒ String Also known as: klass

The class of the relation object(s).

This method returns the class instance corresponding to relation_class_name, resolved relative to the host document class.

If the class does not exist, this method raises NameError. This can happen because the target class has not yet been defined. Note that polymorphic associations generally do not have a well defined target class because the target class can change from one object to another, and calling this method on a polymorphic association will generally fail with a NameError or produce misleading results (if a class does happen to be defined with the same name as the association name).

Returns:

  • (String) —

    The association objects’ class.

Since:

  • 7.0



201
202
203
204
205
206
 
# File 'lib/mongoid/association/relatable.rb', line 201

def relation_class
  @klass ||= begin
    cls_name = @options[:class_name] || ActiveSupport::Inflector.classify(name)
    resolve_name(inverse_class, cls_name)
  end
end

#relation_class_name ⇒ String Also known as: class_name

Note:

The return value of this method should not be used to determine whether two associations have the same target class, because the return value is not always a fully qualified class name. To compare classes, retrieve the class instance of the association target using the relation_class method.

The class name of the relation object(s).

The class name may be fully qualified or may be specified relative to the class on which the association is defined (this class is accessible as inverse_class). If :class_name option is given in the association, the exact value of that option is returned here for backwards compatibility reasons. If :class_name option is not given, the name of the class computed by Mongoid to be the association target is returned, and it will be fully qualified.

The class name returned by this method may not correspond to a defined class. The return value of the method is the class name that Mongoid would reference, relative to the host document class, when it needs to perform operations on the association target.

Returns:

  • (String) —

    The association objects’ class name.

Since:

  • 7.0



172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/mongoid/association/relatable.rb', line 172

def relation_class_name
  @class_name ||= @options[:class_name] || begin
    cls_name = ActiveSupport::Inflector.classify(name)
    begin
      cls_name = resolve_name(inverse_class, cls_name).name
    rescue NameError
      # ignore
    end
    cls_name
  end
end

#setter ⇒ String

The name of the setter on this object for assigning an associated object.

Returns:

  • (String) —

    The setter name.

Since:

  • 7.0



243
244
245
 
# File 'lib/mongoid/association/relatable.rb', line 243

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

#type_setter ⇒ String

Note:

Only relevant for polymorphic relations that take the :as option.

Get the type setter.

Returns:

  • (String) —

    The type setter method.

Since:

  • 7.0



98
99
100
 
# File 'lib/mongoid/association/relatable.rb', line 98

def type_setter
  @type_setter ||= type.__setter__
end

#validate? ⇒ true, false

Whether the associated object(s) should be validated.

Returns:

  • (true, false) —

    If the associated object(s) should be validated.

Since:

  • 7.0



359
360
361
362
363
364
365
 
# File 'lib/mongoid/association/relatable.rb', line 359

def validate?
  @validate ||= if @options[:validate].nil?
                  validation_default
                else
                  !!@options[:validate]
                end
end