stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/paranoia.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # Include this module to get soft deletion of root level documents.
+  # This will add a deleted_at field to the +Document+, managed automatically.
+  # Potentially incompatible with unique indices. (if collisions with deleted items)
+  #
+  # To use:
+  #
+  #   class Person
+  #     include Mongoid::Document
+  #     include Mongoid::Paranoia
+  #   end
+  module Paranoia
+    extend ActiveSupport::Concern
+
+    included do
+      field :deleted_at, :type => Time
+    end
+
+    # Delete the paranoid +Document+ from the database completely. This will
+    # run the destroy callbacks.
+    #
+    # Example:
+    #
+    # <tt>document.destroy!</tt>
+    def destroy!
+      run_callbacks(:destroy) { delete! }
+    end
+
+    # Delete the paranoid +Document+ from the database completely.
+    #
+    # Example:
+    #
+    # <tt>document.delete!</tt>
+    def delete!
+      @destroyed = true
+      Mongoid::Persistence::Remove.new(self).persist
+    end
+
+    # Delete the +Document+, will set the deleted_at timestamp and not actually
+    # delete it.
+    #
+    # Example:
+    #
+    # <tt>document._remove</tt>
+    #
+    # Returns:
+    #
+    # true
+    def _remove(options = {})
+      now = Time.now
+      collection.update({ :_id => self.id }, { '$set' => { :deleted_at => Time.now } })
+      @attributes["deleted_at"] = now
+      true
+    end
+
+    alias :delete :_remove
+
+    # Determines if this document is destroyed.
+    #
+    # Returns:
+    #
+    # true if the +Document+ was destroyed.
+    def destroyed?
+      @destroyed || !!deleted_at
+    end
+
+    # Restores a previously soft-deleted document. Handles this by removing the
+    # deleted_at flag.
+    #
+    # Example:
+    #
+    # <tt>document.restore</tt>
+    def restore
+      collection.update({ :_id => self.id }, { '$unset' => { :deleted_at => true } })
+      @attributes.delete("deleted_at")
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Override the default +Criteria+ accessor to only get existing
+      # documents.
+      #
+      # Returns:
+      #
+      # A +Criteria+ for deleted_at not existing.
+      def criteria(embedded = false)
+        super.where(:deleted_at.exists => false)
+      end
+
+      # Find deleted documents
+      #
+      # Examples:
+      #
+      #   <tt>Person.deleted</tt>  # all deleted employees
+      #   <tt>Company.first.employees.deleted</tt>  # works with a join
+      #   <tt>Person.deleted.find("4c188dea7b17235a2a000001").first</tt>
+      def deleted
+        where(:deleted_at.exists => true)
+      end
+    end
+  end
+end

data/lib/mongoid/paths.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :__path
+      attr_accessor :_index
+    end
+
+    # Get the insertion modifier for the document. Will be nil on root
+    # documents, $set on embeds_one, $push on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.inserter</tt>
+    def _inserter
+      embedded? ? (embedded_many? ? "$push" : "$set") : nil
+    end
+
+    # Return the path to this +Document+ in JSON notation, used for atomic
+    # updates via $set in MongoDB.
+    #
+    # Example:
+    #
+    # <tt>address.path # returns "addresses"</tt>
+    def _path
+      _position.sub!(/\.\d+$/, '') || _position
+    end
+    alias :_pull :_path
+
+    # Returns the positional operator of this document for modification.
+    #
+    # Example:
+    #
+    # <tt>address.position</tt>
+    def _position
+      locator = _index ? (new_record? ? "" : ".#{_index}") : ""
+      embedded? ? "#{_parent._position}#{"." unless _parent._position.blank?}#{metadata.name.to_s}#{locator}" : ""
+    end
+
+    # Get the removal modifier for the document. Will be nil on root
+    # documents, $unset on embeds_one, $set on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.remover</tt>
+    def _remover
+      embedded? ? (_index ? "$pull" : "$unset") : nil
+    end
+
+    # Return the selector for this document to be matched exactly for use
+    # with MongoDB's $ operator.
+    #
+    # Example:
+    #
+    # <tt>address.selector</tt>
+    def _selector
+      embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }
+    end
+  end
+end

data/lib/mongoid/persistence/command.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Persistence commands extend from this class to get basic functionality on
+    # initialization.
+    class Command
+      include Mongoid::Safe
+
+      attr_reader \
+        :collection,
+        :document,
+        :klass,
+        :options,
+        :selector,
+        :validate
+
+      # Initialize the persistence +Command+.
+      #
+      # Options:
+      #
+      # document_or_class: The +Document+ or +Class+ to get the collection.
+      # options: Options like validation or safe mode.
+      # selector: Optional selector to use in query.
+      #
+      # Example:
+      #
+      # <tt>DeleteAll.new(Person, { :validate => true }, {})</tt>
+      def initialize(document_or_class, options = {}, selector = {})
+        init(document_or_class)
+        validate = options[:validate]
+        @validate = (validate.nil? ? true : validate)
+        @selector = selector
+        @options = { :safe => safe_mode?(options) }
+      end
+
+      private
+
+      # Setup the proper instance variables based on if the supplied argument
+      # was a document object or a class object.
+      #
+      # Example:
+      #
+      # <tt>init(document_or_class)</tt>
+      #
+      # Options:
+      #
+      # document_or_class: A document or a class.
+      def init(document_or_class)
+        if document_or_class.is_a?(Mongoid::Document)
+          @document = document_or_class
+          @collection = @document.embedded? ? @document._root.collection : @document.collection
+        else
+          @klass = document_or_class
+          @collection = @klass.collection
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class Insert < Command
+
+      # Insert the new document in the database. This delegates to the standard
+      # MongoDB collection's insert command.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        return document if validate && document.invalid?(:create)
+        document.run_callbacks(:create) do
+          document.run_callbacks(:save) do
+            if insert
+              document.new_record = false
+              document._children.each { |child| child.new_record = false }
+              document.move_changes
+            end
+          end
+        end; document
+      end
+
+      protected
+      # Insert the document into the database.
+      def insert
+        if document.embedded?
+          Persistence::InsertEmbedded.new(
+            document,
+            options.merge(:validate => validate)
+          ).persist
+        else
+          collection.insert(document.to_hash, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert_embedded.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it. This specific class
+    # handles the case when the document is embedded in another.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class InsertEmbedded < Command
+
+      # Insert the new document in the database. If the document's parent is a
+      # new record, we will call save on the parent, otherwise we will $push
+      # the document onto the parent.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        return document if validate && document.invalid?(:create)
+        parent = document._parent
+        if parent.new_record?
+          parent.insert
+        else
+          update = { document._inserter => { document._position => document.raw_attributes } }
+          collection.update(parent._selector, update, options.merge(:multi => false))
+          document.new_record = false
+        end
+        document
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class Remove < Command
+
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        if document.embedded?
+          Persistence::RemoveEmbedded.new(
+            document,
+            options.merge(:validate => validate)
+          ).persist
+        else
+          collection.remove({ :_id => document.id }, options)
+        end; true
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_all.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "field" : value },
+    #     false
+    #   );
+    class RemoveAll < Command
+
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        select = (klass.hereditary? ? selector.merge(:_type => klass.name) : selector)
+        collection.find(select).count.tap do
+          collection.remove(select, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_embedded.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class RemoveEmbedded < Command
+
+      # Remove the document from the database. If the parent is a new record,
+      # it will get removed in Ruby only. If the parent is not a new record
+      # then either an $unset or $set will occur, depending if it's an
+      # embeds_one or embeds_many.
+      #
+      # Example:
+      #
+      # <tt>RemoveEmbedded.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on if the removal passed.
+      def persist
+        parent = document._parent
+        parent.remove_child(document)
+        unless parent.new_record?
+          update = { document._remover => removal_selector }
+          collection.update(parent._selector, update, options.merge(:multi => false))
+        end; true
+      end
+
+      protected
+      # Get the value to pass to the removal modifier.
+      def setter
+        document._index ? document.id : true
+      end
+
+      def removal_selector
+        document._index ? { document._pull => { "_id" => document.id } } : { document._path => setter }
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/update.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Update is a persistence command responsible for taking a document that
+    # has already been saved to the database and saving it, depending on
+    # whether or not the document has been modified.
+    #
+    # Before persisting the command will check via dirty attributes if the
+    # document has changed, if not, it will simply return true. If it has it
+    # will go through the validation steps, run callbacks, and set the changed
+    # fields atomically on the document. The underlying query resembles the
+    # following MongoDB query:
+    #
+    #   collection.update(
+    #     { "_id" : 1,
+    #     { "$set" : { "field" : "value" },
+    #     false,
+    #     false
+    #   );
+    #
+    # For embedded documents it will use the positional locator:
+    #
+    #   collection.update(
+    #     { "_id" : 1, "addresses._id" : 2 },
+    #     { "$set" : { "addresses.$.field" : "value" },
+    #     false,
+    #     false
+    #   );
+    #
+    class Update < Command
+
+      # Persist the document that is to be updated to the database. This will
+      # only write changed fields via MongoDB's $set modifier operation.
+      #
+      # Example:
+      #
+      # <tt>Update.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on validation.
+      def persist
+        return false if validate && document.invalid?(:update)
+        document.run_callbacks(:save) do
+          document.run_callbacks(:update) do
+            if update
+              document.move_changes
+              document._children.each do |child|
+                child.move_changes
+                child.new_record = false if child.new_record?
+              end
+            else
+              return false
+            end
+          end
+        end; true
+      end
+
+      protected
+      # Update the document in the database atomically.
+      def update
+        updates = document._updates
+        unless updates.empty?
+          other_pushes = updates.delete(:other)
+          collection.update(document._selector, updates, options.merge(:multi => false))
+          collection.update(
+            document._selector,
+            { "$pushAll" => other_pushes },
+            options.merge(:multi => false)
+          ) if other_pushes
+        end; true
+      end
+    end
+  end
+end