Class: Mongoid::Relations::Embedded::Many

Inherits:
Many show all
Includes:
Atomic
Defined in:
lib/mongoid/relations/embedded/many.rb

Overview

This class handles the behaviour for a document that embeds many other documents within in it as an array.

Constant Summary

Constants included from Atomic

Atomic::MODIFIERS

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 embeds_many relation.

Examples:

Create the new relation.

Many.new(person, addresses, metadata)

Parameters:

  • base (Document) —

    The document this relation hangs off of.

  • target (Array<Document>) —

    The child documents of the relation.

  • metadata (Metadata) —

    The relation’s metadata



199
200
201
202
203
204
205
206
 
# File 'lib/mongoid/relations/embedded/many.rb', line 199

def initialize(base, target, metadata)
  init(base, target, metadata) do
    target.each_with_index do |doc, index|
      integrate(doc)
      doc._index = index
    end
  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:



355
356
357
358
359
360
 
# File 'lib/mongoid/relations/embedded/many.rb', line 355

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

Class Method Details

.builder(meta, object, loading = false) ⇒ Builder

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

Examples:

Get the builder.

Embedded::Many.builder(meta, object)

Parameters:

  • meta (Metadata) —

    The metadata of the relation.

  • object (Document, Hash) —

    A document or attributes to build with.

Returns:

  • (Builder) —

    A newly instantiated builder object.

Since:

  • 2.0.0.rc.1



425
426
427
 
# File 'lib/mongoid/relations/embedded/many.rb', line 425

def builder(meta, object, loading = false)
  Builders::Embedded::Many.new(meta, object, loading)
end

.embedded? ⇒ true

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

Examples:

Is the relation embedded?

Embedded::Many.embedded?

Returns:

  • (true) —

    true.

Since:

  • 2.0.0.rc.1



438
439
440
 
# File 'lib/mongoid/relations/embedded/many.rb', line 438

def embedded?
  true
end

.macro ⇒ Symbol

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

Examples:

Get the relation macro.

Mongoid::Relations::Embedded::Many.macro

Returns:

Since:

  • 2.0.0.rc.1



451
452
453
 
# File 'lib/mongoid/relations/embedded/many.rb', line 451

def macro
  :embeds_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.

NestedAttributes::Many.builder(attributes, options)

Parameters:

  • metadata (Metadata) —

    The relation metadata.

  • attributes (Hash) —

    The attributes to build with.

  • options (Hash) —

    The builder options.

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:

Since:

  • 2.0.0.rc.1



477
478
479
 
# File 'lib/mongoid/relations/embedded/many.rb', line 477

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

.path(document) ⇒ Mongoid::Atomic::Paths::Embedded::Many

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:

Since:

  • 2.1.0



492
493
494
 
# File 'lib/mongoid/relations/embedded/many.rb', line 492

def path(document)
  Mongoid::Atomic::Paths::Embedded::Many.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?

Embedded::Many.stores_foreign_key?

Returns:

  • (false) —

    false.

Since:

  • 2.0.0.rc.1



505
506
507
 
# File 'lib/mongoid/relations/embedded/many.rb', line 505

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



517
518
519
 
# File 'lib/mongoid/relations/embedded/many.rb', line 517

def valid_options
  [ :as, :cyclic, :order, :versioned ]
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



530
531
532
 
# File 'lib/mongoid/relations/embedded/many.rb', line 530

def validation_default
  true
end

Instance Method Details

#<<(*args) ⇒ Object Also known as: concat, 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.addresses << address

Push a document.

person.addresses.push(address)

Concat with other documents.

person.addresses.concat([ address_one, address_two ])

Parameters:



24
25
26
27
28
29
30
31
32
 
# File 'lib/mongoid/relations/embedded/many.rb', line 24

def <<(*args)
  atomically(:$pushAll) do
    args.flatten.each do |doc|
      next unless doc
      append(doc)
      doc.save if persistable? && !assigning?
    end
  end
end

#as_document ⇒ Array<Hash>

Get this relation as as its representation in the database.

Examples:

Convert the relation to an attributes hash.

person.addresses.as_document

Returns:

  • (Array<Hash>) —

    The relation as stored in the db.

Since:

  • 2.0.0.rc.1



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

def as_document
  [].tap do |attributes|
    target.each do |doc|
      attributes << doc.as_document
    end
  end
end

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

Builds a new document in the relation and appends it to the target. Takes an optional type if you want to specify a subclass.

Examples:

Build a new document on the relation.

person.people.build(:name => "Bozo")

Parameters:

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

    The attributes to build the document with.

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

    Optional class to build the document with.

Returns:



46
47
48
49
50
51
52
 
# File 'lib/mongoid/relations/embedded/many.rb', line 46

def build(attributes = {}, type = nil)
  Factory.build(type || metadata.klass, attributes).tap do |doc|
    doc.identify
    append(doc)
    yield(doc) if block_given?
  end
end

#clear ⇒ Many

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

Examples:

Clear the relation.

person.addresses.clear

Returns:

  • (Many) —

    The empty relation.



62
63
64
65
66
 
# File 'lib/mongoid/relations/embedded/many.rb', line 62

def clear
  tap do |proxy|
    atomically(:$unset) { proxy.delete_all }
  end
end

#count ⇒ Integer

Returns a count of the number of documents in the association that have actually been persisted to the database.

Use #size if you want the total number of documents.

Examples:

Get the count of persisted documents.

person.addresses.count

Returns:

  • (Integer) —

    The total number of persisted embedded docs, as flagged by the #persisted? method.



78
79
80
 
# File 'lib/mongoid/relations/embedded/many.rb', line 78

def count
  target.select { |doc| doc.persisted? }.size
end

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

Create a new document in the relation. This is essentially the same as doing a #build then #save on the new document.

Examples:

Create a new document in the relation.

person.movies.create(:name => "Bozo")

Parameters:

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

    The attributes to build the document with.

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

    Optional class to create the document with.

Returns:

  • (Document) —

    The newly created document.



92
93
94
 
# File 'lib/mongoid/relations/embedded/many.rb', line 92

def create(attributes = {}, type = nil, &block)
  build(attributes, type, &block).tap { |doc| doc.save }
end

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

Create a new document in the relation. This is essentially the same as doing a #build then #save on the new document. If validation failed on the document an error will get raised.

Examples:

Create the document.

person.addresses.create!(:street => "Unter der Linden")</tt>

Parameters:

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

    The attributes to build the document with.

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

    Optional class to create the document with.

Returns:

  • (Document) —

    The newly created document.

Raises:



109
110
111
 
# File 'lib/mongoid/relations/embedded/many.rb', line 109

def create!(attributes = {}, type = nil, &block)
  build(attributes, type, &block).tap { |doc| doc.save! }
end

#delete(document) ⇒ Document?

Delete the supplied document from the target. This method is proxied in order to reindex the array after the operation occurs.

Examples:

Delete the document from the relation.

person.addresses.delete(address)

Parameters:

  • document (Document) —

    The document to be deleted.

Returns:

  • (Document, nil) —

    The deleted document or nil if nothing deleted.

Since:

  • 2.0.0.rc.1



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/mongoid/relations/embedded/many.rb', line 124

def delete(document)
  target.delete_one(document).tap do |doc|
    if doc && !binding?
      if assigning?
        base.add_atomic_pull(doc)
      else
        doc.delete(:suppress => true)
      end
      unbind_one(doc)
    end
    reindex
  end
end

#delete_all(conditions = {}) ⇒ Integer

Delete all the documents in the association without running callbacks.

Examples:

Delete all documents from the relation.

person.addresses.delete_all

Conditionally delete documents from the relation.

person.addresses.delete_all(:conditions => { :street => "Bond" })

Parameters:

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

    Conditions on which documents to delete.

Returns:

  • (Integer) —

    The number of documents deleted.



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

def delete_all(conditions = {})
  atomically(:$pull) { remove_all(conditions, :delete) }
end

#destroy_all(conditions = {}) ⇒ Integer

Destroy all the documents in the association whilst running callbacks.

Examples:

Destroy all documents from the relation.

person.addresses.destroy_all

Conditionally destroy documents from the relation.

person.addresses.destroy_all(:conditions => { :street => "Bond" })

Parameters:

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

    Conditions on which documents to destroy.

Returns:

  • (Integer) —

    The number of documents destroyed.



164
165
166
 
# File 'lib/mongoid/relations/embedded/many.rb', line 164

def destroy_all(conditions = {})
  atomically(:$pull) { remove_all(conditions, :destroy) }
end

#find(*args) ⇒ Array<Document>, Document

Finds a document in this association through several different methods.

Examples:

Find a document by its id.

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

Find documents for multiple ids.

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

Find documents based on conditions.

person.addresses.find(:all, :conditions => { :number => 10 })
person.addresses.find(:first, :conditions => { :number => 10 })
person.addresses.find(:last, :conditions => { :number => 10 })

Parameters:

Returns:



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

def find(*args)
  criteria.find(*args)
end

#in_memory ⇒ Array<Document>

Get all the documents in the relation that are loaded into memory.

Examples:

Get the in memory documents.

relation.in_memory

Returns:

Since:

  • 2.1.0



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

def in_memory
  target
end

#substitute(replacement) ⇒ Many

Substitutes the supplied target documents for the existing documents in the relation.

Examples:

Substitute the relation’s target.

person.addresses.substitute([ address ])

Parameters:

  • new_target (Array<Document>) —

    The replacement array.

  • building (true, false) —

    Are we in build mode?

Returns:

  • (Many) —

    The proxied relation.

Since:

  • 2.0.0.rc.1



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/mongoid/relations/embedded/many.rb', line 232

def substitute(replacement)
  tap do |proxy|
    if replacement.blank?
      if assigning? && !proxy.empty?
        base.atomic_unsets.push(proxy.first.atomic_path)
      end
      proxy.clear
    else
      atomically(:$set) do
        if replacement.first.is_a?(Hash)
          replacement = Many.builder(metadata, replacement).build
        end
        proxy.target = replacement.compact
        if assigning?
          base.delayed_atomic_sets[metadata.name.to_s] = proxy.as_document
        end
        proxy.target.each_with_index do |doc, index|
          integrate(doc)
          doc._index = index
          doc.save if base.persisted? && !assigning?
        end
      end
    end
  end
end

#unscoped ⇒ Criteria

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

Examples:

Get the unscoped criteria.

person.addresses.unscoped

Returns:

Since:

  • 2.2.1



283
284
285
 
# File 'lib/mongoid/relations/embedded/many.rb', line 283

def unscoped
  criteria(false)
end