mongoid-multi-db 3.0.0

data/lib/mongoid/persistence/deletion.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Contains common logic for delete operations.
+    module Deletion
+
+      # Wrap all the common delete logic for both root and embedded
+      # documents and then yield to the block.
+      #
+      # @example Execute common delete logic.
+      #   prepare do |doc|
+      #     collection.remove({ :_id => "value })
+      #   end
+      #
+      # @param [ Proc ] block The block to call.
+      #
+      # @return [ true ] Always true.
+      #
+      # @since 2.1.0
+      def prepare(&block)
+        document.cascade!
+        yield(document)
+        document.freeze
+        document.destroyed = true
+        IdentityMap.remove(document)
+        Threaded.clear_options!
+        true
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insertion.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Contains common logic for insertion operations.
+    module Insertion
+
+      # Wrap all the common insertion logic for both root and embedded
+      # documents and then yield to the block.
+      #
+      # @example Execute common insertion logic.
+      #   prepare do |doc|
+      #     collection.insert({ :field => "value })
+      #   end
+      #
+      # @param [ Proc ] block The block to call.
+      #
+      # @return [ Document ] The inserted document.
+      #
+      # @since 2.1.0
+      def prepare(&block)
+        document.tap do |doc|
+          unless validating? && document.invalid?(:create)
+            result = doc.run_callbacks(:save) do
+              doc.run_callbacks(:create) do
+                yield(doc)
+                doc.new_record = false
+                doc.reset_persisted_children and true
+              end
+            end
+
+            unless result == false
+              doc.move_changes
+              Threaded.clear_options!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/modification.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Contains common logic for modification operations.
+    module Modification
+
+      # Wrap all the common modification logic for both root and embedded
+      # documents and then yield to the block.
+      #
+      # @example Execute common modification logic.
+      #   prepare do |doc|
+      #     collection.update({ :_id => 1 }, { :field => "value })
+      #   end
+      #
+      # @param [ Proc ] block The block to call.
+      #
+      # @return [ true, false ] If the save passed or not.
+      #
+      # @since 2.1.0
+      def prepare(&block)
+        return false if validating? && document.invalid?(:update)
+        document.run_callbacks(:save) do
+          document.run_callbacks(:update) do
+            yield(document); true
+          end
+        end.tap do |result|
+          unless result == false
+            document.reset_persisted_children
+            document.move_changes
+            Threaded.clear_options!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/operations.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+require "mongoid/persistence/operations/insert"
+require "mongoid/persistence/operations/remove"
+require "mongoid/persistence/operations/update"
+require "mongoid/persistence/operations/embedded/insert"
+require "mongoid/persistence/operations/embedded/remove"
+
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # Persistence operations include this module to get basic functionality
+    # on initialization.
+    module Operations
+
+      attr_reader :conflicts, :document
+
+      # Get the collection we should be persisting to.
+      #
+      # @example Get the collection.
+      #   operation.collection
+      #
+      # @return [ Collection ] The collection to persist to.
+      #
+      # @since 2.1.0
+      def collection
+        @collection ||= document._root.collection
+      end
+
+      # Get the atomic delete operations for embedded documents.
+      #
+      # @example Get the atomic deletes.
+      #   operation.deletes
+      #
+      # @return [ Hash ] The atomic delete selector.
+      #
+      # @since 2.1.0
+      def deletes
+        { document.atomic_delete_modifier =>
+          { document.atomic_path =>
+            document._index ? { "_id" => document.id } : true } }
+      end
+
+      # Instantiate the new persistence operation.
+      #
+      # @example Create the operation.
+      #   Operation.new(document, { :safe => true }, { "field" => "value" })
+      #
+      # @param [ Document ] document The document to persist.
+      # @param [ Hash ] options The persistence options.
+      #
+      # @since 2.1.0
+      def initialize(document, options = {})
+        @document, @options = document, options
+      end
+
+      # Get the atomic insert for embedded documents, either a push or set.
+      #
+      # @example Get the inserts.
+      #   operation.inserts
+      #
+      # @return [ Hash ] The insert ops.
+      #
+      # @since 2.1.0
+      def inserts
+        { document.atomic_insert_modifier =>
+          { document.atomic_position => document.as_document } }
+      end
+
+      # Should the parent document (in the case of embedded persistence) be
+      # notified of the child deletion. This is used when calling delete from
+      # the associations themselves.
+      #
+      # @example Should the parent be notified?
+      #   operation.notifying_parent?
+      #
+      # @return [ true, false ] If the parent should be notified.
+      #
+      # @since 2.1.0
+      def notifying_parent?
+        @notifying_parent ||= !@options.delete(:suppress)
+      end
+
+      # Get all the options that will be sent to the database. Right now this
+      # is only safe mode opts.
+      #
+      # @example Get the options hash.
+      #   operation.options
+      #
+      # @return [ Hash ] The options for the database.
+      #
+      # @since 2.1.0
+      def options
+        Safety.merge_safety_options(@options)
+      end
+
+      # Get the parent of the provided document.
+      #
+      # @example Get the parent.
+      #   operation.parent
+      #
+      # @return [ Document ] The parent document.
+      #
+      # @since 2.1.0
+      def parent
+        document._parent
+      end
+
+      # Get the atomic selector for the document.
+      #
+      # @example Get the selector.
+      #   operation.selector.
+      #
+      # @return [ Hash ] The mongodb selector.
+      #
+      # @since 2.1.0
+      def selector
+        @selector ||= document.atomic_selector
+      end
+
+      # Get the atomic updates for the document without the conflicting
+      # modifications.
+      #
+      # @example Get the atomic updates.
+      #   operation.updates
+      #
+      # @return [ Hash ] The updates sans conflicting mods.
+      #
+      # @since 2.1.0
+      def updates
+        @updates ||= init_updates
+      end
+
+      # Should we be running validations on this persistence operation?
+      # Defaults to true.
+      #
+      # @example Run validations?
+      #   operation.validating?
+      #
+      # @return [ true, false ] If we run validations.
+      #
+      # @since 2.1.0
+      def validating?
+        @validating ||= @options[:validate].nil? ? true : @options[:validate]
+      end
+
+      private
+
+      # Initialize the atomic updates and conflicting modifications.
+      #
+      # @example Initialize the updates.
+      #   operation.init_updates
+      #
+      # @return [ Hash ] The atomic updates.
+      #
+      # @since 2.1.0
+      def init_updates
+        document.atomic_updates.tap do |updates|
+          @conflicts = updates.delete(:conflicts) || {}
+        end
+      end
+
+      class << self
+
+        # Get the appropriate removal operation based on the document.
+        #
+        # @example Get the deletion operation.
+        #   Operations.remove(doc, options)
+        #
+        # @param [ Document ] doc The document to persist.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Operations ] The operation.
+        #
+        # @since 2.1.0
+        def remove(doc, options = {})
+          (doc.embedded? ? Embedded::Remove : Remove).new(doc, options)
+        end
+
+        # Get the appropriate insertion operation based on the document.
+        #
+        # @example Get the insertion operation.
+        #   Operations.insert(doc, options)
+        #
+        # @param [ Document ] doc The document to persist.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Operations ] The operation.
+        #
+        # @since 2.1.0
+        def insert(doc, options = {})
+          (doc.embedded? ? Embedded::Insert : Insert).new(doc, options)
+        end
+
+        # Get the appropriate update operation based on the document.
+        #
+        # @example Get the update operation.
+        #   Operations.update(doc, options)
+        #
+        # @param [ Document ] doc The document to persist.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Operations ] The operation.
+        #
+        # @since 2.1.0
+        def update(doc, options = {})
+          Update.new(doc, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/operations/embedded/insert.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #:nodoc:
+      module Embedded #: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.update(
+        #     { "_id" : 1 },
+        #     { "$push" : { "field" : "value" } },
+        #     false
+        #   );
+        class Insert
+          include Insertion, Operations
+
+          # 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 Insert an embedded document.
+          #   Insert.persist
+          #
+          # @return [ Document ] The document to be inserted.
+          def persist
+            prepare do
+              if parent.new?
+                parent.insert
+              else
+                collection.update(parent.atomic_selector, inserts, options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/operations/embedded/remove.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #:nodoc:
+      module Embedded #: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
+          include Deletion, Operations
+
+          # 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 Remove an embedded document.
+          #   RemoveEmbedded.persist
+          #
+          # @return [ true ] Always true.
+          def persist
+            prepare do |doc|
+              parent.remove_child(doc) if notifying_parent?
+              if parent.persisted?
+                collection.update(parent.atomic_selector, deletes, options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/operations/insert.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #: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
+        include Insertion, Operations
+
+        # Insert the new document in the database. This delegates to the standard
+        # MongoDB collection's insert command.
+        #
+        # @example Insert the document.
+        #   Insert.persist
+        #
+        # @return [ Document ] The document to be inserted.
+        def persist
+          prepare do |doc|
+            collection.insert(doc.as_document, options)
+            IdentityMap.set(doc)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/operations/remove.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #: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
+        include Deletion, Operations
+
+        # Remove the document from the database: delegates to the MongoDB
+        # collection remove method.
+        #
+        # @example Remove the document.
+        #   Remove.persist
+        #
+        # @return [ true ] Always true.
+        def persist
+          prepare do |doc|
+            collection.remove({ :_id => doc.id }, options)
+          end
+        end
+      end
+    end
+  end
+end