mongoid 2.0.2 → 2.1.0

data/lib/mongoid/persistence/operations.rb

@@ -0,0 +1,214 @@
+# 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(:other)
+          if conflicts
+            @conflicts = { "$pushAll" => conflicts }
+          end
+        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

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Operations #: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
+        include Modification, Operations
+
+        # Persist the document that is to be updated to the database. This will
+        # only write changed fields via MongoDB's $set modifier operation.
+        #
+        # @example Update the document.
+        #   Update.persist
+        #
+        # @return [ true, false ] If the save passed.
+        def persist
+          prepare do
+            unless updates.empty?
+              collection.update(selector, updates, options)
+              collection.update(selector, conflicts, options) if conflicts
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -60,8 +60,7 @@ module Rails #:nodoc:
       initializer "setup database" do
         config_file = Rails.root.join("config", "mongoid.yml")
         if config_file.file?
-          settings = YAML.load(ERB.new(config_file.read).result)[Rails.env]
-          ::Mongoid.from_hash(settings) if settings.present?
+          ::Mongoid.load!(config_file)
         end
       end
 
@@ -76,17 +75,6 @@ module Rails #:nodoc:
         end
       end
 
-      # Due to all models not getting loaded and messing up inheritance queries
-      # and indexing, we need to preload the models in order to address this.
-      #
-      # This will happen every request in development, once in ther other
-      # environments.
-      initializer "preload all application models" do |app|
-        config.to_prepare do
-          ::Rails::Mongoid.load_models(app) unless $rails_rake_task
-        end
-      end
-
       # Set the proper error types for Rails. DocumentNotFound errors should be
       # 404s and not 500s, validation errors are 422s.
       initializer "load http errors" do |app|
@@ -98,27 +86,27 @@ module Rails #:nodoc:
         end
       end
 
-      # When workers are forked in passenger and unicorn, we need to reconnect
-      # to the database to all the workers do not share the same connection.
-      initializer "reconnect to master if application is preloaded" do
-        config.after_initialize do
-
-          # Unicorn clears the START_CTX when a worker is forked, so if we have
-          # data in START_CTX then we know we're being preloaded. Unicorn does
-          # not provide application-level hooks for executing code after the
-          # process has forked, so we reconnect lazily.
-          if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
-            ::Mongoid.reconnect!(false)
-          end
+      # Due to all models not getting loaded and messing up inheritance queries
+      # and indexing, we need to preload the models in order to address this.
+      #
+      # This will happen every request in development, once in ther other
+      # environments.
+      initializer "preload all application models" do |app|
+        config.to_prepare do
+          ::Rails::Mongoid.load_models(app) unless $rails_rake_task
+        end
+      end
 
-          # Passenger provides the :starting_worker_process event for executing
-          # code after it has forked, so we use that and reconnect immediately.
-          if defined?(PhusionPassenger)
-            PhusionPassenger.on_event(:starting_worker_process) do |forked|
-              if forked
-                ::Mongoid.reconnect!
-              end
-            end
+      # This initializer warns the user that preloading models is set to false,
+      # and queries will be inconsistent in dev mode if models are using
+      # inheritance.
+      initializer "warn of preload models configuration" do |app|
+        config.after_initialize do
+          if !::Mongoid.preload_models && !Rails.configuration.cache_classes
+            puts "\nMongoid preload_models is set to false. If you are using"
+            puts "inheritance in your application model please set this to true or "
+            puts "you will experience querying inconsistencies in dev mode. Note that"
+            puts "this will severely decrease performance in dev mode only.\n\n"
           end
         end
       end