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.

Constant Summary collapse

SHARED_OPTIONS =

The options shared between all association types.

Returns:

  • (Array<Symbol>) —

    The shared options.

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

The primary key default.

Returns:

  • (String) —

    The primary key field default.

'_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, #touchable?, #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 association.



33
34
35
 
# File 'lib/mongoid/association/relatable.rb', line 33

def name
  @name
end

#options ⇒ Hash (readonly)

The options on this association.

Returns:

  • (Hash) —

    The options.



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

def options
  @options
end

#parent_inclusions ⇒ Array<String>

The associations above this one in the inclusion tree.

Returns:

  • (Array<String>) —

    The associations.



306
307
308
 
# File 'lib/mongoid/association/relatable.rb', line 306

def parent_inclusions
  @parent_inclusions
end

Instance Method Details

#==(other) ⇒ Object

Compare this association to another.

Returns:

  • (Object) —

    The object to compare to this association.



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

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.



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

def bindable?(doc); false; end

#counter_cache_column_name ⇒ String

Get the counter cache column name.

Returns:

  • (String) —

    The counter cache column name.



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

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 an association proxy object using the owner and target.

Parameters:

  • owner (Document) —

    The document this association hangs off of.

  • target (Document | Array<Document>) —

    The target (parent) of the association.

Returns:



256
257
258
 
# File 'lib/mongoid/association/relatable.rb', line 256

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.



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

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.



279
280
281
 
# File 'lib/mongoid/association/relatable.rb', line 279

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.



245
246
247
 
# File 'lib/mongoid/association/relatable.rb', line 245

def foreign_key_check
  @foreign_key_check ||= "#{foreign_key}_previously_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.



215
216
217
218
219
 
# File 'lib/mongoid/association/relatable.rb', line 215

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.



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

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

#in_to? ⇒ true | false

Is this association an embedded_in or belongs_to association?

Returns:

  • (true | false) —

    true if it is an embedded_in or belongs_to association, false if not.



333
334
335
 
# File 'lib/mongoid/association/relatable.rb', line 333

def in_to?
  [Referenced::BelongsTo, Embedded::EmbeddedIn].any? { |a| self.is_a?(a) }
end

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

Initialize the Association.

Parameters:

  • _class (Class) —

    The class of the model who owns this association.

  • name (Symbol) —

    The name of the association.

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

    The association options.

  • block (Block) —

    The optional block.



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

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.



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

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

#inverse_association(other = nil) ⇒ Mongoid::Association::Relatable

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:



118
119
120
 
# File 'lib/mongoid/association/relatable.rb', line 118

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

Returns:

  • (String) —

    The owning objects’ class.



185
186
187
 
# File 'lib/mongoid/association/relatable.rb', line 185

def inverse_class
  @owner_class
end

#inverse_class_name ⇒ String

The class name of the object owning this association.

Returns:

  • (String) —

    The owning objects’ class name.



178
179
180
 
# File 'lib/mongoid/association/relatable.rb', line 178

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.



208
209
210
 
# File 'lib/mongoid/association/relatable.rb', line 208

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.



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

def inverse_type; end

#inverse_type_setter ⇒ String

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

Examples:

Get the inverse type setter.

association.inverse_type_setter

Returns:

  • (String) —

    The name of the setter.



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

def inverse_type_setter
  @inverse_type_setter ||= "#{inverse_type}=" if inverse_type
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.



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

def inverses(other = nil)
  return [ inverse_of ] if inverse_of
  return [] if @options.key?(:inverse_of) && !inverse_of

  if polymorphic?
    polymorphic_inverses(other)
  else
    determine_inverses(other)
  end
end

#key ⇒ Symbol | String

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

Returns:

  • (Symbol | String) —

    The primary key.



194
195
196
 
# File 'lib/mongoid/association/relatable.rb', line 194

def key
  stores_foreign_key? ? foreign_key : primary_key
end

#many? ⇒ true | false

Is this association an embeds_many or has_many association?

Returns:

  • (true | false) —

    true if it is a *_many association, false if not.



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

def many?
  [Referenced::HasMany, Embedded::EmbedsMany].any? { |a| self.is_a?(a) }
end

#one? ⇒ true | false

Is this association an embeds_one or has_one association?

Returns:

  • (true | false) —

    true if it is a *_one association, false if not.



325
326
327
 
# File 'lib/mongoid/association/relatable.rb', line 325

def one?
  [Referenced::HasOne, Embedded::EmbedsOne].any? { |a| self.is_a?(a) }
end

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

The atomic path for this association.

Returns:



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

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

#relation_class ⇒ String Also known as: klass

The class of the association 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.



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

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, possibly unqualified or

prefixed, of the association

object(s).

This method returns the class name as it is used in the association definition. If :class_name option is given in the association, the exact value of that option is returned here. If :class_name option is not given, the name of the class is calculated from association name but is not resolved to the actual class.

The class name returned by this method may not correspond to a defined class, either because the corresponding class has not been loaded yet, or because the association references a non-existent class altogether. To obtain the association class, use relation_class method.

Returns:

  • (String) —

    The association objects’ class name.



148
149
150
 
# File 'lib/mongoid/association/relatable.rb', line 148

def relation_class_name
  @class_name ||= @options[:class_name] || ActiveSupport::Inflector.classify(name)
end

#setter ⇒ String

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

Returns:

  • (String) —

    The setter name.



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

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

#type_setter ⇒ String

Note:

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

Get the type setter.

Returns:

  • (String) —

    The type setter method.



83
84
85
 
# File 'lib/mongoid/association/relatable.rb', line 83

def type_setter
  @type_setter ||= "#{type}=" if type
end

#validate? ⇒ true | false

Whether the associated object(s) should be validated.

Returns:

  • (true | false) —

    If the associated object(s) should be validated.



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

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