stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/collections/cyclic_iterator.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class CyclicIterator
+
+      attr_reader :counter
+
+      # Performs iteration over an array, if the array gets to the end then loop
+      # back to the first.
+      #
+      # Example:
+      #
+      # <tt>CyclicIterator.new([ first, second ])</tt>
+      def initialize(array)
+        @array, @counter = array, -1
+      end
+
+      # Get the next element in the array. If the element is the last in the
+      # array then return the first.
+      #
+      # Example:
+      #
+      # <tt>iterator.next</tt>
+      #
+      # Returns:
+      #
+      # The next element in the array.
+      def next
+        (@counter == @array.size - 1) ? @counter = 0 : @counter = @counter + 1
+        @array[@counter]
+      end
+    end
+  end
+end

data/lib/mongoid/collections/master.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Master
+
+      attr_reader :collection
+
+      # All read and write operations should delegate to the master connection.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      Operations::ALL.each do |name|
+        define_method(name) { |*args| collection.send(name, *args) }
+      end
+
+      # Create the new database writer. Will create a collection from the
+      # master database.
+      #
+      # Example:
+      #
+      # <tt>Master.new(master, "mongoid_people")</tt>
+      def initialize(master, name)
+        @collection = master.collection(name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/operations.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Operations #:nodoc:
+      # Constant definining all the read operations available for a
+      # Mongo:Collection. This is used in delegation.
+      READ = [
+        :[],
+        :db,
+        :count,
+        :distinct,
+        :find,
+        :find_one,
+        :group,
+        :index_information,
+        :map_reduce,
+        :mapreduce,
+        :stats,
+        :options
+      ]
+
+      # Constant definining all the write operations available for a
+      # Mongo:Collection. This is used in delegation.
+      WRITE = [
+        :<<,
+        :create_index,
+        :drop,
+        :drop_index,
+        :drop_indexes,
+        :insert,
+        :remove,
+        :rename,
+        :save,
+        :update
+      ]
+
+      # Convenience constant for getting back all collection operations.
+      ALL = (READ + WRITE)
+      PROXIED = ALL - [ :find, :find_one, :map_reduce, :mapreduce ]
+    end
+  end
+end

data/lib/mongoid/collections/slaves.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Slaves
+
+      attr_reader :iterator
+
+      # All read operations should delegate to the slave connections.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      Operations::READ.each do |name|
+        define_method(name) { |*args| collection.send(name, *args) }
+      end
+
+      # Is the collection of slaves empty or not?
+      #
+      # Return:
+      #
+      # True is the iterator is not set, false if not.
+      def empty?
+        @iterator.nil?
+      end
+
+      # Create the new database reader. Will create a collection from the
+      # slave databases and cycle through them on each read.
+      #
+      # Example:
+      #
+      # <tt>Reader.new(slaves, "mongoid_people")</tt>
+      def initialize(slaves, name)
+        unless slaves.blank?
+          @iterator = CyclicIterator.new(slaves.collect { |db| db.collection(name) })
+        end
+      end
+
+      protected
+      def collection
+        @iterator.next
+      end
+    end
+  end
+end

data/lib/mongoid/collections.rb

@@ -0,0 +1,70 @@
+# 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
+
+      delegate :collection, :db, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc:
+      # Returns the collection associated with this +Document+. If the
+      # document is embedded, there will be no collection associated
+      # with it.
+      #
+      # Returns: <tt>Mongo::Collection</tt>
+      def collection
+        self._collection || set_collection
+        add_indexes; self._collection
+      end
+
+      # Return the database associated with this collection.
+      #
+      # Example:
+      #
+      # <tt>Person.db</tt>
+      def db
+        collection.db
+      end
+
+      # Convenience method for getting index information from the collection.
+      #
+      # Example:
+      #
+      # <tt>Person.index_information</tt>
+      def index_information
+        collection.index_information
+      end
+
+      # The MongoDB logger is not exposed through the driver to be changed
+      # after initialization of the connection, this is a hacky way around that
+      # if logging needs to be changed at runtime.
+      #
+      # Example:
+      #
+      # <tt>Person.logger = Logger.new($stdout)</tt>
+      def logger=(logger)
+        db.connection.instance_variable_set(:@logger, logger)
+      end
+
+      # Macro for setting the collection name to store in.
+      #
+      # Example:
+      #
+      # <tt>Person.store_in :population</tt>
+      def store_in(name)
+        self.collection_name = name.to_s
+        set_collection
+      end
+
+      protected
+      def set_collection
+        self._collection = Mongoid::Collection.new(self, self.collection_name)
+      end
+    end
+  end
+end

data/lib/mongoid/components.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Components #:nodoc
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend ActiveModel::Translation
+      extend Mongoid::DefaultScope
+      extend Mongoid::Finders
+      extend Mongoid::NamedScope
+    end
+
+    include ActiveModel::Conversion
+    include ActiveModel::Naming
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Mongoid::Atomicity
+    include Mongoid::Attributes
+    include Mongoid::Collections
+    include Mongoid::Copyable
+    include Mongoid::Dirty
+    include Mongoid::Extras
+    include Mongoid::Fields
+    include Mongoid::Hierarchy
+    include Mongoid::Indexes
+    include Mongoid::Inspection
+    include Mongoid::JSON
+    include Mongoid::Keys
+    include Mongoid::Matchers
+    include Mongoid::MultiParameterAttributes
+    include Mongoid::Modifiers
+    include Mongoid::NestedAttributes
+    include Mongoid::Paths
+    include Mongoid::Persistence
+    include Mongoid::Relations
+    include Mongoid::Safety
+    include Mongoid::Serialization
+    include Mongoid::State
+    include Mongoid::Validations
+    include Mongoid::Callbacks
+  end
+end

data/lib/mongoid/config/database.rb

@@ -0,0 +1,167 @@
+# 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
+
+      # 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
+        Mongo::Connection.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|
+          Mongo::Connection.from_uri(uri(options), optional(true)).tap do |conn|
+            conn.apply_saved_authentication
+          end
+        end
+      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 => Mongoid::Logger.new,
+          :slave_ok => slave
+        }
+      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,48 @@
+# 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({}) { |memo, (k, v)| memo[k.to_sym] = v; memo}
+        connection = Mongo::ReplSetConnection.new(*(self['hosts'] << options))
+        [ connection.db(self['database']), nil ]
+      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