mongoid-with-auth 1.9.4

data/lib/mongoid/callbacks.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Callbacks
+    def self.included(base)
+      base.class_eval do
+        include ActiveSupport::Callbacks
+
+        # Define all the callbacks that are accepted by the document.
+        define_callbacks \
+          :before_create,
+          :after_create,
+          :before_destroy,
+          :after_destroy,
+          :before_save,
+          :after_save,
+          :before_update,
+          :after_update,
+          :before_validation,
+          :after_validation
+      end
+    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,41 @@
+# 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, :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
+
+      # 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,27 @@
+# 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 Mongoid::Associations
+      include Mongoid::Attributes
+      include Mongoid::Callbacks
+      include Mongoid::Collections
+      include Mongoid::Dirty
+      include Mongoid::Extras
+      include Mongoid::Fields
+      include Mongoid::Indexes
+      include Mongoid::Matchers
+      include Mongoid::Memoization
+      include Mongoid::Observable
+      include Mongoid::Paths
+      include Mongoid::Persistence
+      include Mongoid::State
+      include Validatable
+      extend Mongoid::Finders
+      extend Mongoid::NamedScope
+    end
+  end
+end

data/lib/mongoid/concern.rb

@@ -0,0 +1,31 @@
+unless defined?(ActiveSupport::Concern)
+  module ActiveSupport
+    module Concern
+      def self.extended(base)
+        base.instance_variable_set("@_dependencies", [])
+      end
+
+      def append_features(base)
+        if base.instance_variable_defined?("@_dependencies")
+          base.instance_variable_get("@_dependencies") << self
+          return false
+        else
+          return false if base < self
+          @_dependencies.each { |dep| base.send(:include, dep) }
+          super
+          base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+          base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
+          base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+        end
+      end
+
+      def included(base = nil, &block)
+        if base.nil?
+          @_included_block = block
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config.rb

@@ -0,0 +1,205 @@
+# 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
+
+    # Defaults the configuration options to true.
+    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 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 if none has been set nil
+    #
+    # Example:
+    #
+    # <tt>Config.slaves</tt>
+    #
+    # Returns:
+    #
+    # The slave +Mongo::DBs+
+    def slaves
+      @slaves
+    end
+
+    # Confiure mongoid from a hash that was usually parsed out of 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
+
+    # 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
+      @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)
+      version = database.connection.server_version
+      raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
+    end
+
+    # Get a Rails logger or stdout logger.
+    #
+    # Example:
+    #
+    # <tt>config.logger</tt>
+    def logger
+      defined?(Rails) ? Rails.logger : Logger.new($stdout)
+    end
+
+    # Get a master database from settings.
+    #
+    # Example:
+    #
+    # <tt>config._master({}, "test")</tt>
+    def _master(settings)
+      self.master = database_from_hash(settings)
+    end
+
+    # Get a bunch-o-slaves from settings and names.
+    #
+    # Example:
+    #
+    # <tt>config._slaves({}, "test")</tt>
+    def _slaves(settings)
+      self.slaves = settings["slaves"].to_a.map do |slave|
+        database_from_hash({"database" => master.name}.merge(slave), :slave_ok => true)
+      end
+    end
+
+    def database_from_hash(settings, connection_options={})
+      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
+
+      local_options = {
+        :logger => logger,
+        :pool_size => pool_size
+      }.merge(connection_options)
+
+      Mongo::Connection.new(host, port, local_options).tap do |connection|
+        if username || password
+          connection.add_auth(name, username, password)
+          connection.apply_saved_authentication
+        end
+      end.db(name)
+    end
+  end
+end