mongoid 2.0.2 → 2.1.0

data/lib/mongoid/relations/builders/embedded/one.rb

@@ -17,7 +17,11 @@ module Mongoid # :nodoc:
           # @return [ Document ] A single document.
           def build(type = nil)
             return object unless object.is_a?(Hash)
-            Mongoid::Factory.from_db(metadata.klass, object)
+            if loading
+              Mongoid::Factory.from_db(metadata.klass, object)
+            else
+              Mongoid::Factory.build(metadata.klass, object)
+            end
           end
         end
       end

data/lib/mongoid/relations/builders/nested_attributes/many.rb

@@ -114,9 +114,9 @@ module Mongoid # :nodoc:
             return if reject?(attrs)
             if id = attrs[:id] || attrs["id"] || attrs["_id"]
               document = existing.find(convert_id(id))
-              destroyable?(attrs) ? document.destroy : document.update_attributes(attrs)
+              destroyable?(attrs) ? existing.delete(document) : document.update_attributes(attrs)
             else
-              existing.push(metadata.klass.new(attrs)) unless destroyable?(attrs)
+              existing.push(Mongoid::Factory.build(metadata.klass, attrs)) unless destroyable?(attrs)
             end
           end
         end

data/lib/mongoid/relations/builders/nested_attributes/one.rb

@@ -27,7 +27,7 @@ module Mongoid # :nodoc:
             if update?
               existing.attributes = attributes
             elsif replace?
-              parent.send(metadata.setter, metadata.klass.new(attributes))
+              parent.send(metadata.setter, Mongoid::Factory.build(metadata.klass, attributes))
             elsif delete?
               parent.send(metadata.setter, nil)
             end

data/lib/mongoid/relations/builders/referenced/in.rb

@@ -16,11 +16,8 @@ module Mongoid # :nodoc:
           # @return [ Document ] A single document.
           def build(type = nil)
             return object unless query?
-            begin
-              (type ? type.constantize : metadata.klass).find(object)
-            rescue Errors::DocumentNotFound
-              return nil
-            end
+            model = type ? type.constantize : metadata.klass
+            IdentityMap.get(model, object) || metadata.criteria(object, model).first
           end
         end
       end

data/lib/mongoid/relations/builders/referenced/many.rb

@@ -17,8 +17,7 @@ module Mongoid # :nodoc:
           def build(type = nil)
             return object unless query?
             return [] if object.is_a?(Array)
-            key = metadata.foreign_key
-            metadata.klass.where(key => convertable(metadata, object))
+            metadata.criteria(convertable(metadata, object))
           end
 
           private
@@ -37,7 +36,7 @@ module Mongoid # :nodoc:
             if inverse.using_object_ids? || object.is_a?(BSON::ObjectId)
               object
             else
-              Mongoid::Criterion::Unconvertable.new(object)
+              Criterion::Unconvertable.new(object)
             end
           end
         end

data/lib/mongoid/relations/builders/referenced/many_to_many.rb

@@ -16,11 +16,20 @@ module Mongoid # :nodoc:
           # @return [ Array<Document> ] The documents.
           def build(type = nil)
             return object.try(:dup) unless query?
-            begin
-              metadata.klass.find(object)
-            rescue Errors::DocumentNotFound
-              return []
-            end
+            metadata.criteria(object)
+          end
+
+          # Do we need to perform a database query? It will be so if the object we
+          # have is not a document.
+          #
+          # @example Should we query the database?
+          #   builder.query?
+          #
+          # @return [ true, false ] Whether a database query should happen.
+          #
+          # @since 2.0.0.rc.1
+          def query?
+            object.nil? || !object.first.is_a?(Mongoid::Document)
           end
         end
       end

data/lib/mongoid/relations/builders/referenced/one.rb

@@ -16,9 +16,8 @@ module Mongoid # :nodoc:
           # @return [ Document ] A single document.
           def build(type = nil)
             return object unless query?
-            metadata.klass.first(
-              :conditions => { metadata.foreign_key => object }
-            )
+            criteria = metadata.criteria(object)
+            IdentityMap.match(criteria) || criteria.first
           end
         end
       end

data/lib/mongoid/relations/embedded/atomic.rb

@@ -53,12 +53,12 @@ module Mongoid #:nodoc:
         #
         # @since 2.0.0
         def atomically(modifier, &block)
-          updater = Thread.current[:mongoid_atomic_update] ||= MODIFIERS[modifier].new
+          updater = Threaded.update ||= MODIFIERS[modifier].new
           count_executions do
             block.call if block
           end.tap do
             if @executions.zero?
-              Thread.current[:mongoid_atomic_update] = nil
+              Threaded.update = nil
               updater.execute(collection)
             end
           end

data/lib/mongoid/relations/embedded/in.rb

@@ -8,28 +8,6 @@ module Mongoid # :nodoc:
       # multiple documents.
       class In < Relations::One
 
-        # Binds the base object to the inverse of the relation. This is so we
-        # are referenced to the actual objects themselves and dont hit the
-        # database twice when setting the relations up.
-        #
-        # This is called after first creating the relation, or if a new object
-        # is set on the relation.
-        #
-        # @example Bind the relation.
-        #   name.person.bind(:continue => true)
-        #
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def bind(options = {})
-          binding.bind(options)
-          base.save if target.persisted? && !options[:binding]
-        end
-
         # Instantiate a new embedded_in relation.
         #
         # @example Create the new relation.
@@ -43,29 +21,32 @@ module Mongoid # :nodoc:
         def initialize(base, target, metadata)
           init(base, target, metadata) do
             characterize_one(target)
-            base.parentize(target)
+            bind_one
+            base.save if persistable?
           end
         end
 
-        # Unbinds the base object to the inverse of the relation. This occurs
-        # when setting a side of the relation to nil.
+        # Substitutes the supplied target documents for the existing document
+        # in the relation.
         #
-        # Will delete the object if necessary.
+        # @example Substitute the new document.
+        #   person.name.substitute(new_name)
         #
-        # @example Unbind the relation.
-        #   name.person.unbind(:continue => false)
+        # @param [ Document ] other A document to replace the target.
         #
-        # @param [ Proxy ] old_target The previous target of the relation.
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
+        # @return [ Document, nil ] The relation or nil.
         #
         # @since 2.0.0.rc.1
-        def unbind(old_target, options = {})
-          binding(old_target).unbind(options)
-          base.delete if old_target.persisted? && !base.destroyed?
+        def substitute(replacement)
+          tap do |proxy|
+            proxy.unbind_one
+            unless replacement
+              base.delete unless binding?
+              return nil
+            end
+            proxy.target = replacement
+            proxy.bind_one
+          end
         end
 
         private
@@ -80,8 +61,32 @@ module Mongoid # :nodoc:
         # @return [ Binding ] A binding object.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Embedded::In.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Embedded::In.new(base, target, metadata)
+        end
+
+        # Characterize the document.
+        #
+        # @example Set the base metadata.
+        #   relation.characterize_one(document)
+        #
+        # @param [ Document ] document The document to set the metadata on.
+        #
+        # @since 2.1.0
+        def characterize_one(document)
+          base.metadata = metadata.inverse_metadata(document)
+        end
+
+        # Are we able to persist this relation?
+        #
+        # @example Can we persist the relation?
+        #   relation.persistable?
+        #
+        # @return [ true, false ] If the relation is persistable.
+        #
+        # @since 2.1.0
+        def persistable?
+          target.persisted? && !binding? && !building?
         end
 
         class << self
@@ -98,8 +103,8 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A newly instantiated builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Embedded::In.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Embedded::In.new(meta, object, loading)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -154,6 +159,20 @@ module Mongoid # :nodoc:
             Builders::NestedAttributes::One.new(metadata, attributes, options)
           end
 
+          # Get the path calculator for the supplied document.
+          #
+          # @example Get the path calculator.
+          #   Proxy.path(document)
+          #
+          # @param [ Document ] document The document to calculate on.
+          #
+          # @return [ Root ] The root atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Root.new(document)
+          end
+
           # Tells the caller if this relation is one that stores the foreign
           # key on its own objects.
           #
@@ -166,6 +185,18 @@ module Mongoid # :nodoc:
           def stores_foreign_key?
             false
           end
+
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [ :cyclic, :polymorphic ]
+          end
         end
       end
     end

data/lib/mongoid/relations/embedded/many.rb

@@ -22,55 +22,35 @@ module Mongoid # :nodoc:
         #
         # @param [ Document, Array<Document> ] *args Any number of documents.
         def <<(*args)
-          options = default_options(args)
           atomically(:$pushAll) do
             args.flatten.each do |doc|
-              return doc unless doc
-              append(doc, options)
-              doc.save if base.persisted? && !options[:binding]
+              next unless doc
+              append(doc)
+              doc.save if persistable?
             end
           end
         end
+        alias :concat :<<
+        alias :push :<<
 
-        # Binds the base object to the inverse of the relation. This is so we
-        # are referenced to the actual objects themselves and dont hit the
-        # database twice when setting the relations up.
+        # Builds a new document in the relation and appends it to the target.
+        # Takes an optional type if you want to specify a subclass.
         #
-        # This is called after first creating the relation, or if a new object
-        # is set on the relation.
+        # @example Build a new document on the relation.
+        #   person.people.build(:name => "Bozo")
         #
-        # @example Bind the relation.
-        #   person.addresses.bind(:continue => true)
-        #
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def bind(options = {})
-          binding.bind(options)
-          if base.persisted? && !options[:binding]
-            atomically(:$set) { target.each(&:save) }
+        # @param [ Hash ] attributes The attributes to build the document with.
+        # @param [ Class ] type Optional class to build the document with.
+        #
+        # @return [ Document ] The new document.
+        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
-
-        # Bind the inverse relation between a single document in this proxy
-        # instead of the entire target.
-        #
-        # Used when appending to the target instead of setting the entire
-        # thing.
-        #
-        # @example Bind a single document.
-        #   person.addressses.bind_one(address)
-        #
-        # @param [ Document ] document The document to bind.
-        #
-        # @since 2.0.0.rc.1
-        def bind_one(document, options = {})
-          binding.bind_one(document, options)
-        end
+        alias :new :build
 
         # Clear the relation. Will delete the documents from the db if they are
         # already persisted.
@@ -80,7 +60,9 @@ module Mongoid # :nodoc:
         #
         # @return [ Many ] The empty relation.
         def clear
-          load! and substitute(nil)
+          tap do |proxy|
+            atomically(:$unset) { proxy.delete_all }
+          end
         end
 
         # Returns a count of the number of documents in the association that have
@@ -94,7 +76,7 @@ module Mongoid # :nodoc:
         # @return [ Integer ] The total number of persisted embedded docs, as
         #   flagged by the #persisted? method.
         def count
-          target.select(&:persisted?).size
+          target.select { |doc| doc.persisted? }.size
         end
 
         # Create a new document in the relation. This is essentially the same
@@ -108,7 +90,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Document ] The newly created document.
         def create(attributes = {}, type = nil, &block)
-          build(attributes, type, &block).tap(&:save)
+          build(attributes, type, &block).tap { |doc| doc.save }
         end
 
         # Create a new document in the relation. This is essentially the same
@@ -125,7 +107,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Document ] The newly created document.
         def create!(attributes = {}, type = nil, &block)
-          build(attributes, type, &block).tap(&:save!)
+          build(attributes, type, &block).tap { |doc| doc.save! }
         end
 
         # Delete the supplied document from the target. This method is proxied
@@ -140,7 +122,10 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def delete(document)
-          target.delete(document).tap { reindex }
+          target.delete_one(document).tap do |doc|
+            unbind_one(doc) if doc && !binding?
+            reindex
+          end
         end
 
         # Delete all the documents in the association without running callbacks.
@@ -207,29 +192,22 @@ module Mongoid # :nodoc:
         def initialize(base, target, metadata)
           init(base, target, metadata) do
             target.each_with_index do |doc, index|
-              characterize_one(doc)
-              doc.parentize(base)
+              integrate(doc)
               doc._index = index
             end
           end
         end
 
-        # Will load the target into an array if the target had not already been
-        # loaded.
+        # Get all the documents in the relation that are loaded into memory.
         #
-        # @example Load the relation into memory.
-        #   relation.load!
+        # @example Get the in memory documents.
+        #   relation.in_memory
         #
-        # @return [ Many ] The relation.
+        # @return [ Array<Document> ] The documents in memory.
         #
-        # @since 2.0.0.rc.5
-        def load!(options = {})
-          tap do |relation|
-            unless relation.loaded?
-              relation.bind(options)
-              relation.loaded = true
-            end
-          end
+        # @since 2.1.0
+        def in_memory
+          target
         end
 
         # Substitutes the supplied target documents for the existing documents
@@ -244,14 +222,19 @@ module Mongoid # :nodoc:
         # @return [ Many ] The proxied relation.
         #
         # @since 2.0.0.rc.1
-        def substitute(new_target, options = {})
-          old_target = target
-          tap do |relation|
-            relation.target = new_target || []
-            if !new_target.blank?
-              atomically(:$set) { rebind(old_target, options) }
+        def substitute(replacement)
+          tap do |proxy|
+            if replacement.blank?
+              proxy.clear
             else
-              atomically(:$unset) { unbind(old_target, options) }
+              atomically(:$set) do
+                proxy.target = replacement
+                proxy.target.each_with_index do |doc, index|
+                  integrate(doc)
+                  doc._index = index
+                  doc.save if base.persisted?
+                end
+              end
             end
           end
         end
@@ -265,32 +248,9 @@ module Mongoid # :nodoc:
         #
         # @since 2.0.0.rc.1
         def as_document
-          target.inject([]) do |attributes, doc|
-            attributes.tap do |attr|
-              attr << doc.as_document
-            end
-          end
-        end
-
-        # Unbind the inverse relation from this set of documents. Used when the
-        # entire proxy has been cleared, set to nil or empty, or replaced.
-        #
-        # @example Unbind the relation.
-        #   person.addresses.unbind(target, :continue => false)
-        #
-        # @param [ Array<Document> ] old_target The relations previous target.
-        # @param [ Hash ] options The options to bind with.
-        #
-        # @option options [ true, false ] :binding Are we in build mode?
-        # @option options [ true, false ] :continue Continue binding the
-        #   inverse?
-        #
-        # @since 2.0.0.rc.1
-        def unbind(old_target, options = {})
-          binding(old_target).unbind(options)
-          if base.persisted?
-            old_target.each do |doc|
-              doc.delete unless doc.destroyed?
+          [].tap do |attributes|
+            target.each do |doc|
+              attributes << doc.as_document
             end
           end
         end
@@ -306,10 +266,9 @@ module Mongoid # :nodoc:
         # @param [ Document ] document The document to append to the target.
         #
         # @since 2.0.0.rc.1
-        def append(document, options = {})
-          load! and target.push(document)
-          characterize_one(document)
-          bind_one(document, options)
+        def append(document)
+          target.push(document)
+          integrate(document)
           document._index = target.size - 1
         end
 
@@ -323,8 +282,8 @@ module Mongoid # :nodoc:
         # @return [ Binding ] The many binding.
         #
         # @since 2.0.0.rc.1
-        def binding(new_target = nil)
-          Bindings::Embedded::Many.new(base, new_target || target, metadata)
+        def binding
+          Bindings::Embedded::Many.new(base, target, metadata)
         end
 
         # Returns the criteria object for the target class with its documents set
@@ -335,11 +294,25 @@ module Mongoid # :nodoc:
         #
         # @return [ Criteria ] A new criteria.
         def criteria
-          metadata.klass.criteria(true).tap do |criterion|
+          klass.criteria(true).tap do |criterion|
             criterion.documents = target
           end
         end
 
+        # Integrate the document into the relation. will set its metadata and
+        # attempt to bind the inverse.
+        #
+        # @example Integrate the document.
+        #   relation.integrate(document)
+        #
+        # @param [ Document ] document The document to integrate.
+        #
+        # @since 2.1.0
+        def integrate(document)
+          characterize_one(document)
+          bind_one(document)
+        end
+
         # 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.
         #
@@ -351,13 +324,24 @@ module Mongoid # :nodoc:
         #
         # @return [ Criteria, Object ] A Criteria or return value from the target.
         def method_missing(name, *args, &block)
-          load!(:binding => true) and return super if target.respond_to?(name)
-          klass = metadata.klass
+          return super if target.respond_to?(name)
           klass.send(:with_scope, criteria) do
             criteria.send(name, *args, &block)
           end
         end
 
+        # Are we able to persist this relation?
+        #
+        # @example Can we persist the relation?
+        #   relation.persistable?
+        #
+        # @return [ true, false ] If the relation is persistable.
+        #
+        # @since 2.1.0
+        def persistable?
+          base.persisted? && !binding?
+        end
+
         # Reindex all the target elements. This is useful when performing
         # operations on the proxied target directly and the indices need to
         # match that on the database side.
@@ -386,29 +370,14 @@ module Mongoid # :nodoc:
           criteria = find(:all, conditions || {})
           criteria.size.tap do
             criteria.each do |doc|
-              target.delete(doc)
+              target.delete_one(doc)
+              unbind_one(doc)
               doc.send(method, :suppress => true)
             end
             reindex
           end
         end
 
-        # Convenience method to clean up the substitute code. Unbinds the old
-        # target and reindexes.
-        #
-        # @example Rebind the relation.
-        #   relation.rebind([])
-        #
-        # @param [ Array<Document> ] old_target The old target.
-        # @param [ Hash ] options The options passed to substitute.
-        #
-        # @since 2.0.0
-        def rebind(old_target, options)
-          reindex
-          unbind(old_target, options)
-          bind(options)
-        end
-
         class << self
 
           # Return the builder that is responsible for generating the documents
@@ -424,8 +393,8 @@ module Mongoid # :nodoc:
           # @return [ Builder ] A newly instantiated builder object.
           #
           # @since 2.0.0.rc.1
-          def builder(meta, object)
-            Builders::Embedded::Many.new(meta, object)
+          def builder(meta, object, loading = false)
+            Builders::Embedded::Many.new(meta, object, loading)
           end
 
           # Returns true if the relation is an embedded one. In this case
@@ -480,6 +449,21 @@ module Mongoid # :nodoc:
             Builders::NestedAttributes::Many.new(metadata, attributes, options)
           end
 
+          # Get the path calculator for the supplied document.
+          #
+          # @example Get the path calculator.
+          #   Proxy.path(document)
+          #
+          # @param [ Document ] document The document to calculate on.
+          #
+          # @return [ Mongoid::Atomic::Paths::Embedded::Many ]
+          #   The embedded many atomic path calculator.
+          #
+          # @since 2.1.0
+          def path(document)
+            Mongoid::Atomic::Paths::Embedded::Many.new(document)
+          end
+
           # Tells the caller if this relation is one that stores the foreign
           # key on its own objects.
           #
@@ -492,6 +476,18 @@ module Mongoid # :nodoc:
           def stores_foreign_key?
             false
           end
+
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [ :as, :cyclic, :order, :versioned ]
+          end
         end
       end
     end