mongoid-multi-db 3.0.0

data/lib/mongoid/callbacks.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains all the callback hooks for Mongoid.
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation,
+      :after_initialize,
+      :before_create, :around_create, :after_create,
+      :before_destroy, :around_destroy, :after_destroy,
+      :before_save, :around_save, :after_save,
+      :before_update, :around_update, :after_update,
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :only => :after
+      define_model_callbacks :create, :destroy, :save, :update
+    end
+
+    # Run the callbacks for the document. This overrides active support's
+    # functionality to cascade callbacks to embedded documents that have been
+    # flagged as such.
+    #
+    # @example Run the callbacks.
+    #   run_callbacks :save do
+    #     save!
+    #   end
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array ] *args Any options.
+    #
+    # @return [ Document ] The document
+    #
+    # @since 2.3.0
+    def run_callbacks(kind, *args, &block)
+      run_cascading_callbacks(cascadable_children(kind), kind, *args) do
+        super(kind, *args, &block)
+      end
+    end
+
+    private
+
+    # Execute the callbacks, including all children that have cascade callbacks
+    # set to true.
+    #
+    # @example Run the cascading callbacks.
+    #   document.run_cascading_callbacks([], :update)
+    #
+    # @param [ Array<Document> ] children The cascading children.
+    # @param [ Symbol ] kind The callback type.
+    # @param [ Array ] args The options.
+    #
+    # @since 2.3.0
+    def run_cascading_callbacks(children, kind, *args, &block)
+      if child = children.pop
+        run_cascading_callbacks(children, kind, *args) do
+          child.run_callbacks(child_callback_type(kind, child), *args) do
+            block.call
+          end
+        end
+      else
+        block.call
+      end
+    end
+
+    # Get all the child embedded documents that are flagged as cascadable.
+    #
+    # @example Get all the cascading children.
+    #   document.cascadable_children(:update)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 2.3.0
+    def cascadable_children(kind)
+      [].tap do |children|
+        relations.each_pair do |name, metadata|
+          next unless metadata.cascading_callbacks?
+          delayed_pulls = delayed_atomic_pulls[name]
+          children.concat(delayed_pulls) if delayed_pulls
+          child = send(name)
+          Array.wrap(child).each do |doc|
+            children.push(doc) if cascadable_child?(kind, doc)
+            children.concat(doc.send(:cascadable_children, kind))
+          end
+        end
+      end
+    end
+
+    # Determine if the child should fire the callback.
+    #
+    # @example Should the child fire the callback?
+    #   document.cascadable_child?(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document.
+    #
+    # @return [ true, false ] If the child should fire the callback.
+    #
+    # @since 2.3.0
+    def cascadable_child?(kind, child)
+      [ :create, :destroy ].include?(kind) || child.changed? || child.new_record?
+    end
+
+    # Get the name of the callback that the child should fire. This changes
+    # depending on whether or not the child is new. A persisted parent with a
+    # new child would fire :update from the parent, but needs to fire :create
+    # on the child.
+    #
+    # @example Get the callback type.
+    #   document.child_callback_type(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document
+    #
+    # @return [ Symbol ] The name of the callback.
+    #
+    # @since 2.3.0
+    def child_callback_type(kind, child)
+      if kind == :update
+        return :create if child.new_record?
+        return :destroy if child.flagged_for_destroy?
+        kind
+      else
+        kind
+      end
+    end
+  end
+end

data/lib/mongoid/collection.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+require "mongoid/collections/retry"
+require "mongoid/collections/operations"
+require "mongoid/collections/master"
+
+module Mongoid #:nodoc
+
+  # This class is the Mongoid wrapper to the Mongo Ruby driver's collection
+  # object.
+  class Collection
+    attr_reader :counter, :klass, :name
+
+    # All write operations should delegate to the master connection. These
+    # operations mimic the methods on a Mongo:Collection.
+    #
+    # @example Delegate the operation.
+    #   collection.save({ :name => "Al" })
+    delegate *(Collections::Operations::PROXIED.dup << {:to => :master})
+
+    # Get the unwrapped driver collection for this mongoid collection.
+    #
+    # @example Get the driver collection.
+    #   collection.driver
+    #
+    # @return [ Mongo::Collection ] The driver collection.
+    #
+    # @since 2.2.0
+    def driver
+      master.collection
+    end
+
+    # Find documents from the database given a selector and options.
+    #
+    # @example Find documents in the collection.
+    #   collection.find({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def find(selector = {}, options = {})
+      cursor = Mongoid::Cursor.new(klass, self, master(options).find(selector, options))
+      if block_given?
+        yield cursor; cursor.close
+      else
+        cursor
+      end
+    end
+
+    # Find the first document from the database given a selector and options.
+    #
+    # @example Find one document.
+    #   collection.find_one({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Document, nil ] A matching document or nil if none found.
+    def find_one(selector = {}, options = {})
+      master(options).find_one(selector, options)
+    end
+
+    # Initialize a new Mongoid::Collection, setting up the master, slave, and
+    # name attributes. Masters will be used for writes, slaves for reads.
+    #
+    # @example Create the new collection.
+    #   Collection.new(masters, slaves, "test")
+    #
+    # @param [ Class ] klass The class the collection is for.
+    # @param [ String ] name The name of the collection.
+    # @param [ Hash ] options The collection options.
+    #
+    # @option options [ true, false ] :capped If the collection is capped.
+    # @option options [ Integer ] :size The capped collection size.
+    # @option options [ Integer ] :max The maximum number of docs in the
+    #   capped collection.
+    def initialize(klass, name, options = {})
+      @klass, @name, @options = klass, name, options || {}
+    end
+
+    # Inserts one or more documents in the collection.
+    #
+    # @example Insert documents.
+    #   collection.insert(
+    #     { "field" => "value" },
+    #     :safe => true
+    #   )
+    #
+    # @param [ Hash, Array<Hash> ] documents A single document or multiples.
+    # @param [ Hash ] options The options.
+    #
+    # @since 2.0.2, batch-relational-insert
+    def insert(documents, options = {})
+      consumer = Threaded.insert
+      if consumer
+        consumer.consume(documents, options)
+      else
+        master(options).insert(documents, options)
+      end
+    end
+
+    # Perform a map/reduce on the documents.
+    #
+    # @example Perform the map/reduce.
+    #   collection.map_reduce(map, reduce)
+    #
+    # @param [ String ] map The map javascript function.
+    # @param [ String ] reduce The reduce javascript function.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def map_reduce(map, reduce, options = {})
+      master(options).map_reduce(map, reduce, options)
+    end
+    alias :mapreduce :map_reduce
+
+    # Return the object responsible for writes to the database. This will
+    # always return a collection associated with the Master DB.
+    #
+    # @example Get the master connection.
+    #   collection.master
+    #
+    # @return [ Master ] The master connection.
+    def master(options = {})
+      options.delete(:cache)
+      db = Mongoid.databases[klass.database] || Mongoid.master
+      @master ||= Collections::Master.new(db, @name, @options)
+    end
+
+    # Updates one or more documents in the collection.
+    #
+    # @example Update documents.
+    #   collection.update(
+    #     { "_id" => BSON::OjectId.new },
+    #     { "$push" => { "addresses" => { "_id" => "street" } } },
+    #     :safe => true
+    #   )
+    #
+    # @param [ Hash ] selector The document selector.
+    # @param [ Hash ] document The modifier.
+    # @param [ Hash ] options The options.
+    #
+    # @since 2.0.0
+    def update(selector, document, options = {})
+      updater = Threaded.update_consumer(klass)
+      if updater
+        updater.consume(selector, document, options)
+      else
+        master(options).update(selector, document, options)
+      end
+    end
+  end
+end

data/lib/mongoid/collection_proxy.rb

@@ -0,0 +1,59 @@
+require 'thread'
+
+#
+# Proxy that enables runtime swapping of a MongoDB collection, as it
+# appears to be cached at several points within Mongoid.
+#
+# This proxy is generated by the DatabaseProxy when asked for a
+# specific collection.
+#
+class CollectionProxy
+    #
+    # Class-level instance variables.
+    #
+    @mutex = Mutex.new
+    @pool = Hash.new
+
+    #
+    # Accessor for class-level instance variable that holds all the
+    # db-collection pairs that we know about, so that we can switch all
+    # of them globally.
+    #
+    def CollectionProxy.pool
+        @pool
+    end
+
+    #
+    # Collection-global mutex... for great thread safety!
+    #
+    def CollectionProxy.mutex
+        @mutex
+    end
+
+    #
+    # Set our default connection and name.
+    #
+    def initialize(db, name, opts)
+        @db, @name, @opts = db, name, opts
+    end
+
+    #
+    # Convenience method for synchronizing threads.
+    #
+    def synchronize(&block)
+        CollectionProxy.mutex.synchronize(&block)
+    end
+
+    #
+    # Proxy methods to the correct collection. We do this by trying to
+    # find a matching collection in our pool, and if not, we create one
+    # using the _name_ and _opts_ initially passed to initialize.
+    #
+    def method_missing(*args, &block)
+        collection = synchronize do
+            pool = (CollectionProxy.pool[@db.target] ||= {})
+            pool[@name] ||= @db.target.create_collection(@name, @opts)
+        end
+        collection.send(*args, &block)
+    end
+end

data/lib/mongoid/collections.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # The collections module is used for providing functionality around setting
+  # up and updating collections.
+  module Collections
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :_collection, :collection_name
+      self.collection_name = self.name.collectionize
+    end
+
+    # Get the collection for the class.
+    #
+    # @note Defining methods instead of delegate to avoid calls to
+    #   Kernel.caller for class load performance reasons.
+    #
+    # @example Get the collection.
+    #   person.collection
+    #
+    # @return [ Collection ] The class collection.
+    #
+    # @since 1.0.0
+    def collection
+      self.class.collection
+    end
+
+    # Get the database for the class.
+    #
+    # @note Defining methods instead of delegate to avoid calls to
+    #   Kernel.caller for class load performance reasons.
+    #
+    # @example Get the database.
+    #   person.db
+    #
+    # @return [ DB ] The class db.
+    #
+    # @since 1.0.0
+    def db
+      self.class.db
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Returns the collection associated with this +Document+. If the
+      # document is embedded, there will be no collection associated
+      # with it unless it's in a cyclic relation.
+      #
+      # @example Get the collection.
+      #   Model.collection
+      #
+      # @return [ Collection ] The Mongoid collection wrapper.
+      def collection
+        raise Errors::InvalidCollection.new(self) if embedded? && !cyclic
+        self._collection || set_collection
+        add_indexes; self._collection
+      end
+
+      # Return the database associated with this collection.
+      #
+      # @example Get the database object.
+      #   Model.db
+      #
+      # @return [ Mongo::DB ] The Mongo daatabase object.
+      def db
+        collection.db
+      end
+
+      # Convenience method for getting index information from the collection.
+      #
+      # @example Get the index information from the collection.
+      #   Model.index_information
+      #
+      # @return [ Array ] The collection index information.
+      def index_information
+        collection.index_information
+      end
+
+      # Macro for setting the collection name to store in.
+      #
+      # @example Store in a separate collection than the default.
+      #   Model.store_in :population
+      #
+      # @example Store in a capped collection.
+      #   Model.store_in :population, :capped => true, :max => 10000
+      #
+      # @param [ Symbol ] name The name of the collection.
+      # @param [ Hash ] options The collection options.
+      #
+      # @option options [ true, false ] :capped If the collection is capped.
+      # @option options [ Integer ] :size The capped collection size.
+      # @option options [ Integer ] :max The maximum number of docs in the
+      #   capped collection.
+      def store_in(name, options = {})
+        self.collection_name = name.to_s
+        set_collection(options)
+      end
+
+      protected
+
+      # Set the collection on the class.
+      #
+      # @example Set the collection.
+      #   Model.set_collection
+      #
+      # @param [ Hash ] options The collection options.
+      #
+      # @option options [ true, false ] :capped If the collection is capped.
+      # @option options [ Integer ] :size The capped collection size.
+      # @option options [ Integer ] :max The maximum number of docs in the
+      #   capped collection.
+
+      # @return [ Collection ] The Mongoid collection wrapper.
+      def set_collection(options = {})
+        self._collection = Collection.new(self, self.collection_name, options)
+      end
+    end
+  end
+end