mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/callbacks.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Callbacks
+    extend ActiveSupport::Concern
+    included do
+      extend ActiveModel::Callbacks
+
+      # Define all the callbacks that are accepted by the document.
+      define_model_callbacks \
+        :create,
+        :destroy,
+        :save,
+        :update,
+        :validation
+    end
+
+    def valid?(*) #nodoc
+      _run_validation_callbacks { super }
+    end
+  end
+end

data/lib/mongoid/collection.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require "mongoid/collections/operations"
+require "mongoid/collections/cyclic_iterator"
+require "mongoid/collections/master"
+require "mongoid/collections/slaves"
+
+module Mongoid #:nodoc
+  # The Mongoid wrapper to the Mongo Ruby driver's collection object.
+  class Collection
+    attr_reader :counter, :name
+
+    # All write operations should delegate to the master connection. These
+    # operations mimic the methods on a Mongo:Collection.
+    #
+    # Example:
+    #
+    # <tt>collection.save({ :name => "Al" })</tt>
+    Collections::Operations::PROXIED.each do |name|
+      define_method(name) { |*args| master.send(name, *args) }
+    end
+
+    # Determines where to send the next read query. If the slaves are not
+    # defined then send to master. If the read counter is under the configured
+    # maximum then return the master. In any other case return the slaves.
+    #
+    # Example:
+    #
+    # <tt>collection.directed</tt>
+    #
+    # Return:
+    #
+    # Either a +Master+ or +Slaves+ collection.
+    def directed(options = {})
+      options.delete(:cache)
+      enslave = options.delete(:enslave) || @klass.enslaved?
+      enslave ? master_or_slaves : master
+    end
+
+    # Find documents from the database given a selector and options.
+    #
+    # Options:
+    #
+    # selector: A +Hash+ selector that is the query.
+    # options: The options to pass to the db.
+    #
+    # Example:
+    #
+    # <tt>collection.find({ :test => "value" })</tt>
+    def find(selector = {}, options = {})
+      cursor = Mongoid::Cursor.new(@klass, self, directed(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.
+    #
+    # Options:
+    #
+    # selector: A +Hash+ selector that is the query.
+    # options: The options to pass to the db.
+    #
+    # Example:
+    #
+    # <tt>collection.find_one({ :test => "value" })</tt>
+    def find_one(selector = {}, options = {})
+      directed(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:
+    #
+    # <tt>Mongoid::Collection.new(masters, slaves, "test")</tt>
+    def initialize(klass, name)
+      @klass, @name = klass, name
+    end
+
+    # Perform a map/reduce on the documents.
+    #
+    # Options:
+    #
+    # map: The map javascript funcdtion.
+    # reduce: The reduce javascript function.
+    def map_reduce(map, reduce, options = {})
+      directed(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:
+    #
+    # <tt>collection.writer</tt>
+    def master
+      @master ||= Collections::Master.new(Mongoid.master, @name)
+    end
+
+    # Return the object responsible for reading documents from the database.
+    # This is usually the slave databases, but in their absence the master will
+    # handle the task.
+    #
+    # Example:
+    #
+    # <tt>collection.reader</tt>
+    def slaves
+      @slaves ||= Collections::Slaves.new(Mongoid.slaves, @name)
+    end
+
+    protected
+    def master_or_slaves
+      slaves.empty? ? master : slaves
+    end
+  end
+end

data/lib/mongoid/collections.rb

@@ -0,0 +1,71 @@
+# 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
+        raise Errors::InvalidCollection.new(self) if embedded?
+        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 :populdation</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/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,41 @@
+# 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,
+        :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/components.rb

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

data/lib/mongoid/config.rb

@@ -0,0 +1,263 @@
+# encoding: utf-8
+require "uri"
+
+module Mongoid #:nodoc
+  class Config #:nodoc
+    include Singleton
+
+    attr_accessor \
+      :allow_dynamic_fields,
+      :reconnect_time,
+      :parameterize_keys,
+      :persist_in_safe_mode,
+      :raise_not_found_error,
+      :use_object_ids,
+      :skip_version_check
+
+    # Initializes the configuration with default settings.
+    def initialize
+      reset
+    end
+
+    # Sets whether the times returned from the database are in UTC or local time.
+    # If you omit this setting, then times will be returned in
+    # the local time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_utc = true</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    def use_utc=(value)
+      @use_utc = value || false
+    end
+
+    # Returns whether times are return from the database in UTC. If
+    # this setting is false, then times will be returned in the local time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_utc</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    attr_reader :use_utc
+    alias_method :use_utc?, :use_utc
+
+    # Sets the Mongo::DB master database to be used. If the object trying to be
+    # set is not a valid +Mongo::DB+, then an error will be raised.
+    #
+    # Example:
+    #
+    # <tt>Config.master = Mongo::Connection.db("test")</tt>
+    #
+    # Returns:
+    #
+    # The master +Mongo::DB+ instance.
+    def master=(db)
+      check_database!(db)
+      @master = db
+    end
+
+    # Returns the master database, or if none has been set it will raise an
+    # error.
+    #
+    # Example:
+    #
+    # <tt>Config.master</tt>
+    #
+    # Returns:
+    #
+    # The master +Mongo::DB+
+    def master
+      @master || (raise Errors::InvalidDatabase.new(nil))
+    end
+
+    alias :database :master
+    alias :database= :master=
+
+    # Sets the Mongo::DB slave databases to be used. If the objects provided
+    # are not valid +Mongo::DBs+ an error will be raised.
+    #
+    # Example:
+    #
+    # <tt>Config.slaves = [ Mongo::Connection.db("test") ]</tt>
+    #
+    # Returns:
+    #
+    # The slave DB instances.
+    def slaves=(dbs)
+      return unless dbs
+      dbs.each do |db|
+        check_database!(db)
+      end
+      @slaves = dbs
+    end
+
+    # Returns the slave databases or nil if none have been set.
+    #
+    # Example:
+    #
+    # <tt>Config.slaves</tt>
+    #
+    # Returns:
+    #
+    # The slave +Mongo::DBs+
+    def slaves
+      @slaves
+    end
+
+    # Returns the logger, or defaults to Rails logger or stdout logger.
+    #
+    # Example:
+    #
+    # <tt>Config.logger</tt>
+    def logger
+      return @logger if defined?(@logger)
+
+      @logger = defined?(Rails) ? Rails.logger : ::Logger.new($stdout)
+    end
+
+    # Sets the logger for Mongoid to use.
+    #
+    # Example:
+    #
+    # <tt>Config.logger = Logger.new($stdout, :warn)</tt>
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # Return field names that could cause destructive things to happen if
+    # defined in a Mongoid::Document
+    #
+    # Example:
+    #
+    # <tt>Config.destructive_fields</tt>
+    #
+    # Returns:
+    #
+    # An array of bad field names.
+    def destructive_fields
+      @destructive_fields ||= lambda {
+        klass = Class.new do
+          include Mongoid::Document
+        end
+        klass.instance_methods(true).collect { |method| method.to_s }
+      }.call
+    end
+
+    # Configure mongoid from a hash. This is usually called after parsing a
+    # yaml config file such as mongoid.yml.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Config.instance.from_hash({})</tt>
+    def from_hash(settings)
+      _master(settings)
+      _slaves(settings)
+      settings.except("database").each_pair do |name, value|
+        send("#{name}=", value) if respond_to?(name)
+      end
+    end
+
+    # Convenience method for connecting to the master database after forking a
+    # new process.
+    #
+    # Example:
+    #
+    # <tt>Mongoid.reconnect!</tt>
+    def reconnect!
+      master.connection.connect_to_master
+    end
+
+    # Reset the configuration options to the defaults.
+    #
+    # Example:
+    #
+    # <tt>config.reset</tt>
+    def reset
+      @allow_dynamic_fields = true
+      @parameterize_keys = true
+      @persist_in_safe_mode = true
+      @raise_not_found_error = true
+      @reconnect_time = 3
+      @use_object_ids = false
+      @skip_version_check = false
+      @time_zone = nil
+    end
+
+    protected
+
+    # Check if the database is valid and the correct version.
+    #
+    # Example:
+    #
+    # <tt>config.check_database!</tt>
+    def check_database!(database)
+      raise Errors::InvalidDatabase.new(database) unless database.kind_of?(Mongo::DB)
+      unless Mongoid.skip_version_check
+        version = database.connection.server_version
+        raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
+      end
+    end
+
+    # Get a master database from settings.
+    #
+    # TODO: Durran: This code's a bit hairy, refactor.
+    #
+    # Example:
+    #
+    # <tt>config._master({}, "test")</tt>
+    def _master(settings)
+      mongo_uri = settings["uri"].present? ? URI.parse(settings["uri"]) : OpenStruct.new
+
+      name = settings["database"] || mongo_uri.path.to_s.sub("/", "")
+      host = settings["host"] || mongo_uri.host || "localhost"
+      port = settings["port"] || mongo_uri.port || 27017
+      pool_size = settings["pool_size"] || 1 
+      username = settings["username"] || mongo_uri.user
+      password = settings["password"] || mongo_uri.password
+
+      connection = Mongo::Connection.new(host, port, :logger => Mongoid::Logger.new, :pool_size => pool_size)
+      if username || password
+        connection.add_auth(name, username, password)
+        connection.apply_saved_authentication
+      end
+      self.master = connection.db(name)
+    end
+
+    # Get a bunch-o-slaves from settings and names.
+    #
+    # TODO: Durran: This code's a bit hairy, refactor.
+    #
+    # Example:
+    #
+    # <tt>config._slaves({}, "test")</tt>
+    def _slaves(settings)
+      mongo_uri = settings["uri"].present? ? URI.parse(settings["uri"]) : OpenStruct.new
+      name = settings["database"] || mongo_uri.path.to_s.sub("/", "")
+      self.slaves = []
+      slaves = settings["slaves"]
+      slaves.to_a.each do |slave|
+        slave_uri = slave["uri"].present? ? URI.parse(slave["uri"]) : OpenStruct.new
+        slave_username = slave["username"] || slave_uri.user
+        slave_password = slave["password"] || slave_uri.password
+
+        slave_connection = Mongo::Connection.new(
+          slave["host"] || slave_uri.host || "localhost",
+          slave["port"] || slave_uri.port,
+          :slave_ok => true
+        )
+
+        if slave_username || slave_password
+          slave_connection.add_auth(name, slave_username, slave_password)
+          slave_connection.apply_saved_authentication
+        end
+        self.slaves << slave_connection.db(name)
+      end
+    end
+  end
+end