mongoid-multi-db 3.0.0

data/lib/mongoid/config/database.rb

@@ -0,0 +1,186 @@
+require 'mongoid/connection_proxy'
+
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Config #:nodoc:
+
+    # This class handles the configuration and initialization of a mongodb
+    # database from options.
+    class Database < Hash
+
+      # keys to remove from self to not pass through to Mongo::Connection
+      PRIVATE_OPTIONS = %w(uri database username password logger)
+
+      # Configure the database connections. This will return an array
+      # containing the master and an array of slaves.
+      #
+      # @example Configure the connection.
+      #   db.configure
+      #
+      # @return [ Array<Mongo::DB, Array<Mongo:DB>> ] The Mongo databases.
+      #
+      # @since 2.0.0.rc.1
+      def configure
+        [ master.db(name), slaves.map { |slave| slave.db(name) } ]
+      end
+
+      # Create the new db configuration class.
+      #
+      # @example Initialize the class.
+      #   Config::Database.new(
+      #     false, "uri" => { "mongodb://durran:password@localhost:27017/mongoid" }
+      #   )
+      #
+      # @param [ Hash ] options The configuration options.
+      #
+      # @option options [ String ] :database The database name.
+      # @option options [ String ] :host The database host.
+      # @option options [ String ] :password The password for authentication.
+      # @option options [ Integer ] :port The port for the database.
+      # @option options [ String ] :uri The uri for the database.
+      # @option options [ String ] :username The user for authentication.
+      #
+      # @since 2.0.0.rc.1
+      def initialize(options = {})
+        merge!(options)
+      end
+
+      private
+
+      # Do we need to authenticate against the database?
+      #
+      # @example Are we authenticating?
+      #   db.authenticating?
+      #
+      # @return [ true, false ] True if auth is needed, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def authenticating?
+        username || password
+      end
+
+      # Takes the supplied options in the hash and created a URI from them to
+      # pass to the Mongo connection object.
+      #
+      # @example Build the URI.
+      #   db.build_uri
+      #
+      # @param [ Hash ] options The options to build with.
+      #
+      # @return [ String ] A mongo compliant URI string.
+      #
+      # @since 2.0.0.rc.1
+      def build_uri(options = {})
+        "mongodb://".tap do |base|
+          base << "#{username}:#{password}@" if authenticating?
+          base << "#{options["host"] || "localhost"}:#{options["port"] || 27017}"
+          base << "/#{self["database"]}" if authenticating?
+        end
+      end
+
+      # Create the mongo master connection from either the supplied URI
+      # or a generated one, while setting pool size and logging.
+      #
+      # @example Create the connection.
+      #   db.connection
+      #
+      # @return [ Mongo::Connection ] The mongo connection.
+      #
+      # @since 2.0.0.rc.1
+      def master
+        ConnectionProxy.from_uri(uri(self), optional).tap do |conn|
+          conn.apply_saved_authentication
+        end
+      end
+
+      # Create the mongo slave connections from either the supplied URI
+      # or a generated one, while setting pool size and logging.
+      #
+      # @example Create the connection.
+      #   db.connection
+      #
+      # @return [ Array<Mongo::Connection> ] The mongo slave connections.
+      #
+      # @since 2.0.0.rc.1
+      def slaves
+        (self["slaves"] || []).map do |options|
+          ConnectionProxy.from_uri(uri(options), optional(true)).tap do |conn|
+            conn.apply_saved_authentication
+          end
+        end
+      end
+
+      # Should we use a logger?
+      #
+      # @example Should we use a logger?
+      #   database.logger?
+      #
+      # @return [ true, false ] Defaults to true, false if specifically
+      #   defined.
+      #
+      # @since 2.2.0
+      def logger?
+        self[:logger].nil? || self[:logger] ? true : false
+      end
+
+      # Convenience for accessing the hash via dot notation.
+      #
+      # @example Access a value in alternate syntax.
+      #   db.host
+      #
+      # @return [ Object ] The value in the hash.
+      #
+      # @since 2.0.0.rc.1
+      def method_missing(name, *args, &block)
+        self[name.to_s]
+      end
+
+      # Get the name of the database, from either the URI supplied or the
+      # database value in the options.
+      #
+      # @example Get the database name.
+      #   db.name
+      #
+      # @return [ String ] The database name.
+      #
+      # @since 2.0.0.rc.1
+      def name
+        db_name = URI.parse(uri(self)).path.to_s.sub("/", "")
+        db_name.blank? ? database : db_name
+      end
+
+      # Get the options used in creating the database connection.
+      #
+      # @example Get the options.
+      #   db.options
+      #
+      # @param [ true, false ] slave Are the options for a slave db?
+      #
+      # @return [ Hash ] The hash of configuration options.
+      #
+      # @since 2.0.0.rc.1
+      def optional(slave = false)
+        ({
+          :pool_size => pool_size,
+          :logger => logger? ? Mongoid::Logger.new : nil,
+          :slave_ok => slave
+        }).merge(self).reject { |k,v| PRIVATE_OPTIONS.include? k }.
+          inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo} # mongo likes symbols
+      end
+
+      # Get a Mongo compliant URI for the database connection.
+      #
+      # @example Get the URI.
+      #   db.uri
+      #
+      # @param [ Hash ] options The options hash.
+      #
+      # @return [ String ] The URI for the connection.
+      #
+      # @since 2.0.0.rc.1
+      def uri(options = {})
+        options["uri"] || build_uri(options)
+      end
+    end
+  end
+end

data/lib/mongoid/config/replset_database.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Config #:nodoc:
+    class ReplsetDatabase < Hash
+
+      # Configure the database connections. This will return an array
+      # containing one Mongo::DB and nil (to keep compatibility with Mongoid::Config::Database)
+      # If you want the reads to go to a secondary node use the :read_secondary(true): option
+      #
+      # @example Configure the connection.
+      #   db.configure
+      #
+      # @return [ Array<Mongo::DB, nil ] The Mongo databases.
+      #
+      # @since 2.0.0.rc.5
+      def configure
+        # yes, construction is weird but the driver wants
+        # "A list of host-port pairs ending with a hash containing any options"
+        # mongo likes symbols
+        options = self.inject({ :logger => Mongoid::Logger.new }) do |memo, (k, v)|
+          memo[k.to_sym] = v
+          memo
+        end
+        connection = Mongo::ReplSetConnection.new(*(hosts.clone << options))
+
+        if authenticating?
+          connection.add_auth(database, username, password)
+          connection.apply_saved_authentication
+        end
+
+        [ DatabaseProxy.new(connection, database), nil ]
+      end
+
+      # Do we need to authenticate against the database?
+      #
+      # @example Are we authenticating?
+      #   db.authenticating?
+      #
+      # @return [ true, false ] True if auth is needed, false if not.
+      #
+      # @since 2.0.2
+      def authenticating?
+        username || password
+      end
+
+      # Convenience for accessing the hash via dot notation.
+      #
+      # @example Access a value in alternate syntax.
+      #   db.host
+      #
+      # @return [ Object ] The value in the hash.
+      #
+      # @since 2.0.2
+      def method_missing(name, *args, &block)
+        self[name.to_s]
+      end
+
+      # Create the new db configuration class.
+      #
+      # @example Initialize the class.
+      #   Config::ReplsetDatabase.new(
+      #     "hosts" => [[host1,port1],[host2,port2]]
+      #   )
+      #
+      # replSet does not supports auth
+      #
+      # @param [ Hash ] options The configuration options.
+      #
+      # @option options [ Array ] :hosts The database host.
+      # @option options [ String ] :database The database name.
+      # @option options [ Boolean ] :read_secondary Tells the driver to read from secondaries.
+      # ...
+      #
+      # @see Mongo::ReplSetConnection for all options
+      #
+      # @since 2.0.0.rc.5
+      def initialize(options = {})
+        merge!(options)
+      end
+    end
+  end
+end

data/lib/mongoid/connection_proxy.rb

@@ -0,0 +1,30 @@
+require 'mongoid/database_proxy'
+
+#
+# Proxy that enables runtime swapping of the MongoDB connection. This is
+# not an ideal-solution, performance-wise, as a quick check shows that
+# method invocation via method_missing is about three times as slow as
+# direct invocation on the object.
+#
+# What this does allow us to do, however, is very transparently swap out
+# Mongo::Connection instances underneath Mongoid, without having to
+# rewrite large portions of the codebase. In theory, this should result
+# in a relatively painless connection-swapping system.
+#
+class ConnectionProxy
+    def ConnectionProxy.from_uri(*args)
+        new(*args)
+    end
+
+    def initialize(*args)
+        @connection = Mongo::Connection.from_uri(*args)
+    end
+
+    def db(name)
+        @database ||= DatabaseProxy.new(@connection, name)
+    end
+
+    def method_missing(*args, &block)
+        @connection.send(*args, &block)
+    end
+end

data/lib/mongoid/contexts.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "mongoid/contexts/enumerable"
+require "mongoid/contexts/mongo"
+
+module Mongoid
+  module Contexts
+    extend self
+
+    # Determines the context to be used for this criteria. If the class is an
+    # embedded document, then the context will be the array in the has_many
+    # association it is in. If the class is a root, then the database itself
+    # will be the context.
+    #
+    # @example Get the context for the criteria.
+    #   Contexts.context_for(criteria)
+    #
+    # @param [ Criteria ] criteria The criteria to use.
+    # @param [ true, false ] embedded Whether this is on embedded documents.
+    #
+    # @return [ Enumerable, Mongo ] The appropriate context.
+    def context_for(criteria, embedded = false)
+      embedded ? Enumerable.new(criteria) : Mongo.new(criteria)
+    end
+  end
+end

data/lib/mongoid/contexts/enumerable.rb

@@ -0,0 +1,288 @@
+# encoding: utf-8
+require 'mongoid/contexts/enumerable/sort'
+
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Enumerable
+      include Relations::Embedded::Atomic
+
+      attr_accessor :collection, :criteria
+
+      delegate :blank?, :empty?, :first, :last, :to => :execute
+      delegate :klass, :documents, :options, :field_list, :selector, :to => :criteria
+
+      # Return aggregation counts of the grouped documents. This will count by
+      # the first field provided in the fields array.
+      #
+      # @example Aggregate on a field.
+      #   person.addresses.only(:street).aggregate
+      #
+      # @return [ Hash ] Field values as keys, count as values
+      def aggregate
+        {}.tap do |counts|
+          group.each_pair { |key, value| counts[key] = value.size }
+        end
+      end
+
+      # Get the average value for the supplied field.
+      #
+      # @example Get the average.
+      #   context.avg(:age)
+      #
+      # @return [ Numeric ] A numeric value that is the average.
+      def avg(field)
+        total = sum(field)
+        total ? (total.to_f / count) : nil
+      end
+
+      # Gets the number of documents in the array. Delegates to size.
+      #
+      # @example Get the count.
+      #   context.count
+      #
+      # @return [ Integer ] The count of documents.
+      def count
+        @count ||= execute.size
+      end
+      alias :length :count
+      alias :size :count
+
+      # Delete all the documents in the database matching the selector.
+      #
+      # @example Delete the documents.
+      #   context.delete_all
+      #
+      # @return [ Integer ] The number of documents deleted.
+      #
+      # @since 2.0.0.rc.1
+      def delete_all
+        atomically(:$pull) do
+          set_collection
+          count.tap do
+            filter.each { |doc| doc.delete }
+          end
+        end
+      end
+      alias :delete :delete_all
+
+      # Destroy all the documents in the database matching the selector.
+      #
+      # @example Destroy the documents.
+      #   context.destroy_all
+      #
+      # @return [ Integer ] The number of documents destroyed.
+      #
+      # @since 2.0.0.rc.1
+      def destroy_all
+        atomically(:$pull) do
+          set_collection
+          count.tap do
+            filter.each { |doc| doc.destroy }
+          end
+        end
+      end
+      alias :destroy :destroy_all
+
+      # Gets an array of distinct values for the supplied field across the
+      # entire array or the susbset given the criteria.
+      #
+      # @example Get the list of distinct values.
+      #   context.distinct(:title)
+      #
+      # @return [ Array<String> ] The distinct values.
+      def distinct(field)
+        execute.collect { |doc| doc.send(field) }.uniq
+      end
+
+      # Enumerable implementation of execute. Returns matching documents for
+      # the selector, and adds options if supplied.
+      #
+      # @example Execute the context.
+      #   context.execute
+      #
+      # @return [ Array<Document> ] Documents that matched the selector.
+      def execute
+        limit(sort(filter)) || []
+      end
+
+      # Groups the documents by the first field supplied in the field options.
+      #
+      # @example Group the context.
+      #   context.group
+      #
+      # @return [ Hash ] Field values as keys, arrays of documents as values.
+      def group
+        field = field_list.first
+        execute.group_by { |doc| doc.send(field) }
+      end
+
+      # Create the new enumerable context. This will need the selector and
+      # options from a +Criteria+ and a documents array that is the underlying
+      # array of embedded documents from a has many association.
+      #
+      # @example Create a new context.
+      #   Mongoid::Contexts::Enumerable.new(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria for the context.
+      def initialize(criteria)
+        @criteria = criteria
+      end
+
+      # Iterate over each +Document+ in the results. This can take an optional
+      # block to pass to each argument in the results.
+      #
+      # @example Iterate over the documents.
+      #   context.iterate { |doc| p doc }
+      def iterate(&block)
+        execute.each(&block)
+      end
+
+      # Get the largest value for the field in all the documents.
+      #
+      # @example Get the max value.
+      #   context.max(:age)
+      #
+      # @return [ Numeric ] The numerical largest value.
+      def max(field)
+        determine(field, :>=)
+      end
+
+      # Get the smallest value for the field in all the documents.
+      #
+      # @example Get the minimum value.
+      #   context.min(:age)
+      #
+      # @return [ Numeric ] The numerical smallest value.
+      def min(field)
+        determine(field, :<=)
+      end
+
+      # Get one document.
+      #
+      # @example Get one document.
+      #   context.one
+      #
+      # @return [ Document ] The first document in the array.
+      alias :one :first
+
+      # Get one document and tell the criteria to skip this record on
+      # successive calls.
+      #
+      # @example Shift the documents.
+      #   context.shift
+      #
+      # @return [ Document ] The first document in the array.
+      def shift
+        first.tap do |document|
+          self.criteria = criteria.skip((options[:skip] || 0) + 1)
+        end
+      end
+
+      # Get the sum of the field values for all the documents.
+      #
+      # @example Get the sum of the field.
+      #   context.sum(:cost)
+      #
+      # @return [ Numeric ] The numerical sum of all the document field values.
+      def sum(field)
+        sum = execute.inject(nil) do |memo, doc|
+          value = doc.send(field) || 0
+          memo ? memo += value : value
+        end
+      end
+
+      # Very basic update that will perform a simple atomic $set of the
+      # attributes provided in the hash. Can be expanded to later for more
+      # robust functionality.
+      #
+      # @example Update all matching documents.
+      #   context.update_all(:title => "Sir")
+      #
+      # @param [ Hash ] attributes The sets to perform.
+      #
+      # @since 2.0.0.rc.6
+      def update_all(attributes = nil)
+        iterate do |doc|
+          doc.update_attributes(attributes || {})
+        end
+      end
+      alias :update :update_all
+
+      protected
+
+      # Filters the documents against the criteria's selector
+      #
+      # @example Filter the documents.
+      #   context.filter
+      #
+      # @return [ Array ] The documents filtered.
+      def filter
+        documents.select { |document| document.matches?(selector) }
+      end
+
+      # If the field exists, perform the comparison and set if true.
+      #
+      # @example Compare.
+      #   context.determine
+      #
+      # @return [ Array<Document> ] The matching documents.
+      def determine(field, operator)
+        matching = documents.inject(nil) do |memo, doc|
+          value = doc.send(field) || 0
+          (memo && memo.send(operator, value)) ? memo : value
+        end
+      end
+
+      # Limits the result set if skip and limit options.
+      #
+      # @example Limit the results.
+      #   context.limit(documents)
+      #
+      # @return [ Array<Document> ] The limited documents.
+      def limit(documents)
+        skip, limit = options[:skip], options[:limit]
+        if skip && limit
+          return documents.slice(skip, limit)
+        elsif limit
+          return documents.first(limit)
+        elsif skip
+          return documents.slice(skip..-1)
+        end
+        documents
+      end
+
+      def root
+        @root ||= documents.first.try(:_root)
+      end
+
+      def root_class
+        @root_class ||= root ? root.class : nil
+      end
+
+      # Set the collection to the collection of the root document.
+      #
+      # @example Set the collection.
+      #   context.set_collection
+      #
+      # @return [ Collection ] The root collection.
+      def set_collection
+        @collection = root.collection if root && !root.embedded?
+      end
+
+      # Sorts the result set if sort options have been set.
+      #
+      # @example Sort the documents.
+      #   context.sort(documents)
+      #
+      # @return [ Array<Document> ] The sorted documents.
+      def sort(documents)
+        return documents if options[:sort].blank?
+        documents.sort_by do |document|
+          options[:sort].map do |key, direction|
+            Sort.new(document.read_attribute(key), direction)
+          end
+        end
+      end
+    end
+  end
+end