class Mongoid::Relations::Metadata

The “Grand Poobah” of information about any relation is this class. It contains everything you could ever possible want to know.

Public Class Methods

new(properties = {}) click to toggle source

Instantiate new metadata for a relation.

@example Create the new metadata.

Metadata.new(:name => :addresses)

@param [ Hash ] properties The relation options.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 358
def initialize(properties = {})
  Options.validate!(properties)
  merge!(properties)
end

Public Instance Methods

as() click to toggle source

Returns the as option of the relation.

@example Get the as option.

metadata.as

@return [ true, false ] The as option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 19
def as
  self[:as]
end
as?() click to toggle source

Tells whether an as option exists.

@example Is the as option set?

metadata.as?

@return [ true, false ] True if an as exists, false if not.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 31
def as?
  !!as
end
autobuilding?() click to toggle source

Is the relation autobuilding if accessed via the getter and the document is new.

@example Is the relation autobuilding?

metadata.autobuilding?

@return [ true, false ] If the relation autobuilds.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 44
def autobuilding?
  !!self[:autobuild]
end
autosave() click to toggle source

Returns the autosave option of the relation.

@example Get the autosave option.

metadata.autosave

@return [ true, false ] The autosave option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 56
def autosave
  self[:autosave]
end
autosave?() click to toggle source

Does the metadata have a autosave option?

@example Is the relation autosaving?

metadata.autosave?

@return [ true, false ] If the relation autosaves.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 68
def autosave?
  !!autosave
end
builder(base, object) click to toggle source

Gets a relation builder associated with the relation this metadata is for.

@example Get the builder.

metadata.builder(document)

@param [ Document ] base The base document. @param [ Object ] object A document or attributes to give the builder.

@return [ Builder ] The builder for the relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 84
def builder(base, object)
  relation.builder(base, self, object)
end
cascade_strategy() click to toggle source

Returns the name of the strategy used for handling dependent relations.

@example Get the strategy.

metadata.cascade_strategy

@return [ Object ] The cascading strategy to use.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 96
def cascade_strategy
  if dependent?
    "Mongoid::Relations::Cascading::#{dependent.to_s.classify}".constantize
  end
end
cascading_callbacks?() click to toggle source

Is this an embedded relations that allows callbacks to cascade down to it?

@example Does the relation have cascading callbacks?

metadata.cascading_callbacks?

@return [ true, false ] If the relation cascades callbacks.

@since 2.3.0

# File lib/mongoid/relations/metadata.rb, line 111
def cascading_callbacks?
  !!self[:cascade_callbacks]
end
class_name() click to toggle source

Returns the name of the class that this relation contains. If the class_name was provided as an option this will return that, otherwise it will determine the name from the name property.

@example Get the class name.

metadata.class_name

@return [ String ] The name of the relation's proxied class.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 125
def class_name
  @class_name ||= (self[:class_name] || classify).sub(/\A::/,"")
end
constraint() click to toggle source

Get the foreign key contraint for the metadata.

@example Get the constaint.

metadata.constraint

@return [ Constraint ] The constraint.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 137
def constraint
  @constraint ||= Constraint.new(self)
end
counter_cache_column_name() click to toggle source

Returns the counter cache column name

@example Get the counter cache column.

metadata.counter_cache_column_name

@return [ String ] The counter cache column

@since 3.1.0

# File lib/mongoid/relations/metadata.rb, line 161
def counter_cache_column_name
  if self[:counter_cache] == true
    "#{inverse || inverse_class_name.demodulize.underscore.pluralize}_count"
  else
    self[:counter_cache].to_s
  end
end
counter_cached?() click to toggle source

Does the metadata have a counter cache?

@example Is the metadata counter_cached?

metadata.counter_cached?

@return [ true, false ] If the metadata has counter_cache

@since 3.1.0

# File lib/mongoid/relations/metadata.rb, line 149
def counter_cached?
  !!self[:counter_cache]
end
criteria(object, type) click to toggle source

Get the criteria that is used to query for this metadata's relation.

@example Get the criteria.

metadata.criteria([ id_one, id_two ], Person)

@param [ Object ] object The foreign key used for the query. @param [ Class ] type The base class.

@return [ Criteria ] The criteria.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 180
def criteria(object, type)
  relation.criteria(self, object, type)
end
cyclic() click to toggle source

Returns the cyclic option of the relation.

@example Get the cyclic option.

metadata.cyclic

@return [ true, false ] The cyclic option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 192
def cyclic
  self[:cyclic]
end
cyclic?() click to toggle source

Does the metadata have a cyclic option?

@example Is the metadata cyclic?

metadata.cyclic?

@return [ true, false ] If the metadata is cyclic.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 204
def cyclic?
  !!cyclic
end
dependent() click to toggle source

Returns the dependent option of the relation.

@example Get the dependent option.

metadata.dependent

@return [ Symbol ] The dependent option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 216
def dependent
  self[:dependent]
end
dependent?() click to toggle source

Does the metadata have a dependent option?

@example Is the metadata performing cascades?

metadata.dependent?

@return [ true, false ] If the metadata cascades.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 228
def dependent?
  !!dependent
end
destructive?() click to toggle source

Does the relation have a destructive dependent option specified. This is true for :dependent => :delete and :dependent => :destroy.

@example Is the relation destructive?

metadata.destructive?

@return [ true, false ] If the relation is destructive.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 649
def destructive?
  @destructive ||= (dependent == :delete || dependent == :destroy)
end
embedded?() click to toggle source

Will determine if the relation is an embedded one or not. Currently only checks against embeds one and many.

@example Is the document embedded.

metadata.embedded?

@return [ true, false ] True if embedded, false if not.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 241
def embedded?
  @embedded ||= (macro == :embeds_one || macro == :embeds_many)
end
extension() click to toggle source

Returns the extension of the relation.

@example Get the relation extension.

metadata.extension

@return [ Module ] The extension or nil.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 253
def extension
  self[:extend]
end
extension?() click to toggle source

Tells whether an extension definition exist for this relation.

@example Is an extension defined?

metadata.extension?

@return [ true, false ] True if an extension exists, false if not.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 265
def extension?
  !!extension
end
forced_nil_inverse?() click to toggle source

Does this metadata have a forced nil inverse_of defined. (Used in many to manies)

@example Is this a forced nil inverse?

metadata.forced_nil_inverse?

@return [ true, false ] If inverse_of has been explicitly set to nil.

@since 2.3.3

# File lib/mongoid/relations/metadata.rb, line 278
def forced_nil_inverse?
  @forced_nil_inverse ||= has_key?(:inverse_of) && inverse_of.nil?
end
foreign_key() click to toggle source

Handles all the logic for figuring out what the foreign_key is for each relations query. The logic is as follows:

  1. If the developer defined a custom key, use that.

  2. If the relation stores a foreign key, use the class_name_id strategy.

  3. If the relation does not store the key, use the inverse_class_name_id strategy.

@example Get the foreign key.

metadata.foreign_key

@return [ String ] The foreign key for the relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 297
def foreign_key
  @foreign_key ||= determine_foreign_key
end
foreign_key_check() click to toggle source

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

@example Get the foreign key check method.

metadata.foreign_key_check

@return [ String ] The foreign key check.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 309
def foreign_key_check
  @foreign_key_check ||= "#{foreign_key}_changed?"
end
foreign_key_setter() click to toggle source

Returns the name of the method used to set the foreign key on a document.

@example Get the setter for the foreign key.

metadata.foreign_key_setter

@return [ String ] The foreign_key plus =.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 322
def foreign_key_setter
  @foreign_key_setter ||= "#{foreign_key}="
end
index() click to toggle source

Returns the index option of the relation.

@example Get the index option.

metadata.index

@return [ true, false ] The index option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 334
def index
  self[:index]
end
indexed?() click to toggle source

Tells whether a foreign key index exists on the relation.

@example Is the key indexed?

metadata.indexed?

@return [ true, false ] True if an index exists, false if not.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 346
def indexed?
  !!index
end
inspect() click to toggle source

Since a lot of the information from the metadata is inferred and not explicitly stored in the hash, the inspection needs to be much more detailed.

@example Inspect the metadata.

metadata.inspect

@return [ String ] Oodles of information in a nice format.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 373
      def inspect
%Q{#<Mongoid::Relations::Metadata
  autobuild:    #{autobuilding?}
  class_name:   #{class_name}
  cyclic:       #{cyclic.inspect}
  counter_cache:#{counter_cached?}
  dependent:    #{dependent.inspect}
  inverse_of:   #{inverse_of.inspect}
  key:          #{key}
  macro:        #{macro}
  name:         #{name}
  order:        #{order.inspect}
  polymorphic:  #{polymorphic?}
  relation:     #{relation}
  setter:       #{setter}>
}
      end
inverse(other = nil) click to toggle source

Get the name of the inverse relation if it exists. If this is a polymorphic relation then just return the :as option that was defined.

@example Get the name of the inverse.

metadata.inverse

@param [ Document ] other The document to aid in the discovery.

@return [ Symbol ] The inverse name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 419
def inverse(other = nil)
  invs = inverses(other)
  invs.first if invs.count == 1
end
inverse_class_name() click to toggle source

Returns the inverse_class_name option of the relation.

@example Get the inverse_class_name option.

metadata.inverse_class_name

@return [ true, false ] The inverse_class_name option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 432
def inverse_class_name
  self[:inverse_class_name]
end
inverse_class_name?() click to toggle source

Returns the if the inverse class name option exists.

@example Is an inverse class name defined?

metadata.inverse_class_name?

@return [ true, false ] If the inverse if defined.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 444
def inverse_class_name?
  !!inverse_class_name
end
inverse_foreign_key() click to toggle source

Used for relational many to many only. This determines the name of the foreign key field on the inverse side of the relation, since in this case there are keys on both sides.

@example Find the inverse foreign key

metadata.inverse_foreign_key

@return [ String ] The foreign key on the inverse.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 458
def inverse_foreign_key
  @inverse_foreign_key ||= determine_inverse_foreign_key
end
inverse_foreign_key_setter() click to toggle source

Used for relational many to many only. This determines the name of the foreign key field setter on the inverse side of the relation, since in this case there are keys on both sides.

@example Find the inverse foreign key setter.

metadata.inverse_foreign_key_setter

@return [ String ] The foreign key setter on the inverse.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 472
def inverse_foreign_key_setter
  @inverse_foreign_key_setter ||= "#{inverse_foreign_key}="
end
inverse_klass() click to toggle source

Returns the inverse class of the proxied relation.

@example Get the inverse class.

metadata.inverse_klass

@return [ Class ] The class of the inverse of the relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 484
def inverse_klass
  @inverse_klass ||= inverse_class_name.constantize
end
inverse_metadata(object) click to toggle source

Get the metadata for the inverse relation.

@example Get the inverse metadata.

metadata.inverse_metadata(doc)

@param [ Document, Class ] object The document or class.

@return [ Metadata ] The inverse metadata.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 498
def inverse_metadata(object)
  object.reflect_on_association(inverse(object))
end
inverse_of() click to toggle source

Returns the inverse_of option of the relation.

@example Get the inverse_of option.

metadata.inverse_of

@return [ true, false ] The inverse_of option.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 510
def inverse_of
  self[:inverse_of]
end
inverse_of?() click to toggle source

Does the metadata have a inverse_of option?

@example Is an inverse_of defined?

metadata.inverse_of?

@return [ true, false ] If the relation has an inverse_of defined.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 522
def inverse_of?
  !!inverse_of
end
inverse_setter(other = nil) click to toggle source

Returns the setter for the inverse side of the relation.

@example Get the inverse setter.

metadata.inverse_setter

@param [ Document ] other A document to aid in the discovery.

@return [ String ] The inverse setter name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 536
def inverse_setter(other = nil)
  inverse(other).__setter__
end
inverse_type() click to toggle source

Returns the name of the field in which to store the name of the class for the polymorphic relation.

@example Get the name of the field.

metadata.inverse_type

@return [ String ] The name of the field for storing the type.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 549
def inverse_type
  @inverse_type ||= determine_inverse_for(:type)
end
inverse_type_setter() click to toggle source

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

@example Get the inverse type setter.

metadata.inverse_type_setter

@return [ String ] The name of the setter.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 562
def inverse_type_setter
  @inverse_type_setter ||= inverse_type.__setter__
end
inverses(other = nil) click to toggle source

Get the name of the inverse relations if they exists. If this is a polymorphic relation then just return the :as option that was defined.

@example Get the names of the inverses.

metadata.inverses

@param [ Document ] other The document to aid in the discovery.

@return [ Array<Symbol> ] The inverse name.

# File lib/mongoid/relations/metadata.rb, line 400
def inverses(other = nil)
  if self[:polymorphic]
    lookup_inverses(other)
  else
    @inverses ||= determine_inverses
  end
end
key() click to toggle source

This returns the key that is to be used to grab the attributes for the relation or the foreign key or id that a referenced relation will use to query for the object.

@example Get the lookup key.

metadata.key

@return [ String ] The association name, foreign key name, or _id.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 576
def key
  @key ||= determine_key
end
klass() click to toggle source

Returns the class of the proxied relation.

@example Get the class.

metadata.klass

@return [ Class ] The class of the relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 588
def klass
  @klass ||= class_name.constantize
end
macro() click to toggle source

Returns the macro for the relation of this metadata.

@example Get the macro.

metadata.macro

@return [ Symbol ] The macro.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 612
def macro
  relation.macro
end
many?() click to toggle source

Is this metadata representing a one to many or many to many relation?

@example Is the relation a many?

metadata.many?

@return [ true, false ] If the relation is a many.

@since 2.1.6

# File lib/mongoid/relations/metadata.rb, line 600
def many?
  @many ||= (relation.macro.to_s =~ /many/)
end
name() click to toggle source

Get the name associated with this metadata.

@example Get the name.

metadata.name

@return [ Symbol ] The name.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 624
def name
  self[:name]
end
name?() click to toggle source

Is the name defined?

@example Is the name defined?

metadata.name?

@return [ true, false ] If the name is defined.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 636
def name?
  !!name
end
nested_builder(attributes, options) click to toggle source

Gets a relation nested builder associated with the relation this metadata is for. Nested builders are used in conjunction with nested attributes.

@example Get the nested builder.

metadata.nested_builder(attributes, options)

@param [ Hash ] attributes The attributes to build the relation with. @param [ Hash ] options Options for the nested builder.

@return [ NestedBuilder ] The nested builder for the relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 665
def nested_builder(attributes, options)
  if polymorphic? && options[:class_name]
    self[:class_name] = options[:class_name]
  end
  relation.nested_builder(self, attributes, options)
end
options() click to toggle source

Returns the metadata itself. Here for compatibility with Rails association metadata.

@example Get the options.

metadata.options

@return [ Metadata ] self.

@since 2.4.6

# File lib/mongoid/relations/metadata.rb, line 797
def options
  self
end
order() click to toggle source

Returns default order for this association.

@example Get default order

metadata.order

@return [ Criterion::Complex, nil] nil if doesn't set

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 809
def order
  self[:order]
end
order?() click to toggle source

Is a default order set?

@example Is the order set?

metadata.order?

@return [ true, false ] If the order is set.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 821
def order?
  !!order
end
path(document) click to toggle source

Get the path calculator for the supplied document.

@example Get the path calculator.

metadata.path(document)

@param [ Document ] document The document to calculate on.

@return [ Object ] The atomic path calculator.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 682
def path(document)
  relation.path(document)
end
polymorphic?() click to toggle source

Returns true if the relation is polymorphic.

@example Is the relation polymorphic?

metadata.polymorphic?

@return [ true, false ] True if the relation is polymorphic, false if not.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 694
def polymorphic?
  @polymorphic ||= (!!self[:as] || !!self[:polymorphic])
end
primary_key() click to toggle source

Get the primary key field for finding the related document.

@example Get the primary key.

metadata.primary_key

@return [ String ] The primary key field.

@since 3.1.0

# File lib/mongoid/relations/metadata.rb, line 706
def primary_key
  @primary_key ||= (self[:primary_key] || "_id").to_s
end
relation() click to toggle source

Get the relation associated with this metadata.

@example Get the relation.

metadata.relation

@return [ Proxy ] The relation proxy class.

@since 2.1.0

# File lib/mongoid/relations/metadata.rb, line 718
def relation
  self[:relation]
end
setter() click to toggle source

Gets the method name used to set this relation.

@example Get the setter.

metadata = Metadata.new(:name => :person)
metadata.setter # => "person="

@return [ String ] The name plus “=”.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 731
def setter
  @setter ||= "#{name}="
end
store_as() click to toggle source

Key where embedded document is save. By default is the name of relation

@return [ String ] the name of key where save

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 768
def store_as
  @store_as ||= (self[:store_as].try(:to_s) || name.to_s)
end
touchable?() click to toggle source

Is this relation touchable?

@example Is the relation touchable?

metadata.touchable?

@return [ true, false ] If the relation can be touched.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 833
def touchable?
  !!self[:touch]
end
type() click to toggle source

Returns the name of the field in which to store the name of the class for the polymorphic relation.

@example Get the name of the field.

metadata.inverse_type

@return [ String ] The name of the field for storing the type.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 744
def type
  @type ||= polymorphic? ? "#{as}_type" : nil
end
type_relation() click to toggle source

Returns the metadata class types.

@example Get the relation class types.

metadata.type_relation

@return [ Hash ] The hash with relation class types.

@since 3.1.0

# File lib/mongoid/relations/metadata.rb, line 845
def type_relation
  { _type: { "$in" => klass._types }}
end
type_setter() click to toggle source

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

@example Get the inverse type setter.

metadata.inverse_type_setter

@return [ String ] The name of the setter.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 757
def type_setter
  @type_setter ||= type.__setter__
end
validate?() click to toggle source

Are we validating this relation automatically?

@example Is automatic validation on?

metadata.validate?

@return [ true, false ] True unless explictly set to false.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 780
def validate?
  if self[:validate].nil?
    self[:validate] = relation.validation_default
  else
    self[:validate]
  end
end

Private Instance Methods

classify() click to toggle source

Returns the class name for the relation.

@example Get the class name.

metadata.classify

@return [ String ] The classified name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 859
def classify
  @classify ||= "#{find_module}::#{name.to_s.classify}"
end
cyclic_inverse() click to toggle source

Get the name of the inverse relation in a cyclic relation.

@example Get the cyclic inverse name.

class Role
  include Mongoid::Document
  embedded_in :parent_role, :cyclic => true
  embeds_many :child_roles, :cyclic => true
end

metadata = Metadata.new(:name => :parent_role)
metadata.cyclic_inverse # => "child_roles"

@return [ String ] The cyclic inverse name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 956
def cyclic_inverse
  @cyclic_inverse ||= determine_cyclic_inverse
end
determine_cyclic_inverse() click to toggle source

Determine the cyclic inverse. Performance improvement with the memoization.

@example Determine the inverse.

metadata.determine_cyclic_inverse

@return [ String ] The cyclic inverse name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 969
def determine_cyclic_inverse
  underscored = class_name.demodulize.underscore
  klass.relations.each_pair do |key, meta|
    if key =~ /#{underscored.singularize}|#{underscored.pluralize}/ &&
      meta.relation != relation
      return key.to_sym
    end
  end
end
determine_foreign_key() click to toggle source

Determine the value for the relation's foreign key. Performance improvement.

@example Determine the foreign key.

metadata.determine_foreign_key

@return [ String ] The foreign key.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 988
def determine_foreign_key
  return self[:foreign_key].to_s if self[:foreign_key]
  return nil if relation.embedded?

  if relation.stores_foreign_key?
    relation.foreign_key(name)
  else
    suffix = relation.foreign_key_suffix
    "#{inverse}#{suffix}"
  end
end
determine_inverse_for(field) click to toggle source

Get the name for the inverse field.

@api private

@example Get the inverse field name.

metadata.determine_inverse_for(:type)

@param [ Symbol ] field The inverse field name.

@return [ String ] The name of the field.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 875
def determine_inverse_for(field)
  relation.stores_foreign_key? && polymorphic? ? "#{name}_#{field}" : nil
end
determine_inverse_foreign_key() click to toggle source

Determine the inverse foreign key of the relation.

@example Determine the inverse foreign key.

metadata.determine_inverse_foreign_key

@return [ String ] The inverse.

@since 2.3.2

# File lib/mongoid/relations/metadata.rb, line 1008
def determine_inverse_foreign_key
  if has_key?(:inverse_of)
    inverse_of ? "#{inverse_of.to_s.singularize}#{relation.foreign_key_suffix}" : nil
  else
    "#{inverse_class_name.demodulize.underscore}#{relation.foreign_key_suffix}"
  end
end
determine_inverse_relation() click to toggle source

Determine the inverse relation. Memoizing inverse_relation and adding this method dropped 5 seconds off the test suite as a performance improvement.

@example Determine the inverse.

metadata.determine_inverse_relation

@return [ Symbol ] The name of the inverse.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 1026
def determine_inverse_relation
  default = foreign_key_match || klass.relations[inverse_klass.name.underscore]
  return default.name if default
  names = inverse_relation_candidate_names
  if names.size > 1
    raise Errors::AmbiguousRelationship.new(klass, inverse_klass, name, names)
  end
  names.first
end
determine_inverses() click to toggle source

Deterimene the inverses that can be memoized.

@api private

@example Determin the inverses.

metadata.determine_inverses

@return [ Array<Symbol> ] The inverses.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 889
def determine_inverses
  return [ inverse_of ] if has_key?(:inverse_of)
  return [ as ] if has_key?(:as)
  return [ cyclic_inverse ] if self[:cyclic]
  [ inverse_relation ]
end
determine_key() click to toggle source

Determine the key for the relation in the attributes.

@example Get the key.

metadata.determine_key

@return [ String ] The key in the attributes.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 1094
def determine_key
  return store_as.to_s if relation.embedded?
  relation.stores_foreign_key? ? foreign_key : primary_key
end
find_from_parts(modules) click to toggle source

Find the modules from a reversed list.

@api private

@example Find the module from the parts.

metadata.find_from_parts([ "Namespace", "Module" ])

@param [ Array<String> ] The modules.

@return [ String ] The matching module.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 928
def find_from_parts(modules)
  modules.find do |mod|
    if mod.blank?
      false
    else
      ActiveSupport::Inflector.constantize(mod).constants.include?(
        name.to_s.classify.to_sym
      )
    end
  end
end
find_module() click to toggle source

Find the module the class with the specific name is in. This is done by starting at the inverse_class_name's module and stepping down to see where it is defined.

@api private

@example Find the module.

metadata.find_module

@return [ String ] The module.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 908
def find_module
  if inverse_class_name.present?
    parts = inverse_class_name.split('::')
    modules = parts.size.times.map { |i| parts.first(i).join('::') }.reverse
    find_from_parts(modules)
  end
end
foreign_key_match() click to toggle source

Return metadata where the foreign key matches the foreign key on this relation.

@api private

@example Return a foreign key match.

meta.foreign_key_match

@return [ Metadata ] A match, if any.

@since 2.4.11

# File lib/mongoid/relations/metadata.rb, line 1047
def foreign_key_match
  if fk = self[:foreign_key]
    relations_metadata.detect do |meta|
      fk == meta.foreign_key if meta.stores_foreign_key?
    end
  end
end
inverse_name() click to toggle source

Infer the name of the inverse relation from the class.

@example Get the inverse name

metadata.inverse_name

@return [ String ] The inverse class name underscored.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 1119
def inverse_name
  @inverse_name ||= inverse_klass.name.underscore
end
inverse_relation() click to toggle source

Determine the name of the inverse relation.

@example Get the inverse name.

metadata.inverse_relation

@return [ Symbol ] The name of the inverse relation.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 1107
def inverse_relation
  @inverse_relation ||= determine_inverse_relation
end
inverse_relation_candidate_names() click to toggle source

Get the candidates for inverse relations.

@api private

@example Get the candidates.

metadata.inverse_relation_candidates

@return [ Array<Symbol> ] The candidates.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 1082
def inverse_relation_candidate_names
  @candidate_names ||= inverse_relation_candidates.map(&:name)
end
inverse_relation_candidates() click to toggle source

Get the inverse relation candidates.

@api private

@example Get the inverse relation candidates.

metadata.inverse_relation_candidates

@return [ Array<Metdata> ] The candidates.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 1065
def inverse_relation_candidates
  relations_metadata.select do |meta|
    next if meta.name == name
    (meta.class_name == inverse_class_name) && !meta.forced_nil_inverse?
  end
end
lookup_inverse(other) click to toggle source

For polymorphic children, we need to figure out the inverse from the actual instance on the other side, since we cannot know the exact class name to infer it from at load time.

@example Find the inverse.

metadata.lookup_inverse(other)

@param [ Document ] : The inverse document.

@return [ String ] The inverse name.

@since 2.0.0.rc.1

# File lib/mongoid/relations/metadata.rb, line 1158
def lookup_inverse(other)
  if invs = lookup_inverses(other) && invs.count == 1
    invs.first
  end
end
lookup_inverses(other) click to toggle source

For polymorphic children, we need to figure out the inverse from the actual instance on the other side, since we cannot know the exact class name to infer it from at load time.

@example Find the inverses.

metadata.lookup_inverses(other)

@param [ Document ] : The inverse document.

@return [ Array<String> ] The inverse names.

# File lib/mongoid/relations/metadata.rb, line 1133
def lookup_inverses(other)
  return [ inverse_of ] if inverse_of
  if other
    matches = []
    other.class.relations.values.each do |meta|
      if meta.as == name && meta.class_name == inverse_class_name
        matches.push(meta.name)
      end
    end
    matches
  end
end
relations_metadata() click to toggle source

Get the relation metadata only.

@api private

@example Get the relation metadata.

metadata.relations_metadata

@return [ Array<Metadata> ] The metadata.

@since 3.0.0

# File lib/mongoid/relations/metadata.rb, line 1174
def relations_metadata
  klass.relations.values
end