Class: Mongoid::Relations::Referenced::Many

Inherits:
Many show all
Includes:
Batch
Defined in:
lib/mongoid/relations/referenced/many.rb

Overview

This class defines the behaviour for all relations that are a one-to-many between documents in different collections.

Direct Known Subclasses

ManyToMany

Instance Attribute Summary

Attributes inherited from Proxy

#base, #loaded, #metadata, #target

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Many

#blank?, #exists?, #find_or_create_by, #find_or_initialize_by, #nil?, #respond_to?, #scoped, #serializable_hash

Methods inherited from Proxy

#init, #substitutable

Constructor Details

#initialize(base, target, metadata) ⇒ Many

Instantiate a new references_many relation. Will set the foreign key and the base on the inverse object.

Examples:

Create the new relation.

Referenced::Many.new(base, target, metadata)

Parameters:

  • base (Document) —

    The document this relation hangs off of.

  • target (Array<Document>) —

    The target of the relation.

  • metadata (Metadata) —

    The relation’s metadata.

Since:

  • 2.0.0.beta.1



267
268
269
270
271
 
# File 'lib/mongoid/relations/referenced/many.rb', line 267

def initialize(base, target, metadata)
  init(base, Targets::Enumerable.new(target), metadata) do
    raise_mixed if klass.embedded?
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Criteria, Object (private)

If the target array does not respond to the supplied method then try to find a named scope or criteria on the class and send the call there.

If the method exists on the array, use the default proxy behavior.

Parameters:

  • name (Symbol, String) —

    The name of the method.

  • args (Array) —

    The method args

  • block (Proc) —

    Optional block to pass.

Returns:

Since:

  • 2.0.0.beta.1



443
444
445
446
447
448
449
450
451
 
# File 'lib/mongoid/relations/referenced/many.rb', line 443

def method_missing(name, *args, &block)
  if target.respond_to?(name)
    target.send(name, *args, &block)
  else
    klass.send(:with_scope, criteria) do
      criteria.send(name, *args, &block)
    end
  end
end

Class Method Details

.builder(base, meta, object) ⇒ Builder

Return the builder that is responsible for generating the documents that will be used by this relation.

Examples:

Get the builder.

Referenced::Many.builder(meta, object)

Parameters:

  • base (Document) —

    The base document.

  • meta (Metadata) —

    The metadata of the relation.

  • object (Document, Hash) —

    A document or attributes to build with.

Returns:

  • (Builder) —

    A new builder object.

Since:

  • 2.0.0.rc.1



537
538
539
 
# File 'lib/mongoid/relations/referenced/many.rb', line 537

def builder(base, meta, object)
  Builders::Referenced::Many.new(base, meta, object || [])
end

.criteria(metadata, object, type = nil) ⇒ Criteria

Get the standard criteria used for querying this relation.

Examples:

Get the criteria.

Proxy.criteria(meta, id, Model)

Parameters:

  • metadata (Metadata) —

    The metadata.

  • object (Object) —

    The value of the foreign key.

  • type (Class) (defaults to: nil) —

    The optional type.

Returns:

Since:

  • 2.1.0



553
554
555
 
# File 'lib/mongoid/relations/referenced/many.rb', line 553

def criteria(metadata, object, type = nil)
  metadata.klass.where(metadata.foreign_key => object)
end

.eager_load(metadata, ids) ⇒ Criteria

Eager load the relation based on the criteria.

Examples:

Eager load the criteria.

Proxy.eager_load(metadata, criteria)

Parameters:

  • metadata (Metadata) —

    The relation metadata.

  • ids (Array<Object>) —

    The ids of the base docs.

Returns:

  • (Criteria) —

    The criteria to eager load the relation.

Since:

  • 2.2.0



568
569
570
571
572
573
574
575
576
577
578
579
 
# File 'lib/mongoid/relations/referenced/many.rb', line 568

def eager_load(metadata, ids)
  cleared = false
  klass, foreign_key = metadata.klass, metadata.foreign_key
  klass.any_in(foreign_key => ids).each do |doc|
    base_id = doc.send(foreign_key)
    unless cleared
      IdentityMap.clear_many(klass, foreign_key => base_id)
      cleared = true
    end
    IdentityMap.set_many(doc, foreign_key => base_id)
  end
end

.embedded? ⇒ false

Returns true if the relation is an embedded one. In this case always false.

Examples:

Is this relation embedded?

Referenced::Many.embedded?

Returns:

  • (false) —

    Always false.

Since:

  • 2.0.0.rc.1



590
591
592
 
# File 'lib/mongoid/relations/referenced/many.rb', line 590

def embedded?
  false
end

.foreign_key_default ⇒ nil

Get the default value for the foreign key.

Examples:

Get the default.

Referenced::Many.foreign_key_default

Returns:

  • (nil) —

    Always nil.

Since:

  • 2.0.0.rc.1



602
603
604
 
# File 'lib/mongoid/relations/referenced/many.rb', line 602

def foreign_key_default
  nil
end

.foreign_key_suffix ⇒ String

Returns the suffix of the foreign key field, either “_id” or “_ids”.

Examples:

Get the suffix for the foreign key.

Referenced::Many.foreign_key_suffix

Returns:

Since:

  • 2.0.0.rc.1



614
615
616
 
# File 'lib/mongoid/relations/referenced/many.rb', line 614

def foreign_key_suffix
  "_id"
end

.macro ⇒ Symbol

Returns the macro for this relation. Used mostly as a helper in reflection.

Examples:

Get the macro.

Referenced::Many.macro

Returns:

  • (Symbol) —

    :references_many



625
626
627
 
# File 'lib/mongoid/relations/referenced/many.rb', line 625

def macro
  :references_many
end

.nested_builder(metadata, attributes, options) ⇒ NestedBuilder

Return the nested builder that is responsible for generating the documents that will be used by this relation.

Examples:

Get the nested builder.

Referenced::Many.builder(attributes, options)

Parameters:

  • metadata (Metadata) —

    The relation metadata.

  • attributes (Hash) —

    The attributes to build with.

  • options (Hash) —

    The options for the builder.

Options Hash (options):

  • :allow_destroy (true, false) —

    Can documents be deleted?

  • :limit (Integer) —

    Max number of documents to create at once.

  • :reject_if (Proc, Symbol) —

    If documents match this option then they are ignored.

  • :update_only (true, false) —

    Only existing documents can be modified.

Returns:

  • (NestedBuilder) —

    A newly instantiated nested builder object.

Since:

  • 2.0.0.rc.1



651
652
653
 
# File 'lib/mongoid/relations/referenced/many.rb', line 651

def nested_builder(metadata, attributes, options)
  Builders::NestedAttributes::Many.new(metadata, attributes, options)
end

.path(document) ⇒ Root

Get the path calculator for the supplied document.

Examples:

Get the path calculator.

Proxy.path(document)

Parameters:

  • document (Document) —

    The document to calculate on.

Returns:

  • (Root) —

    The root atomic path calculator.

Since:

  • 2.1.0



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

def path(document)
  Mongoid::Atomic::Paths::Root.new(document)
end

.stores_foreign_key? ⇒ false

Tells the caller if this relation is one that stores the foreign key on its own objects.

Examples:

Does this relation store a foreign key?

Referenced::Many.stores_foreign_key?

Returns:

  • (false) —

    Always false.

Since:

  • 2.0.0.rc.1



678
679
680
 
# File 'lib/mongoid/relations/referenced/many.rb', line 678

def stores_foreign_key?
  false
end

.valid_options ⇒ Array<Symbol>

Get the valid options allowed with this relation.

Examples:

Get the valid options.

Relation.valid_options

Returns:

Since:

  • 2.1.0



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

def valid_options
  [ :as, :autosave, :dependent, :foreign_key, :order ]
end

.validation_default ⇒ true, false

Get the default validation setting for the relation. Determines if by default a validates associated will occur.

Examples:

Get the validation default.

Proxy.validation_default

Returns:

  • (true, false) —

    The validation default.

Since:

  • 2.1.9



703
704
705
 
# File 'lib/mongoid/relations/referenced/many.rb', line 703

def validation_default
  true
end

Instance Method Details

#<<(*args) ⇒ Array<Document> Also known as: push

Appends a document or array of documents to the relation. Will set the parent and update the index in the process.

Examples:

Append a document.

person.posts << post

Push a document.

person.posts.push(post)

Concat with other documents.

person.posts.concat([ post_one, post_two ])

Parameters:

Returns:

Since:

  • 2.0.0.beta.1



31
32
33
34
35
36
37
38
 
# File 'lib/mongoid/relations/referenced/many.rb', line 31

def <<(*args)
  docs = args.flatten
  return concat(docs) if docs.size > 1
  if doc = docs.first
    append(doc)
    doc.save if persistable? && !_assigning? && !doc.validated?
  end
end

#build(attributes = {}, options = {}, type = nil) ⇒ Document #build(attributes = {}, type = nil) ⇒ Document Also known as: new

Build a new document from the attributes and append it to this relation without saving.

Examples:

Build a new document on the relation.

person.posts.build(:title => "A new post")

Overloads:

  • #build(attributes = {}, options = {}, type = nil) ⇒ Document

    Parameters:

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

      The attributes of the new document.

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

      The scoped assignment options.

    • type (Class) (defaults to: nil) —

      The optional subclass to build.

  • #build(attributes = {}, type = nil) ⇒ Document

    Parameters:

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

      The attributes of the new document.

    • type (Class) (defaults to: nil) —

      The optional subclass to build.

Returns:

Since:

  • 2.0.0.beta.1



85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/mongoid/relations/referenced/many.rb', line 85

def build(attributes = {}, options = {}, type = nil)
  if options.is_a? Class
    options, type = {}, options
  end

  Factory.build(type || klass, attributes, options).tap do |doc|
    append(doc)
    doc.apply_proc_defaults
    yield(doc) if block_given?
    doc.run_callbacks(:build) { doc }
  end
end

#concat(documents) ⇒ Array<Document>

Note:

When performing batch inserts the after callbacks will get executed before the documents have actually been persisted to the database due to an issue with Active Support’s callback system - we cannot explicitly fire the after callbacks by themselves.

Appends an array of documents to the relation. Performs a batch insert of the documents instead of persisting one at a time.

Examples:

Concat with other documents.

person.posts.concat([ post_one, post_two ])

Parameters:

Returns:

Since:

  • 2.4.0



57
58
59
60
61
62
63
64
65
 
# File 'lib/mongoid/relations/referenced/many.rb', line 57

def concat(documents)
  batched do
    documents.each do |doc|
      next unless doc
      append(doc)
      doc.save if persistable?
    end
  end
end

#create(attributes = nil, options = {}, type = nil) ⇒ Document #create(attributes = nil, type = nil) ⇒ Document

Creates a new document on the references many relation. This will save the document if the parent has been persisted.

Examples:

Create and save the new document.

person.posts.create(:text => "Testing")

Overloads:

  • #create(attributes = nil, options = {}, type = nil) ⇒ Document

    Parameters:

    • attributes (Hash) (defaults to: nil) —

      The attributes to create with.

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

      The scoped assignment options.

    • type (Class) (defaults to: nil) —

      The optional type of document to create.

  • #create(attributes = nil, type = nil) ⇒ Document

    Parameters:

    • attributes (Hash) (defaults to: nil) —

      The attributes to create with.

    • type (Class) (defaults to: nil) —

      The optional type of document to create.

Returns:

  • (Document) —

    The newly created document.

Since:

  • 2.0.0.beta.1



117
118
119
120
121
 
# File 'lib/mongoid/relations/referenced/many.rb', line 117

def create(attributes = nil, options = {}, type = nil, &block)
  build(attributes, options, type, &block).tap do |doc|
    base.persisted? ? doc.save : raise_unsaved(doc)
  end
end

#create!(attributes = nil, options = {}, type = nil) ⇒ Document #create!(attributes = nil, type = nil) ⇒ Document

Creates a new document on the references many relation. This will save the document if the parent has been persisted and will raise an error if validation fails.

Examples:

Create and save the new document.

person.posts.create!(:text => "Testing")

Overloads:

  • #create!(attributes = nil, options = {}, type = nil) ⇒ Document

    Parameters:

    • attributes (Hash) (defaults to: nil) —

      The attributes to create with.

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

      The scoped assignment options.

    • type (Class) (defaults to: nil) —

      The optional type of document to create.

  • #create!(attributes = nil, type = nil) ⇒ Document

    Parameters:

    • attributes (Hash) (defaults to: nil) —

      The attributes to create with.

    • type (Class) (defaults to: nil) —

      The optional type of document to create.

Returns:

  • (Document) —

    The newly created document.

Raises:

Since:

  • 2.0.0.beta.1



144
145
146
147
148
 
# File 'lib/mongoid/relations/referenced/many.rb', line 144

def create!(attributes = nil, options = {}, type = nil, &block)
  build(attributes, options, type, &block).tap do |doc|
    base.persisted? ? doc.save! : raise_unsaved(doc)
  end
end

#delete(document) ⇒ Document

Delete the document from the relation. This will set the foreign key on the document to nil. If the dependent options on the relation are :delete or :destroy the appropriate removal will occur.

Examples:

Delete the document.

person.posts.delete(post)

Parameters:

  • document (Document) —

    The document to remove.

Returns:

Since:

  • 2.1.0



162
163
164
165
166
167
168
169
 
# File 'lib/mongoid/relations/referenced/many.rb', line 162

def delete(document)
  target.delete(document) do |doc|
    if doc
      unbind_one(doc)
      cascade!(doc)
    end
  end
end

#delete_all(conditions = nil) ⇒ Integer

Deletes all related documents from the database given the supplied conditions.

Examples:

Delete all documents in the relation.

person.posts.delete_all

Conditonally delete all documents in the relation.

person.posts.delete_all(:conditions => { :title => "Testing" })

Parameters:

  • conditions (Hash) (defaults to: nil) —

    Optional conditions to delete with.

Returns:

  • (Integer) —

    The number of documents deleted.

Since:

  • 2.0.0.beta.1



185
186
187
 
# File 'lib/mongoid/relations/referenced/many.rb', line 185

def delete_all(conditions = nil)
  remove_all(conditions, :delete_all)
end

#destroy_all(conditions = nil) ⇒ Integer

Destroys all related documents from the database given the supplied conditions.

Examples:

Destroy all documents in the relation.

person.posts.destroy_all

Conditonally destroy all documents in the relation.

person.posts.destroy_all(:conditions => { :title => "Testing" })

Parameters:

  • conditions (Hash) (defaults to: nil) —

    Optional conditions to destroy with.

Returns:

  • (Integer) —

    The number of documents destroyd.

Since:

  • 2.0.0.beta.1



203
204
205
 
# File 'lib/mongoid/relations/referenced/many.rb', line 203

def destroy_all(conditions = nil)
  remove_all(conditions, :destroy_all)
end

#each ⇒ Array<Document>

Note:

This will load the entire relation into memory.

Iterate over each document in the relation and yield to the provided block.

Examples:

Iterate over the documents.

person.posts.each do |post|
  post.save
end

Returns:

Since:

  • 2.1.0



220
221
222
 
# File 'lib/mongoid/relations/referenced/many.rb', line 220

def each
  target.each { |doc| yield(doc) if block_given? }
end

#find(*args) ⇒ Document, Criteria

Note:

This will keep matching documents in memory for iteration later.

Find the matchind document on the association, either based on id or conditions.

Examples:

Find by an id.

person.posts.find(BSON::ObjectId.new)

Find by multiple ids.

person.posts.find([ BSON::ObjectId.new, BSON::ObjectId.new ])

Conditionally find all matching documents.

person.posts.find(:all, :conditions => { :title => "Sir" })

Conditionally find the first document.

person.posts.find(:first, :conditions => { :title => "Sir" })

Conditionally find the last document.

person.posts.find(:last, :conditions => { :title => "Sir" })

Parameters:

  • arg (Moped::BSON::ObjectId, Array<Moped::BSON::ObjectId>) —

    The ids.

Returns:

Since:

  • 2.0.0.beta.1



250
251
252
253
254
 
# File 'lib/mongoid/relations/referenced/many.rb', line 250

def find(*args)
  matching = criteria.find(*args)
  Array(matching).each { |doc| target.push(doc) }
  matching
end

#nullify ⇒ Object Also known as: nullify_all

Removes all associations between the base document and the target documents by deleting the foreign keys and the references, orphaning the target documents in the process.

Examples:

Nullify the relation.

person.posts.nullify

Since:

  • 2.0.0.rc.1



281
282
283
284
285
286
 
# File 'lib/mongoid/relations/referenced/many.rb', line 281

def nullify
  criteria.update(metadata.foreign_key => nil)
  target.clear do |doc|
    unbind_one(doc)
  end
end

#purge ⇒ Many Also known as: clear

Clear the relation. Will delete the documents from the db if they are already persisted.

Examples:

Clear the relation.

person.posts.clear

Returns:

  • (Many) —

    The relation emptied.

Since:

  • 2.0.0.beta.1



298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/mongoid/relations/referenced/many.rb', line 298

def purge
  unless metadata.destructive?
    nullify
  else
    criteria.delete_all
    target.clear do |doc|
      unbind_one(doc)
      doc.destroyed = true
    end
  end
end

#substitute(replacement) ⇒ Many

Substitutes the supplied target documents for the existing documents in the relation. If the new target is nil, perform the necessary deletion.

Examples:

Replace the relation.

person.posts.substitute([ new_post ])

Parameters:

Returns:

  • (Many) —

    The relation.

Since:

  • 2.0.0.rc.1



323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/mongoid/relations/referenced/many.rb', line 323

def substitute(replacement)
  tap do |proxy|
    if replacement
      new_docs, docs = replacement.compact.uniq, []
      new_ids = new_docs.map { |doc| doc.id }
      remove_not_in(new_ids)
      new_docs.each do |doc|
        docs.push(doc) if doc.send(metadata.foreign_key) != base.id
      end
      proxy.concat(docs)
    else
      proxy.purge
    end
  end
end

#unscoped ⇒ Criteria

Get a criteria for the documents without the default scoping applied.

Examples:

Get the unscoped criteria.

person.posts.unscoped

Returns:

Since:

  • 2.4.0



348
349
350
351
352
 
# File 'lib/mongoid/relations/referenced/many.rb', line 348

def unscoped
  klass.unscoped.where(
    metadata.foreign_key => Conversions.flag(base.id, metadata)
  )
end