Class: Mongoid::Relations::Metadata

Inherits:
Hash
  • Object
show all
Defined in:
lib/mongoid/relations/metadata.rb

Overview

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

Instance Method Summary collapse

Constructor Details

#initialize(properties = {}) ⇒ Metadata

Instantiate new metadata for a relation.

Examples:

Create the new metadata.

Metadata.new(:name => :addresses)

Parameters:

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

    The relation options.

Since:

  • 2.0.0.rc.1



372
373
374
375
 
# File 'lib/mongoid/relations/metadata.rb', line 372

def initialize(properties = {})
  Options.validate!(properties)
  merge!(properties)
end

Instance Method Details

#as ⇒ true, false

Returns the as option of the relation.

Examples:

Get the as option.

metadata.as

Returns:

  • (true, false) —

    The as option.

Since:

  • 2.1.0



19
20
21
 
# File 'lib/mongoid/relations/metadata.rb', line 19

def as
  self[:as]
end

#as? ⇒ true, false

Tells whether an as option exists.

Examples:

Is the as option set?

metadata.as?

Returns:

  • (true, false) —

    True if an as exists, false if not.

Since:

  • 2.0.0.rc.1



31
32
33
 
# File 'lib/mongoid/relations/metadata.rb', line 31

def as?
  !!as
end

#autobuilding? ⇒ true, false

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

Examples:

Is the relation autobuilding?

metadata.autobuilding?

Returns:

  • (true, false) —

    If the relation autobuilds.

Since:

  • 3.0.0



44
45
46
 
# File 'lib/mongoid/relations/metadata.rb', line 44

def autobuilding?
  !!self[:autobuild]
end

#autosave ⇒ true, false

Returns the autosave option of the relation.

Examples:

Get the autosave option.

metadata.autosave

Returns:

  • (true, false) —

    The autosave option.

Since:

  • 2.1.0



56
57
58
 
# File 'lib/mongoid/relations/metadata.rb', line 56

def autosave
  self[:autosave]
end

#autosave? ⇒ true, false

Does the metadata have a autosave option?

Examples:

Is the relation autosaving?

metadata.autosave?

Returns:

  • (true, false) —

    If the relation autosaves.

Since:

  • 2.1.0



68
69
70
 
# File 'lib/mongoid/relations/metadata.rb', line 68

def autosave?
  !!autosave
end

#builder(base, object) ⇒ Builder

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

Examples:

Get the builder.

metadata.builder(document)

Parameters:

  • base (Document) —

    The base document.

  • object (Object) —

    A document or attributes to give the builder.

Returns:

  • (Builder) —

    The builder for the relation.

Since:

  • 2.0.0.rc.1



84
85
86
 
# File 'lib/mongoid/relations/metadata.rb', line 84

def builder(base, object)
  relation.builder(base, self, object)
end

#cascade_strategy ⇒ Object

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

Examples:

Get the strategy.

metadata.cascade_strategy

Returns:

  • (Object) —

    The cascading strategy to use.

Since:

  • 2.0.0.rc.1



96
97
98
99
100
 
# 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? ⇒ true, false

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

Examples:

Does the relation have cascading callbacks?

metadata.cascading_callbacks?

Returns:

  • (true, false) —

    If the relation cascades callbacks.

Since:

  • 2.3.0



111
112
113
 
# File 'lib/mongoid/relations/metadata.rb', line 111

def cascading_callbacks?
  !!self[:cascade_callbacks]
end

#class_name ⇒ String

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.

Examples:

Get the class name.

metadata.class_name

Returns:

  • (String) —

    The name of the relation’s proxied class.

Since:

  • 2.0.0.rc.1



125
126
127
 
# File 'lib/mongoid/relations/metadata.rb', line 125

def class_name
  @class_name ||= (self[:class_name] || classify).sub(/\A::/,"")
end

#constraint ⇒ Constraint

Get the foreign key contraint for the metadata.

Examples:

Get the constaint.

metadata.constraint

Returns:

Since:

  • 2.0.0.rc.1



137
138
139
 
# File 'lib/mongoid/relations/metadata.rb', line 137

def constraint
  @constraint ||= Constraint.new(self)
end

#counter_cache_column_name ⇒ String

Returns the counter cache column name

Examples:

Get the counter cache column.

metadata.counter_cache_column_name

Returns:

  • (String) —

    The counter cache column

Since:

  • 3.1.0



161
162
163
164
165
166
167
 
# 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? ⇒ true, false

Does the metadata have a counter cache?

Examples:

Is the metadata counter_cached?

metadata.counter_cached?

Returns:

  • (true, false) —

    If the metadata has counter_cache

Since:

  • 3.1.0



149
150
151
 
# File 'lib/mongoid/relations/metadata.rb', line 149

def counter_cached?
  !!self[:counter_cache]
end

#criteria(object, type) ⇒ Criteria

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

Examples:

Get the criteria.

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

Parameters:

  • object (Object) —

    The foreign key used for the query.

  • type (Class) —

    The base class.

Returns:

Since:

  • 2.1.0



180
181
182
 
# File 'lib/mongoid/relations/metadata.rb', line 180

def criteria(object, type)
  relation.criteria(self, object, type)
end

#cyclic ⇒ true, false

Returns the cyclic option of the relation.

Examples:

Get the cyclic option.

metadata.cyclic

Returns:

  • (true, false) —

    The cyclic option.

Since:

  • 2.1.0



192
193
194
 
# File 'lib/mongoid/relations/metadata.rb', line 192

def cyclic
  self[:cyclic]
end

#cyclic? ⇒ true, false

Does the metadata have a cyclic option?

Examples:

Is the metadata cyclic?

metadata.cyclic?

Returns:

  • (true, false) —

    If the metadata is cyclic.

Since:

  • 2.1.0



204
205
206
 
# File 'lib/mongoid/relations/metadata.rb', line 204

def cyclic?
  !!cyclic
end

#dependent ⇒ Symbol

Returns the dependent option of the relation.

Examples:

Get the dependent option.

metadata.dependent

Returns:

  • (Symbol) —

    The dependent option.

Since:

  • 2.1.0



216
217
218
 
# File 'lib/mongoid/relations/metadata.rb', line 216

def dependent
  self[:dependent]
end

#dependent? ⇒ true, false

Does the metadata have a dependent option?

Examples:

Is the metadata performing cascades?

metadata.dependent?

Returns:

  • (true, false) —

    If the metadata cascades.

Since:

  • 2.1.0



228
229
230
 
# File 'lib/mongoid/relations/metadata.rb', line 228

def dependent?
  !!dependent
end

#destructive? ⇒ true, false

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

Examples:

Is the relation destructive?

metadata.destructive?

Returns:

  • (true, false) —

    If the relation is destructive.

Since:

  • 2.1.0



690
691
692
 
# File 'lib/mongoid/relations/metadata.rb', line 690

def destructive?
  @destructive ||= (dependent == :delete || dependent == :destroy)
end

#eager_load(ids) ⇒ Criteria

Get the criteria needed to eager load this relation.

Examples:

Get the eager loading criteria.

metadata.eager_load(criteria)

Parameters:

  • ids (Array<Object>) —

    The ids of the returned parents.

Returns:

  • (Criteria) —

    The eager loading criteria.

Since:

  • 2.2.0



242
243
244
 
# File 'lib/mongoid/relations/metadata.rb', line 242

def eager_load(ids)
  relation.eager_load(self, ids)
end

#embedded? ⇒ true, false

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

Examples:

Is the document embedded.

metadata.embedded?

Returns:

  • (true, false) —

    True if embedded, false if not.

Since:

  • 2.0.0.rc.1



255
256
257
 
# File 'lib/mongoid/relations/metadata.rb', line 255

def embedded?
  @embedded ||= (macro == :embeds_one || macro == :embeds_many)
end

#extension ⇒ Module

Returns the extension of the relation.

Examples:

Get the relation extension.

metadata.extension

Returns:

  • (Module) —

    The extension or nil.

Since:

  • 2.0.0.rc.1



267
268
269
 
# File 'lib/mongoid/relations/metadata.rb', line 267

def extension
  self[:extend]
end

#extension? ⇒ true, false

Tells whether an extension definition exist for this relation.

Examples:

Is an extension defined?

metadata.extension?

Returns:

  • (true, false) —

    True if an extension exists, false if not.

Since:

  • 2.0.0.rc.1



279
280
281
 
# File 'lib/mongoid/relations/metadata.rb', line 279

def extension?
  !!extension
end

#forced_nil_inverse? ⇒ true, false

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

Examples:

Is this a forced nil inverse?

metadata.forced_nil_inverse?

Returns:

  • (true, false) —

    If inverse_of has been explicitly set to nil.

Since:

  • 2.3.3



292
293
294
 
# File 'lib/mongoid/relations/metadata.rb', line 292

def forced_nil_inverse?
  @forced_nil_inverse ||= has_key?(:inverse_of) && inverse_of.nil?
end

#foreign_key ⇒ String

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.

Examples:

Get the foreign key.

metadata.foreign_key

Returns:

  • (String) —

    The foreign key for the relation.

Since:

  • 2.0.0.rc.1



311
312
313
 
# File 'lib/mongoid/relations/metadata.rb', line 311

def foreign_key
  @foreign_key ||= determine_foreign_key
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.

metadata.foreign_key_check

Returns:

  • (String) —

    The foreign key check.

Since:

  • 2.1.0



323
324
325
 
# File 'lib/mongoid/relations/metadata.rb', line 323

def foreign_key_check
  @foreign_key_check ||= "#{foreign_key}_changed?"
end

#foreign_key_setter ⇒ String

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

Examples:

Get the setter for the foreign key.

metadata.foreign_key_setter

Returns:

  • (String) —

    The foreign_key plus =.

Since:

  • 2.0.0.rc.1



336
337
338
 
# File 'lib/mongoid/relations/metadata.rb', line 336

def foreign_key_setter
  @foreign_key_setter ||= "#{foreign_key}="
end

#index ⇒ true, false

Returns the index option of the relation.

Examples:

Get the index option.

metadata.index

Returns:

  • (true, false) —

    The index option.

Since:

  • 2.1.0



348
349
350
 
# File 'lib/mongoid/relations/metadata.rb', line 348

def index
  self[:index]
end

#indexed? ⇒ true, false

Tells whether a foreign key index exists on the relation.

Examples:

Is the key indexed?

metadata.indexed?

Returns:

  • (true, false) —

    True if an index exists, false if not.

Since:

  • 2.0.0.rc.1



360
361
362
 
# File 'lib/mongoid/relations/metadata.rb', line 360

def indexed?
  !!index
end

#inspect ⇒ String

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.

Examples:

Inspect the metadata.

metadata.inspect

Returns:

  • (String) —

    Oodles of information in a nice format.

Since:

  • 2.0.0.rc.1



387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'lib/mongoid/relations/metadata.rb', line 387

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}
  versioned:    #{versioned?}>
}
end

#inverse(other = nil) ⇒ Symbol

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.

Examples:

Get the name of the inverse.

metadata.inverse

Parameters:

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

    The document to aid in the discovery.

Returns:

  • (Symbol) —

    The inverse name.

Since:

  • 2.0.0.rc.1



434
435
436
437
 
# File 'lib/mongoid/relations/metadata.rb', line 434

def inverse(other = nil)
  invs = inverses(other)
  invs.first if invs.count == 1
end

#inverse_class_name ⇒ true, false

Returns the inverse_class_name option of the relation.

Examples:

Get the inverse_class_name option.

metadata.inverse_class_name

Returns:

  • (true, false) —

    The inverse_class_name option.

Since:

  • 2.1.0



447
448
449
 
# File 'lib/mongoid/relations/metadata.rb', line 447

def inverse_class_name
  self[:inverse_class_name]
end

#inverse_class_name? ⇒ true, false

Returns the if the inverse class name option exists.

Examples:

Is an inverse class name defined?

metadata.inverse_class_name?

Returns:

  • (true, false) —

    If the inverse if defined.

Since:

  • 2.1.0



459
460
461
 
# File 'lib/mongoid/relations/metadata.rb', line 459

def inverse_class_name?
  !!inverse_class_name
end

#inverse_field_bindable? ⇒ true, false

Is the inverse field bindable? Ie, do we have more than one definition on the parent class with the same polymorphic name (as).

Examples:

Is the inverse of bindable?

metadata.inverse_of_bindable?

Returns:

  • (true, false) —

    If the relation needs the inverse of field set.

Since:

  • 3.0.6



472
473
474
475
476
 
# File 'lib/mongoid/relations/metadata.rb', line 472

def inverse_field_bindable?
  @inverse_field_bindable ||= (inverse_klass.relations.values.count do |meta|
    meta.as == as
  end > 1)
end

#inverse_foreign_key ⇒ String

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.

Examples:

Find the inverse foreign key

metadata.inverse_foreign_key

Returns:

  • (String) —

    The foreign key on the inverse.

Since:

  • 2.0.0.rc.1



488
489
490
 
# File 'lib/mongoid/relations/metadata.rb', line 488

def inverse_foreign_key
  @inverse_foreign_key ||= determine_inverse_foreign_key
end

#inverse_klass ⇒ Class

Returns the inverse class of the proxied relation.

Examples:

Get the inverse class.

metadata.inverse_klass

Returns:

  • (Class) —

    The class of the inverse of the relation.

Since:

  • 2.0.0.rc.1



500
501
502
 
# File 'lib/mongoid/relations/metadata.rb', line 500

def inverse_klass
  @inverse_klass ||= inverse_class_name.constantize
end

#inverse_metadata(object) ⇒ Metadata

Get the metadata for the inverse relation.

Examples:

Get the inverse metadata.

metadata.inverse_metadata(doc)

Parameters:

  • object (Document, Class) —

    The document or class.

Returns:

Since:

  • 2.1.0



514
515
516
 
# File 'lib/mongoid/relations/metadata.rb', line 514

def inverse_metadata(object)
  object.reflect_on_association(inverse(object))
end

#inverse_of ⇒ true, false

Returns the inverse_of option of the relation.

Examples:

Get the inverse_of option.

metadata.inverse_of

Returns:

  • (true, false) —

    The inverse_of option.

Since:

  • 2.1.0



526
527
528
 
# File 'lib/mongoid/relations/metadata.rb', line 526

def inverse_of
  self[:inverse_of]
end

#inverse_of? ⇒ true, false

Does the metadata have a inverse_of option?

Examples:

Is an inverse_of defined?

metadata.inverse_of?

Returns:

  • (true, false) —

    If the relation has an inverse_of defined.

Since:

  • 2.1.0



538
539
540
 
# File 'lib/mongoid/relations/metadata.rb', line 538

def inverse_of?
  !!inverse_of
end

#inverse_of_field ⇒ String

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

Examples:

Get the name of the field.

metadata.inverse_of_field

Returns:

  • (String) —

    The name of the field for storing the name of the inverse field.

Since:

  • 2.4.5



592
593
594
 
# File 'lib/mongoid/relations/metadata.rb', line 592

def inverse_of_field
  @inverse_of_field ||= determine_inverse_for(:field)
end

#inverse_of_field_setter ⇒ String

Gets the setter for the field that stores the name of the inverse field on a polymorphic relation.

Examples:

Get the inverse type setter.

metadata.inverse_of_field_setter

Returns:

  • (String) —

    The name of the setter.



603
604
605
 
# File 'lib/mongoid/relations/metadata.rb', line 603

def inverse_of_field_setter
  @inverse_of_field_setter ||= inverse_of_field.__setter__
end

#inverse_setter(other = nil) ⇒ String

Returns the setter for the inverse side of the relation.

Examples:

Get the inverse setter.

metadata.inverse_setter

Parameters:

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

    A document to aid in the discovery.

Returns:

  • (String) —

    The inverse setter name.

Since:

  • 2.0.0.rc.1



552
553
554
 
# File 'lib/mongoid/relations/metadata.rb', line 552

def inverse_setter(other = nil)
  inverse(other).__setter__
end

#inverse_type ⇒ String

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

Examples:

Get the name of the field.

metadata.inverse_type

Returns:

  • (String) —

    The name of the field for storing the type.

Since:

  • 2.0.0.rc.1



565
566
567
 
# File 'lib/mongoid/relations/metadata.rb', line 565

def inverse_type
  @inverse_type ||= determine_inverse_for(: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.

metadata.inverse_type_setter

Returns:

  • (String) —

    The name of the setter.

Since:

  • 2.0.0.rc.1



578
579
580
 
# File 'lib/mongoid/relations/metadata.rb', line 578

def inverse_type_setter
  @inverse_type_setter ||= inverse_type.__setter__
end

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

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.

Examples:

Get the names of the inverses.

metadata.inverses

Parameters:

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

    The document to aid in the discovery.

Returns:

  • (Array<Symbol>) —

    The inverse name.



415
416
417
418
419
420
421
 
# File 'lib/mongoid/relations/metadata.rb', line 415

def inverses(other = nil)
  if self[:polymorphic]
    lookup_inverses(other)
  else
    @inverses ||= determine_inverses
  end
end

#key ⇒ String

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.

Examples:

Get the lookup key.

metadata.key

Returns:

  • (String) —

    The association name, foreign key name, or _id.

Since:

  • 2.0.0.rc.1



617
618
619
 
# File 'lib/mongoid/relations/metadata.rb', line 617

def key
  @key ||= determine_key
end

#klass ⇒ Class

Returns the class of the proxied relation.

Examples:

Get the class.

metadata.klass

Returns:

  • (Class) —

    The class of the relation.

Since:

  • 2.0.0.rc.1



629
630
631
 
# File 'lib/mongoid/relations/metadata.rb', line 629

def klass
  @klass ||= class_name.constantize
end

#macro ⇒ Symbol

Returns the macro for the relation of this metadata.

Examples:

Get the macro.

metadata.macro

Returns:

Since:

  • 2.0.0.rc.1



653
654
655
 
# File 'lib/mongoid/relations/metadata.rb', line 653

def macro
  relation.macro
end

#many? ⇒ true, false

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

Examples:

Is the relation a many?

metadata.many?

Returns:

  • (true, false) —

    If the relation is a many.

Since:

  • 2.1.6



641
642
643
 
# File 'lib/mongoid/relations/metadata.rb', line 641

def many?
  @many ||= (relation.macro.to_s =~ /many/)
end

#name ⇒ Symbol

Get the name associated with this metadata.

Examples:

Get the name.

metadata.name

Returns:

Since:

  • 2.1.0



665
666
667
 
# File 'lib/mongoid/relations/metadata.rb', line 665

def name
  self[:name]
end

#name? ⇒ true, false

Is the name defined?

Examples:

Is the name defined?

metadata.name?

Returns:

  • (true, false) —

    If the name is defined.

Since:

  • 2.1.0



677
678
679
 
# File 'lib/mongoid/relations/metadata.rb', line 677

def name?
  !!name
end

#nested_builder(attributes, options) ⇒ NestedBuilder

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

Examples:

Get the nested builder.

metadata.nested_builder(attributes, options)

Parameters:

  • attributes (Hash) —

    The attributes to build the relation with.

  • options (Hash) —

    Options for the nested builder.

Returns:

Since:

  • 2.0.0.rc.1



706
707
708
 
# File 'lib/mongoid/relations/metadata.rb', line 706

def nested_builder(attributes, options)
  relation.nested_builder(self, attributes, options)
end

#options ⇒ Metadata

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

Examples:

Get the options.

metadata.options

Returns:

Since:

  • 2.4.6



847
848
849
 
# File 'lib/mongoid/relations/metadata.rb', line 847

def options
  self
end

#order ⇒ Criterion::Complex?

Returns default order for this association.

Examples:

Get default order

metadata.order

Returns:

  • (Criterion::Complex, nil) —

    nil if doesn’t set

Since:

  • 2.1.0



859
860
861
 
# File 'lib/mongoid/relations/metadata.rb', line 859

def order
  self[:order]
end

#order? ⇒ true, false

Is a default order set?

Examples:

Is the order set?

metadata.order?

Returns:

  • (true, false) —

    If the order is set.

Since:

  • 2.1.0



871
872
873
 
# File 'lib/mongoid/relations/metadata.rb', line 871

def order?
  !!order
end

#path(document) ⇒ Object

Get the path calculator for the supplied document.

Examples:

Get the path calculator.

metadata.path(document)

Parameters:

  • document (Document) —

    The document to calculate on.

Returns:

  • (Object) —

    The atomic path calculator.

Since:

  • 2.1.0



720
721
722
 
# File 'lib/mongoid/relations/metadata.rb', line 720

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

#polymorphic? ⇒ true, false

Returns true if the relation is polymorphic.

Examples:

Is the relation polymorphic?

metadata.polymorphic?

Returns:

  • (true, false) —

    True if the relation is polymorphic, false if not.

Since:

  • 2.0.0.rc.1



732
733
734
 
# File 'lib/mongoid/relations/metadata.rb', line 732

def polymorphic?
  @polymorphic ||= (!!self[:as] || !!self[:polymorphic])
end

#primary_key ⇒ String

Get the primary key field for finding the related document.

Examples:

Get the primary key.

metadata.primary_key

Returns:

  • (String) —

    The primary key field.

Since:

  • 3.1.0



744
745
746
 
# File 'lib/mongoid/relations/metadata.rb', line 744

def primary_key
  @primary_key ||= (self[:primary_key] || "_id").to_s
end

#relation ⇒ Proxy

Get the relation associated with this metadata.

Examples:

Get the relation.

metadata.relation

Returns:

  • (Proxy) —

    The relation proxy class.

Since:

  • 2.1.0



756
757
758
 
# File 'lib/mongoid/relations/metadata.rb', line 756

def relation
  self[:relation]
end

#setter ⇒ String

Gets the method name used to set this relation.

Examples:

Get the setter.

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

Returns:

  • (String) —

    The name plus “=”.

Since:

  • 2.0.0.rc.1



769
770
771
 
# File 'lib/mongoid/relations/metadata.rb', line 769

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

#store_as ⇒ String

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

Returns:

  • (String) —

    the name of key where save

Since:

  • 3.0.0



806
807
808
 
# File 'lib/mongoid/relations/metadata.rb', line 806

def store_as
  @store_as ||= (self[:store_as].try(:to_s) || name.to_s)
end

#touchable? ⇒ true, false

Is this relation touchable?

Examples:

Is the relation touchable?

metadata.touchable?

Returns:

  • (true, false) —

    If the relation can be touched.

Since:

  • 3.0.0



883
884
885
 
# File 'lib/mongoid/relations/metadata.rb', line 883

def touchable?
  !!self[:touch]
end

#type ⇒ String

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

Examples:

Get the name of the field.

metadata.inverse_type

Returns:

  • (String) —

    The name of the field for storing the type.

Since:

  • 2.0.0.rc.1



782
783
784
 
# File 'lib/mongoid/relations/metadata.rb', line 782

def type
  @type ||= polymorphic? ? "#{as}_type" : nil
end

#type_relation ⇒ Hash

Returns the metadata class types.

Examples:

Get the relation class types.

metadata.type_relation

Returns:

  • (Hash) —

    The hash with relation class types.

Since:

  • 3.1.0



895
896
897
 
# File 'lib/mongoid/relations/metadata.rb', line 895

def type_relation
  { _type: { "$in" => klass._types }}
end

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

metadata.inverse_type_setter

Returns:

  • (String) —

    The name of the setter.

Since:

  • 2.0.0.rc.1



795
796
797
 
# File 'lib/mongoid/relations/metadata.rb', line 795

def type_setter
  @type_setter ||= type.__setter__
end

#validate? ⇒ true, false

Are we validating this relation automatically?

Examples:

Is automatic validation on?

metadata.validate?

Returns:

  • (true, false) —

    True unless explictly set to false.

Since:

  • 2.0.0.rc.1



818
819
820
821
822
823
824
 
# File 'lib/mongoid/relations/metadata.rb', line 818

def validate?
  unless self[:validate].nil?
    self[:validate]
  else
    self[:validate] = relation.validation_default
  end
end

#versioned? ⇒ true, false

Is this relation using Mongoid’s internal versioning system?

Examples:

Is this relation versioned?

metadata.versioned?

Returns:

  • (true, false) —

    If the relation uses Mongoid versioning.

Since:

  • 2.1.0



834
835
836
 
# File 'lib/mongoid/relations/metadata.rb', line 834

def versioned?
  !!self[:versioned]
end