mongoid 2.0.0.rc.7 → 2.0.0.rc.8

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Pull < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The pull operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$pull" =>
+              { path =>
+                { "_id" =>
+                  { "$in" => documents.map { |doc| doc["_id"] } }
+                }
+              }
+            }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "$pull" => { "addresses" => { "_id" => "street" } } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pull" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$pull"
+              documents.push(operations[path])
+            when "$pullAll"
+              documents.concat(operations[path])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class PushAll < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The set operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$pushAll" => { path => documents } }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "$push" => { "addresses" => { "_id" => "street" } } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pushAll" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$push"
+              documents.push(operations[path])
+            when "$pushAll"
+              documents.concat(operations[path])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Set < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The set operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$set" => { path => documents } }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "addresses" => { "$pushAll" => [{ "_id" => "street" }] } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pushAll" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$push"
+              documents.push(operations[path])
+            when "$pushAll"
+              documents.push(operations[path].first)
+            when "$set"
+              @documents = operations[path]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Unset < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The set operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$unset" => { path => true } }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "addresses" => { "$pushAll" => [{ "_id" => "street" }] } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            @path ||= operations[modifier].keys.first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,31 @@ module Mongoid # :nodoc:
       # This class handles the behaviour for a document that embeds many other
       # documents within in it as an array.
       class Many < Relations::Many
+        include Atomic
+
+        # Appends a document or array of documents to the relation. Will set
+        # the parent and update the index in the process.
+        #
+        # @example Append a document.
+        #   person.addresses << address
+        #
+        # @example Push a document.
+        #   person.addresses.push(address)
+        #
+        # @example Concat with other documents.
+        #   person.addresses.concat([ address_one, address_two ])
+        #
+        # @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]
+            end
+          end
+        end
 
         # 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
@@ -26,7 +51,9 @@ module Mongoid # :nodoc:
         # @since 2.0.0.rc.1
         def bind(options = {})
           binding.bind(options)
-          target.each(&:save) if base.persisted? && !options[:binding]
+          if base.persisted? && !options[:binding]
+            atomically(:$set) { target.each(&:save) }
+          end
         end
 
         # Bind the inverse relation between a single document in this proxy
@@ -80,8 +107,8 @@ module Mongoid # :nodoc:
         # @param [ Class ] type Optional class to create the document with.
         #
         # @return [ Document ] The newly created document.
-        def create(attributes = {}, type = nil)
-          build(attributes, type).tap(&:save)
+        def create(attributes = {}, type = nil, &block)
+          build(attributes, type, &block).tap(&:save)
         end
 
         # Create a new document in the relation. This is essentially the same
@@ -97,15 +124,15 @@ module Mongoid # :nodoc:
         # @raise [ Errors::Validations ] If a validation error occured.
         #
         # @return [ Document ] The newly created document.
-        def create!(attributes = {}, type = nil)
-          build(attributes, type).tap(&:save!)
+        def create!(attributes = {}, type = nil, &block)
+          build(attributes, type, &block).tap(&:save!)
         end
 
         # Delete the supplied document from the target. This method is proxied
         # in order to reindex the array after the operation occurs.
         #
         # @example Delete the document from the relation.
-        #   perosn.addresses.delete(address)
+        #   person.addresses.delete(address)
         #
         # @param [ Document ] document The document to be deleted.
         #
@@ -128,7 +155,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Integer ] The number of documents deleted.
         def delete_all(conditions = {})
-          remove_all(conditions, false)
+          atomically(:$pull) { remove_all(conditions, :delete) }
         end
 
         # Destroy all the documents in the association whilst running callbacks.
@@ -143,7 +170,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Integer ] The number of documents destroyed.
         def destroy_all(conditions = {})
-          remove_all(conditions, true)
+          atomically(:$pull) { remove_all(conditions, :destroy) }
         end
 
         # Finds a document in this association through several different
@@ -164,15 +191,7 @@ module Mongoid # :nodoc:
         #
         # @return [ Array<Document>, Document ] A single or multiple documents.
         def find(*args)
-          type, criteria = Criteria.parse!(self, true, *args)
-          case type
-          when :first then return criteria.one
-          when :last then return criteria.last
-          else
-            criteria.tap do |crit|
-              crit.documents = target if crit.is_a?(Criteria)
-            end
-          end
+          criteria.find(*args)
         end
 
         # Instantiate a new embeds_many relation.
@@ -226,8 +245,6 @@ module Mongoid # :nodoc:
         #
         # @return [ WillPaginate::Collection ] The paginated documents.
         def paginate(options)
-          criteria = Mongoid::Criteria.translate(metadata.klass, true, options)
-          criteria.documents = target
           criteria.paginate(options)
         end
 
@@ -248,10 +265,9 @@ module Mongoid # :nodoc:
           tap do |relation|
             relation.target = new_target || []
             if !new_target.blank?
-              unbind(old_target, options)
-              bind(options)
+              atomically(:$set) { rebind(old_target, options) }
             else
-              unbind(old_target, options)
+              atomically(:$unset) { unbind(old_target, options) }
             end
           end
         end
@@ -382,17 +398,33 @@ module Mongoid # :nodoc:
         # @param [ true, false ] destroy If true then destroy, else delete.
         #
         # @return [ Integer ] The number of documents removed.
-        def remove_all(conditions = {}, destroy = false)
-          criteria = find(conditions || {})
+        def remove_all(conditions = {}, method = :delete)
+          criteria = find(:all, conditions || {})
           criteria.size.tap do
             criteria.each do |doc|
               target.delete(doc)
-              destroy ? doc.destroy : doc.delete
+              doc.send(method)
             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

data/lib/mongoid/relations/macros.rb

@@ -78,7 +78,7 @@ module Mongoid # :nodoc:
         def embeds_many(name, options = {}, &block)
           characterize(name, Embedded::Many, options, &block).tap do |meta|
             relate(name, meta)
-            validate_relation(meta)
+            validates_relation(meta)
           end
         end
 
@@ -105,7 +105,7 @@ module Mongoid # :nodoc:
           characterize(name, Embedded::One, options, &block).tap do |meta|
             relate(name, meta)
             builder(name).creator(name)
-            validate_relation(meta)
+            validates_relation(meta)
           end
         end
 
@@ -131,6 +131,7 @@ module Mongoid # :nodoc:
           characterize(name, Referenced::In, options, &block).tap do |meta|
             relate(name, meta)
             reference(meta)
+            validates_relation(meta)
           end
         end
         alias :belongs_to_related :referenced_in
@@ -160,7 +161,7 @@ module Mongoid # :nodoc:
             relate(name, meta)
             reference(meta)
             autosave(meta)
-            validate_relation(meta)
+            validates_relation(meta)
           end
         end
         alias :has_many_related :references_many
@@ -190,6 +191,7 @@ module Mongoid # :nodoc:
           characterize(name, Referenced::ManyToMany, options, &block).tap do |meta|
             relate(name, meta)
             reference(meta)
+            validates_relation(meta)
           end
         end
         alias :has_and_belongs_to_many :references_and_referenced_in_many
@@ -217,7 +219,7 @@ module Mongoid # :nodoc:
             relate(name, meta)
             reference(meta)
             builder(name).creator(name).autosave(meta)
-            validate_relation(meta)
+            validates_relation(meta)
           end
         end
         alias :has_one_related :references_one

data/lib/mongoid/relations/many.rb

@@ -16,7 +16,7 @@ module Mongoid #:nodoc:
       #   person.addresses.push(address)
       #
       # @example Concat with other documents.
-      #   perosn.addresses.concat([ address_one, address_two ])
+      #   person.addresses.concat([ address_one, address_two ])
       #
       # @param [ Document, Array<Document> ] *args Any number of documents.
       def <<(*args)
@@ -40,11 +40,12 @@ module Mongoid #:nodoc:
       # @param [ Class ] type Optional class to build the document with.
       #
       # @return [ Document ] The new document.
-      def build(attributes = {}, type = nil)
+      def build(attributes = {}, type = nil, &block)
         instantiated(type).tap do |doc|
-          append(doc, default_options(:binding => true))
           doc.write_attributes(attributes)
           doc.identify
+          append(doc, default_options(:binding => true))
+          block.call(doc) if block
         end
       end
       alias :new :build
@@ -59,8 +60,9 @@ module Mongoid #:nodoc:
       # @param [ Class ] type The optional type of document to create.
       #
       # @return [ Document ] The newly created document.
-      def create(attributes = nil, type = nil)
+      def create(attributes = nil, type = nil, &block)
         build(attributes, type).tap do |doc|
+          block.call(doc) if block
           doc.save if base.persisted?
         end
       end
@@ -103,8 +105,8 @@ module Mongoid #:nodoc:
       # @param [ Hash ] attrs The attributes to search or create with.
       #
       # @return [ Document ] An existing document or newly created one.
-      def find_or_create_by(attrs = {})
-        find_or(:create, attrs)
+      def find_or_create_by(attrs = {}, &block)
+        find_or(:create, attrs, &block)
       end
 
       # Find the first +Document+ given the conditions, or instantiates a new document
@@ -116,8 +118,34 @@ module Mongoid #:nodoc:
       # @param [ Hash ] attrs The attributes to search or initialize with.
       #
       # @return [ Document ] An existing document or newly instantiated one.
-      def find_or_initialize_by(attrs = {})
-        find_or(:build, attrs)
+      def find_or_initialize_by(attrs = {}, &block)
+        find_or(:build, attrs, &block)
+      end
+
+      # This proxy can never be nil.
+      #
+      # @example Is the proxy nil?
+      #   relation.nil?
+      #
+      # @return [ false ] Always false.
+      #
+      # @since 2.0.0
+      def nil?
+        false
+      end
+
+      # Since method_missing is overridden we should override this as well.
+      #
+      # @example Does the proxy respond to the method?
+      #   relation.respond_to?(:name)
+      #
+      # @param [ Symbol ] name The method name.
+      #
+      # @return [ true, false ] If the proxy responds to the method.
+      #
+      # @since 2.0.0
+      def respond_to?(name)
+        [].respond_to?(name) || methods.include?(name)
       end
 
       # Gets the document as a serializable hash, used by ActiveModel's JSON and
@@ -140,6 +168,19 @@ module Mongoid #:nodoc:
         target.map { |document| document.serializable_hash(options) }
       end
 
+      # Always returns the number of documents that are in memory.
+      #
+      # @example Get the number of loaded documents.
+      #   relation.size
+      #
+      # @return [ Integer ] The number of documents in memory.
+      #
+      # @since 2.0.0
+      def size
+        target.size
+      end
+      alias :length :size
+
       private
 
       # Get the default options used in binding functions.
@@ -164,8 +205,8 @@ module Mongoid #:nodoc:
       # @param [ Hash ] attrs The attributes to build with.
       #
       # @return [ Document ] A matching document or a new/created one.
-      def find_or(method, attrs = {})
-        find(:first, :conditions => attrs) || send(method, attrs)
+      def find_or(method, attrs = {}, &block)
+        find(:first, :conditions => attrs) || send(method, attrs, &block)
       end
     end
   end