mongoid-multi-db 3.0.0

data/lib/mongoid/relations/conversions.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+
+    # Contains utility methods for object id conversion.
+    module Conversions
+      extend self
+
+      # Mark the provided object as unconvertable to bson or not, and always
+      # return the provided object.
+      #
+      # @example Flag the object.
+      #   Conversions.flag(metadata, 15)
+      #
+      # @param [ Object ] object The object to flag.
+      # @param [ Metadata ] The relation metadata.
+      #
+      # @return [ Object ] The provided object.
+      #
+      # @since 2.3.0
+      def flag(object, metadata)
+        inverse = metadata.inverse_klass
+        if inverse.using_object_ids? || object.is_a?(BSON::ObjectId)
+          object
+        else
+          object.tap do |obj|
+            if obj.is_a?(String)
+              obj.unconvertable_to_bson = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/cyclic.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module provides convenience macros for using cyclic embedded
+    # relations.
+    module Cyclic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cyclic
+      end
+
+      module ClassMethods #:nodoc:
+
+        # Create a cyclic embedded relation that creates a tree hierarchy for
+        # the document and many embedded child documents.
+        #
+        # @example Set up a recursive embeds many.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_many
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_many :child_roles, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_many
+          self.cyclic = true
+          embeds_many cyclic_child_name, :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+        end
+
+        # Create a cyclic embedded relation that creates a single self
+        # referencing relationship for a parent and a single child.
+        #
+        # @example Set up a recursive embeds one.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     recursively_embeds_one
+        #   end
+        #
+        # @example The previous example is a shorcut for this.
+        #
+        #   class Role
+        #     include Mongoid::Document
+        #     embeds_one :child_role, :class_name => "Role", :cyclic => true
+        #     embedded_in :parent_role, :class_name => "Role", :cyclic => true
+        #   end
+        #
+        # This provides the default nomenclature for accessing a parent document
+        # or its children.
+        #
+        # @since 2.0.0.rc.1
+        def recursively_embeds_one
+          self.cyclic = true
+          embeds_one cyclic_child_name(false), :class_name => self.name, :cyclic => true
+          embedded_in cyclic_parent_name, :class_name => self.name, :cyclic => true
+        end
+
+        private
+
+        # Determines the parent name given the class.
+        #
+        # @example Determine the parent name.
+        #   Role.cyclic_parent_name
+        #
+        # @return [ String ] "parent_" plus the class name underscored.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_parent_name
+          ("parent_" << self.name.demodulize.underscore.singularize).to_sym
+        end
+
+        # Determines the child name given the class.
+        #
+        # @example Determine the child name.
+        #   Role.cyclic_child_name
+        #
+        # @param [ true, false ] many Is the a many relation?
+        #
+        # @return [ String ] "child_" plus the class name underscored in
+        #   singular or plural form.
+        #
+        # @since 2.0.0.rc.1
+        def cyclic_child_name(many = true)
+          ("child_" << self.name.demodulize.underscore.send(many ? :pluralize : :singularize)).to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# 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
+        #
+        # @todo Durran: Move executions to thread local stack.
+        #
+        # @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 = Threaded.update_consumer(root_class) ||
+            Threaded.set_update_consumer(root_class, MODIFIERS[modifier].new)
+          count_executions do
+            block.call if block
+          end.tap do
+            if @executions.zero?
+              Threaded.set_update_consumer(root_class, 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

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Pull < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The pull operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$pull" =>
+              { path =>
+                { "_id" =>
+                  { "$in" => documents.map { |doc| doc["_id"] } }
+                }
+              }
+            }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "$pull" => { "addresses" => { "_id" => "street" } } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pull" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$pull"
+              documents.push(operations[path])
+            when "$pullAll"
+              documents.concat(operations[path])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class PushAll < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The set operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$pushAll" => { path => documents } }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "$push" => { "addresses" => { "_id" => "street" } } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pushAll" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$push"
+              documents.push(operations[path])
+            when "$pushAll"
+              documents.concat(operations[path])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Embedded #:nodoc:
+      module Atomic #:nodoc:
+
+        class Set < Operation
+
+          # Get the merged operations for the single atomic set.
+          #
+          # @example Get the operations
+          #   set.operations
+          #
+          # @return [ Hash ] The set operations.
+          #
+          # @since 2.0.0
+          def operations
+            { "$set" => { path => documents } }
+          end
+
+          private
+
+          # Parses the incoming operations to get the documents to set.
+          #
+          # @example Parse the operations.
+          #   set.parse(
+          #     { "addresses" => { "$pushAll" => [{ "_id" => "street" }] } }
+          #   )
+          #
+          # @param [ Hash ] operations The ops to parse.
+          #
+          # @since 2.0.0
+          def parse(operations)
+            modifier = operations.keys.first
+            extract(modifier, operations[modifier])
+          end
+
+          # Extract a document from the operation.
+          #
+          # @example Extract the document.
+          #   set.extract({ "$pushAll" => [{ "_id" => "street" }] })
+          #
+          # @param [ Hash ] operation The op to extract from.
+          #
+          # @since 2.0.0
+          def extract(modifier, operations)
+            @path = operations.keys.first
+            case modifier
+            when "$push"
+              documents.push(operations[path])
+            when "$pushAll"
+              documents.push(operations[path].first)
+            when "$set"
+              @documents = operations[path]
+            end
+          end
+        end
+      end
+    end
+  end
+end