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

data/lib/mongoid/persistence/atomic/add_to_set.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides the ability to perform an explicit $addToSet
+      # modification on a specific field.
+      class AddToSet < Operation
+
+        # Sends the atomic $addToSet operation to the database.
+        #
+        # @example Persist the new values.
+        #   addToSet.persist
+        #
+        # @return [ Object ] The new array value.
+        #
+        # @since 2.0.0
+        def persist
+          document[field] = [] unless document[field]
+          values = document.send(field)
+          values.push(value) unless values.include?(value)
+          values.tap do
+            document.collection.update(document._selector, operation("$addToSet"), options)
+            document.changes.delete(field.to_s) if document.persisted?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/inc.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides atomic $inc behaviour.
+      class Inc < Operation
+
+        # Sends the atomic $inc operation to the database.
+        #
+        # @example Persist the new values.
+        #   inc.persist
+        #
+        # @return [ Object ] The new integer value.
+        #
+        # @since 2.0.0
+        def persist
+          current = document[field] || 0
+          document[field] = current + value
+          document[field].tap do
+            document.collection.update(document._selector, operation("$inc"), options)
+            document.changes.delete(field.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/operation.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This is the superclass for all atomic operation objects.
+      class Operation
+        include Mongoid::Safe
+
+        attr_reader :document, :field, :value, :options
+
+        # Initialize the new pullAll operation.
+        #
+        # @example Create a new pullAll operation.
+        #   PullAll.new(document, :aliases, [ "Bond" ])
+        #
+        # @param [ Document ] document The document to pullAll onto.
+        # @param [ Symbol ] field The name of the array field.
+        # @param [ Object ] value The value to pullAll.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @since 2.0.0
+        def initialize(document, field, value, options = {})
+          @document, @field, @value = document, field, value
+          @options = { :safe => safe_mode?(options) }
+        end
+
+        # Get the atomic operation to perform.
+        #
+        # @example Get the operation.
+        #   inc.operation
+        #
+        # @param [ String ] modifier The modifier to use.
+        #
+        # @return [ Hash ] The atomic operation for the field and addition.
+        #
+        # @since 2.0.0
+        def operation(modifier)
+          { modifier => { field => value } }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/pull_all.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides the ability to perform an explicit $pullAll
+      # modification on a specific field.
+      class PullAll < Operation
+
+        # Sends the atomic $pullAll operation to the database.
+        #
+        # @example Persist the new values.
+        #   pull_all.persist
+        #
+        # @return [ Object ] The new array value.
+        #
+        # @since 2.0.0
+        def persist
+          if document[field]
+            values = document.send(field)
+            values.delete_if { |val| value.include?(val) }
+            values.tap do
+              document.collection.update(document._selector, operation("$pullAll"), options)
+              document.changes.delete(field.to_s) if document.persisted?
+            end
+          else
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/atomic/push.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    module Atomic #:nodoc:
+
+      # This class provides the ability to perform an explicit $push modification
+      # on a specific field.
+      class Push < Operation
+
+        # Sends the atomic $push operation to the database.
+        #
+        # @example Persist the new values.
+        #   push.persist
+        #
+        # @return [ Object ] The new array value.
+        #
+        # @since 2.0.0
+        def persist
+          document[field] = [] unless document[field]
+          document.send(field).push(value).tap do |value|
+            document.collection.update(document._selector, operation("$push"), options)
+            document.changes.delete(field.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -35,7 +35,7 @@ module Rails #:nodoc:
       #   module MyApplication
       #     class Application < Rails::Application
       #       config.mongoid.logger = Logger.new($stdout, :warn)
-      #       config.mongoid.reconnect_time = 10
+      #       config.mongoid.persist_in_safe_mode = true
       #     end
       #   end
       config.mongoid = ::Mongoid::Config
@@ -124,6 +124,18 @@ module Rails #:nodoc:
           end
         end
       end
+
+      # Instantitate any registered observers after Rails initialization and
+      # instantiate them after being reloaded in the development environment
+      initializer "instantiate observers" do
+        config.after_initialize do
+          ::Mongoid.instantiate_observers
+
+          ActionDispatch::Callbacks.to_prepare(:mongoid_instantiate_observers) do
+            ::Mongoid.instantiate_observers
+          end
+        end
+      end
     end
   end
 end

data/lib/mongoid/relations.rb

@@ -10,6 +10,7 @@ require "mongoid/relations/builders"
 require "mongoid/relations/many"
 require "mongoid/relations/one"
 require "mongoid/relations/polymorphic"
+require "mongoid/relations/embedded/atomic"
 require "mongoid/relations/embedded/in"
 require "mongoid/relations/embedded/many"
 require "mongoid/relations/embedded/one"

data/lib/mongoid/relations/accessors.rb

@@ -90,6 +90,20 @@ module Mongoid # :nodoc:
         instance_variable_set("@#{name}", relation)
       end
 
+      # Replace an existing relation with a new one.
+      #
+      # @example Replace the relation.
+      #   document.substitute("addresses", Address.new)
+      #
+      # @param [ String ] name The name of the relation.
+      # @param [ Document ] object The document to replace with.
+      # @options [ Hash ] options The options.
+      #
+      # @since 2.0.0
+      def substitute(name, object, options)
+        set(name, ivar(name).substitute(object, options))
+      end
+
       module ClassMethods #:nodoc:
 
         # Defines the getter for the relation. Nothing too special here: just
@@ -144,9 +158,13 @@ module Mongoid # :nodoc:
               object, options = args.first, options(args)
               variable = "@#{name}"
               if relation_exists?(name) && !object.is_a?(Hash)
-                set(name, ivar(name).substitute(object, options))
+                substitute(name, object, options)
               else
-                build(name, object, metadata, options.merge(:eager => true))
+                if metadata.embedded? && object.blank? && send(name)
+                  substitute(name, object, options)
+                else
+                  build(name, object, metadata, options.merge(:eager => true))
+                end
               end
             end
           end

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

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

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

@@ -24,10 +24,16 @@ module Mongoid # :nodoc:
             if over_limit?(attributes)
               raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
             end
-            attributes.each { |attrs| process(attrs[1]) }
+            attributes.each do |attrs|
+              if attrs.respond_to?(:with_indifferent_access)
+                process(attrs)
+              else
+                process(attrs[1])
+              end
+            end
           end
 
-          # Create the new builder for nested attributes on one-to-one
+          # Create the new builder for nested attributes on one-to-many
           # relations.
           #
           # Example:
@@ -44,8 +50,12 @@ module Mongoid # :nodoc:
           #
           # A new builder.
           def initialize(metadata, attributes, options = {})
-            @attributes = attributes.with_indifferent_access.sort do |a, b|
-              a[0] <=> b[0]
+            if attributes.respond_to?(:with_indifferent_access)
+              @attributes = attributes.with_indifferent_access.sort do |a, b|
+                a[0].to_i <=> b[0].to_i
+              end
+            else
+              @attributes = attributes
             end
             @metadata = metadata
             @options = options
@@ -102,8 +112,9 @@ module Mongoid # :nodoc:
           # attrs: The single document attributes to process.
           def process(attrs)
             return if reject?(attrs)
-            if attrs[:id]
-              document = existing.find(convert_id(attrs[:id]))
+            if attrs[:id] or attrs['id'] or attrs['_id']
+              id = attrs[:id] || attrs['id'] || attrs['_id']
+              document = existing.find(convert_id(id))
               destroyable?(attrs) ? document.destroy : document.update_attributes(attrs)
             else
               # @todo: Durran: Tell the push not to save the base and call it

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

@@ -16,8 +16,9 @@ module Mongoid # :nodoc:
           # @return [ Array<Document> ] The documents.
           def build(type = nil)
             return object unless query?
+            return [] if object.is_a?(Array)
             key = metadata.foreign_key
-            metadata.klass.find(:conditions => { key => object })
+            metadata.klass.all(:conditions => { key => object })
           end
         end
       end

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

@@ -17,6 +17,7 @@ module Mongoid # :nodoc:
           def build(type = nil)
             return object unless query?
             if object.is_a?(Hash)
+              object.delete(:binding)
               return Mongoid::Factory.build(metadata.klass, object)
             end
             metadata.klass.first(

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

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require "mongoid/relations/embedded/atomic/operation"
+require "mongoid/relations/embedded/atomic/pull"
+require "mongoid/relations/embedded/atomic/push_all"
+require "mongoid/relations/embedded/atomic/set"
+require "mongoid/relations/embedded/atomic/unset"
+
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+
+      # This module provides the ability for calls to be declared atomic.
+      module Atomic
+
+        MODIFIERS = {
+          :$pull => Pull,
+          :$pushAll => PushAll,
+          :$set => Set,
+          :$unset => Unset
+        }
+
+        private
+
+        # Executes a block of commands in an atomic fashion. Mongoid will
+        # intercept all database upserts while in this block and combine them
+        # into a single database call. When the block concludes the atomic
+        # update will occur.
+        #
+        # Since the collection is accessed through the class it would not be
+        # thread safe to give it state so we access the atomic updater via the
+        # current thread.
+        #
+        # @note This operation is not safe when attemping to do illegal updates
+        #   for different objects or collections, since the updator is not
+        #   scoped on the thread. This is meant for Mongoid internal use only
+        #   to keep existing design clean.
+        #
+        # @example Atomically $set multiple saves.
+        #   atomically(:$set) do
+        #     address_one.save!
+        #     address_two.save!
+        #   end
+        #
+        # @example Atomically $pushAll multiple new docs.
+        #   atomically(:$pushAll) do
+        #     person.addresses.push([ address_one, address_two ])
+        #   end
+        #
+        # @param [ Symbol ] modifier The atomic modifier to perform.
+        # @param [ Proc ] block The block to execute.
+        #
+        # @return [ Object ] The result of the operation.
+        #
+        # @since 2.0.0
+        def atomically(modifier, &block)
+          updater = Thread.current[:mongoid_atomic_update] ||= MODIFIERS[modifier].new
+          count_executions do
+            block.call if block
+          end.tap do
+            if @executions.zero?
+              Thread.current[:mongoid_atomic_update] = nil
+              updater.execute(collection)
+            end
+          end
+        end
+
+        # Execute the block, incrementing the executions before the call and
+        # decrementing them after in order to be able to nest blocks within
+        # each other.
+        #
+        # @example Execute and increment.
+        #   execute { block.call }
+        #
+        # @param [ Proc ] block The block to call.
+        #
+        # @since 2.0.0
+        def count_executions(&block)
+          @executions ||= 0 and @executions += 1
+          block.call.tap do
+            @executions -=1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Operation
+          attr_accessor :documents, :options, :path, :selector
+
+          # Consumes an execution that was supposed to hit the database, but is
+          # now being deferred to later in favor of a single update.
+          #
+          # @example Consume the operation.
+          #   set.consume(
+          #     { "_id" => BSON::ObjectId.new },
+          #     { "$push" => { "addresses" => { "_id" => "street" } } },
+          #     { :multi => false, :safe => true }
+          #   )
+          #
+          # @param [ Hash ] selector The document selector.
+          # @param [ Hash ] operations The ops to set in the db.
+          # @param [ Hash ] options The persistence options.
+          #
+          # @option options [ true, false ] :multi Persist multiple at once.
+          # @option options [ true, false ] :safe Persist in safe mode.
+          #
+          # @since 2.0.0
+          def consume(selector, operations, options = {})
+            @consumed, @selector, @options = true, selector, options
+            @documents ||= []
+            parse(operations)
+          end
+
+          # Has this operation consumed any executions?
+          #
+          # @example Is this consumed?
+          #   unset.consumed?
+          #
+          # @return [ true, false ] If the operation has consumed anything.
+          #
+          # @since 2.0.0
+          def consumed?
+            !!@consumed
+          end
+
+          # Execute the $pushAll operation on the collection.
+          #
+          # @example Execute the operation.
+          #   unset.execute(collection)
+          #
+          # @param [ Collection ] collection The root collection.
+          #
+          # @since 2.0.0
+          def execute(collection)
+            if collection && consumed?
+              collection.update(selector, operations, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end