mongoid-multi-db 3.0.0

data/lib/mongoid/atomic.rb

@@ -0,0 +1,230 @@
+# encoding: utf-8
+require "mongoid/atomic/modifiers"
+require "mongoid/atomic/paths"
+
+module Mongoid #:nodoc:
+
+  # This module contains the logic for supporting atomic operations against the
+  # database.
+  module Atomic
+    extend ActiveSupport::Concern
+
+    included do
+
+      # When MongoDB finally fully implements the positional operator, we can
+      # get rid of all indexing related code in Mongoid.
+      attr_accessor :_index
+    end
+
+    # Get all the atomic updates that need to happen for the current
+    # +Document+. This includes all changes that need to happen in the
+    # entire hierarchy that exists below where the save call was made.
+    #
+    # @note MongoDB does not allow "conflicting modifications" to be
+    #   performed in a single operation. Conflicting modifications are
+    #   detected by the 'haveConflictingMod' function in MongoDB.
+    #   Examination of the code suggests that two modifications (a $set
+    #   and a $pushAll, for example) conflict if:
+    #     (1) the key paths being modified are equal.
+    #     (2) one key path is a prefix of the other.
+    #   So a $set of 'addresses.0.street' will conflict with a $pushAll
+    #   to 'addresses', and we will need to split our update into two
+    #   pieces. We do not, however, attempt to match MongoDB's logic
+    #   exactly. Instead, we assume that two updates conflict if the
+    #   first component of the two key paths matches.
+    #
+    # @example Get the updates that need to occur.
+    #   person.atomic_updates(children)
+    #
+    # @return [ Hash ] The updates and their modifiers.
+    #
+    # @since 2.1.0
+    def atomic_updates
+      Modifiers.new.tap do |mods|
+        generate_atomic_updates(mods, self)
+        _children.each do |child|
+          generate_atomic_updates(mods, child)
+        end
+      end
+    end
+    alias :_updates :atomic_updates
+
+    # Get the removal modifier for the document. Will be nil on root
+    # documents, $unset on embeds_one, $set on embeds_many.
+    #
+    # @example Get the removal operator.
+    #   name.atomic_delete_modifier
+    #
+    # @return [ String ] The pull or unset operation.
+    def atomic_delete_modifier
+      atomic_paths.delete_modifier
+    end
+
+    # Get the insertion modifier for the document. Will be nil on root
+    # documents, $set on embeds_one, $push on embeds_many.
+    #
+    # @example Get the insert operation.
+    #   name.atomic_insert_modifier
+    #
+    # @return [ String ] The pull or set operator.
+    def atomic_insert_modifier
+      atomic_paths.insert_modifier
+    end
+
+    # Return the path to this +Document+ in JSON notation, used for atomic
+    # updates via $set in MongoDB.
+    #
+    # @example Get the path to this document.
+    #   address.atomic_path
+    #
+    # @return [ String ] The path to the document in the database.
+    def atomic_path
+      atomic_paths.path
+    end
+
+    # Returns the positional operator of this document for modification.
+    #
+    # @example Get the positional operator.
+    #   address.atomic_position
+    #
+    # @return [ String ] The positional operator with indexes.
+    def atomic_position
+      atomic_paths.position
+    end
+
+    # Get all the attributes that need to be pulled.
+    #
+    # @example Get the pulls.
+    #   person.atomic_pulls
+    #
+    # @return [ Array<Hash> ] The $pullAll operations.
+    #
+    # @since 2.2.0
+    def atomic_pulls
+      delayed_atomic_pulls.inject({}) do |pulls, (name, docs)|
+        pulls.tap do |pull|
+          docs.each do |doc|
+            (pull[doc.atomic_path] ||= []).push(doc.as_document)
+            doc.destroyed = true
+            doc.flagged_for_destroy = false
+          end
+        end
+      end
+    end
+
+    # Add the document as an atomic pull.
+    #
+    # @example Add the atomic pull.
+    #   person.add_atomic_pull(address)
+    #
+    # @param [ Document ] The embedded document to pull.
+    #
+    # @since 2.2.0
+    def add_atomic_pull(document)
+      document.flagged_for_destroy = true
+      (delayed_atomic_pulls[document.metadata.name.to_s] ||= []).push(document)
+    end
+
+    # Get all the push attributes that need to occur.
+    #
+    # @example Get the pushes.
+    #   person.atomic_pushes
+    #
+    # @return [ Hash ] The $pushAll operations.
+    #
+    # @since 2.1.0
+    def atomic_pushes
+      pushable? ? { atomic_path => as_document } : {}
+    end
+
+    # Return the selector for this document to be matched exactly for use
+    # with MongoDB's $ operator.
+    #
+    # @example Get the selector.
+    #   address.atomic_selector
+    #
+    # @return [ String ] The exact selector for this document.
+    def atomic_selector
+      atomic_paths.selector
+    end
+
+    # Get all the attributes that need to be set.
+    #
+    # @example Get the sets.
+    #   person.atomic_sets
+    #
+    # @return [ Hash ] The $set operations.
+    #
+    # @since 2.1.0
+    def atomic_sets
+      updateable? ? setters : settable? ? { atomic_path => as_document } : {}
+    end
+
+    # Get all the attributes that need to be unset.
+    #
+    # @example Get the unsets.
+    #   person.atomic_unsets
+    #
+    # @return [ Array<Hash> ] The $unset operations.
+    #
+    # @since 2.2.0
+    def atomic_unsets
+      @atomic_unsets ||= []
+    end
+
+    # Get all the atomic sets that have had their saves delayed.
+    #
+    # @example Get the delayed atomic sets.
+    #   person.delayed_atomic_sets
+    #
+    # @return [ Hash ] The delayed $sets.
+    #
+    # @since 2.3.0
+    def delayed_atomic_sets
+      @delayed_atomic_sets ||= {}
+    end
+
+    # Get a hash of atomic pulls that are pending.
+    #
+    # @example Get the atomic pulls.
+    #   document.delayed_atomic_pulls
+    #
+    # @return [ Hash ] name/document pairs.
+    #
+    # @since 2.3.2
+    def delayed_atomic_pulls
+      @delayed_atomic_pulls ||= {}
+    end
+
+    private
+
+    # Get the atomic paths utility for this document.
+    #
+    # @example Get the atomic paths.
+    #   document.atomic_paths
+    #
+    # @return [ Object ] The associated path.
+    #
+    # @since 2.1.0
+    def atomic_paths
+      @atomic_paths ||= metadata ? metadata.path(self) : Atomic::Paths::Root.new(self)
+    end
+
+    # Generates the atomic updates in the correct order.
+    #
+    # @example Generate the updates.
+    #   model.generate_atomic_updates(mods, doc)
+    #
+    # @param [ Modifiers ] mods The atomic modifications.
+    # @param [ Document ] doc The document to update for.
+    #
+    # @since 2.2.0
+    def generate_atomic_updates(mods, doc)
+      mods.unset(doc.atomic_unsets)
+      mods.pull(doc.atomic_pulls)
+      mods.set(doc.atomic_sets)
+      mods.set(doc.delayed_atomic_sets)
+      mods.push(doc.atomic_pushes)
+    end
+  end
+end

data/lib/mongoid/atomic/modifiers.rb

@@ -0,0 +1,243 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Atomic #:nodoc:
+
+    # This class contains the logic for supporting atomic operations against the
+    # database.
+    class Modifiers < Hash
+
+      # Adds pull modifiers to the modifiers hash.
+      #
+      # @example Add pull operations.
+      #   modifiers.pull({ "addresses" => { "street" => "Bond" }})
+      #
+      # @param [ Hash ] modifications The pull modifiers.
+      #
+      # @since 2.2.0
+      def pull(modifications)
+        modifications.each_pair do |field, value|
+          add_operation(pulls, field, value)
+          pull_fields << field.split(".", 2)[0]
+        end
+      end
+
+      # Adds push modifiers to the modifiers hash.
+      #
+      # @example Add push operations.
+      #   modifiers.push({ "addresses" => { "street" => "Bond" }})
+      #
+      # @param [ Hash ] modifications The push modifiers.
+      #
+      # @since 2.1.0
+      def push(modifications)
+        modifications.each_pair do |field, value|
+          mods = push_conflict?(field) ? conflicting_pushes : pushes
+          add_operation(mods, field, Array.wrap(value))
+        end
+      end
+
+      # Adds set operations to the modifiers hash.
+      #
+      # @example Add set operations.
+      #   modifiers.set({ "title" => "sir" })
+      #
+      # @param [ Hash ] modifications The set modifiers.
+      #
+      # @since 2.1.0
+      def set(modifications)
+        modifications.each_pair do |field, value|
+          next if field == "_id"
+          mods = set_conflict?(field) ? conflicting_sets : sets
+          add_operation(mods, field, value)
+          set_fields << field.split(".", 2)[0]
+        end
+      end
+
+      # Adds unset operations to the modifiers hash.
+      #
+      # @example Add unset operations.
+      #   modifiers.unset([ "addresses" ])
+      #
+      # @param [ Array<String> ] modifications The unset relation names.
+      #
+      # @since 2.2.0
+      def unset(modifications)
+        modifications.each do |field|
+          unsets.update(field => true)
+        end
+      end
+
+      private
+
+      # Add the operation to the modifications, either appending or creating a
+      # new one.
+      #
+      # @example Add the operation.
+      #   modifications.add_operation(mods, field, value)
+      #
+      # @param [ Hash ] mods The modifications.
+      # @param [ String ] field The field.
+      # @param [ Hash ] value The atomic op.
+      #
+      # @since 2.2.0
+      def add_operation(mods, field, value)
+        if mods.has_key?(field)
+          value.each do |val|
+            mods[field].push(val)
+          end
+        else
+          mods[field] = value
+        end
+      end
+
+      # Is the operation going to be a conflict for a $set?
+      #
+      # @example Is this a conflict for a set?
+      #   modifiers.set_conflict?(field)
+      #
+      # @param [ String ] field The field.
+      #
+      # @return [ true, false ] If this field is a conflict.
+      #
+      # @since 2.2.0
+      def set_conflict?(field)
+        pull_fields.include?(field.split(".", 2)[0])
+      end
+
+      # Is the operation going to be a conflict for a $push?
+      #
+      # @example Is this a conflict for a push?
+      #   modifiers.push_conflict?(field)
+      #
+      # @param [ String ] field The field.
+      #
+      # @return [ true, false ] If this field is a conflict.
+      #
+      # @since 2.2.0
+      def push_conflict?(field)
+        name = field.split(".", 2)[0]
+        set_fields.include?(name) || pull_fields.include?(name)
+      end
+
+      # Get the conflicting pull modifications.
+      #
+      # @example Get the conflicting pulls.
+      #   modifiers.conflicting_pulls
+      #
+      # @return [ Hash ] The conflicting pull operations.
+      #
+      # @since 2.2.0
+      def conflicting_pulls
+        conflicts["$pullAll"] ||= {}
+      end
+
+      # Get the conflicting push modifications.
+      #
+      # @example Get the conflicting pushs.
+      #   modifiers.conflicting_pushs
+      #
+      # @return [ Hash ] The conflicting push operations.
+      #
+      # @since 2.2.0
+      def conflicting_pushes
+        conflicts["$pushAll"] ||= {}
+      end
+
+      # Get the conflicting set modifications.
+      #
+      # @example Get the conflicting sets.
+      #   modifiers.conflicting_sets
+      #
+      # @return [ Hash ] The conflicting set operations.
+      #
+      # @since 2.2.0
+      def conflicting_sets
+        conflicts["$set"] ||= {}
+      end
+
+      # Get the push operations that would have conflicted with the sets.
+      #
+      # @example Get the conflicts.
+      #   modifiers.conflicts
+      #
+      # @return [ Hash ] The conflicting modifications.
+      #
+      # @since 2.1.0
+      def conflicts
+        self[:conflicts] ||= {}
+      end
+
+      # Get the names of the fields that need to be pulled.
+      #
+      # @example Get the pull fields.
+      #   modifiers.pull_fields
+      #
+      # @return [ Array<String> ] The pull fields.
+      #
+      # @since 2.2.0
+      def pull_fields
+        @pull_fields ||= []
+      end
+
+      # Get the names of the fields that need to be set.
+      #
+      # @example Get the set fields.
+      #   modifiers.set_fields
+      #
+      # @return [ Array<String> ] The set fields.
+      #
+      # @since 2.2.0
+      def set_fields
+        @set_fields ||= []
+      end
+
+      # Get the $pullAll operations or intialize a new one.
+      #
+      # @example Get the $pullAll operations.
+      #   modifiers.pulles
+      #
+      # @return [ Hash ] The $pullAll operations.
+      #
+      # @since 2.1.0
+      def pulls
+        self["$pullAll"] ||= {}
+      end
+
+      # Get the $pushAll operations or intialize a new one.
+      #
+      # @example Get the $pushAll operations.
+      #   modifiers.pushes
+      #
+      # @return [ Hash ] The $pushAll operations.
+      #
+      # @since 2.1.0
+      def pushes
+        self["$pushAll"] ||= {}
+      end
+
+      # Get the $set operations or intialize a new one.
+      #
+      # @example Get the $set operations.
+      #   modifiers.sets
+      #
+      # @return [ Hash ] The $set operations.
+      #
+      # @since 2.1.0
+      def sets
+        self["$set"] ||= {}
+      end
+
+      # Get the $unset operations or initialize a new one.
+      #
+      # @example Get the $unset operations.
+      #   modifiers.unsets
+      #
+      # @return [ Hash ] The $unset operations.
+      #
+      # @since 2.2.0
+      def unsets
+        self["$unset"] ||= {}
+      end
+    end
+  end
+end