stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/config.rb

@@ -0,0 +1,343 @@
+# encoding: utf-8
+require "uri"
+require "mongoid/config/database"
+require "mongoid/config/replset_database"
+
+module Mongoid #:nodoc
+
+  # This module defines all the configuration options for Mongoid, including the
+  # database connections.
+  #
+  # @todo Durran: This module needs an overhaul, remove singleton, etc.
+  module Config
+    extend self
+
+    attr_accessor :master, :slaves, :settings
+    @settings = {}
+
+    # Define a configuration option with a default.
+    #
+    # @example Define the option.
+    #   Config.option(:persist_in_safe_mode, :default => false)
+    #
+    # @param [ Symbol ] name The name of the configuration option.
+    # @param [ Hash ] options Extras for the option.
+    #
+    # @option options [ Object ] :default The default value.
+    #
+    # @since 2.0.0.rc.1
+    def option(name, options = {})
+      define_method(name) do
+        settings.has_key?(name) ? settings[name] : options[:default]
+      end
+      define_method("#{name}=") { |value| settings[name] = value }
+      define_method("#{name}?") { send(name) }
+    end
+
+    option :allow_dynamic_fields, :default => true
+    option :include_root_in_json, :default => false
+    option :parameterize_keys, :default => true
+    option :persist_in_safe_mode, :default => false
+    option :raise_not_found_error, :default => true
+    option :reconnect_time, :default => 3
+    option :autocreate_indexes, :default => false
+    option :skip_version_check, :default => false
+    option :time_zone, :default => nil
+    option :binding_defaults, :default => { :binding => false, :continue => true }
+
+    # Adds a new I18n locale file to the load path.
+    #
+    # @example Add a portuguese locale.
+    #   Mongoid::Config.add_language('pt')
+    #
+    # @example Add all available languages.
+    #   Mongoid::Config.add_language('*')
+    #
+    # @param [ String ] language_code The language to add.
+    def add_language(language_code = nil)
+      Dir[
+        File.join(
+          File.dirname(__FILE__), "..", "config", "locales", "#{language_code}.yml"
+      )
+      ].each do |file|
+        I18n.load_path << File.expand_path(file)
+      end
+    end
+
+    # Get any extra databases that have been configured.
+    #
+    # @example Get the extras.
+    #   config.databases
+    #
+    # @return [ Hash ] A hash of secondary databases.
+    def databases
+      configure_extras(@settings["databases"]) unless @databases || !@settings
+      @databases || {}
+    end
+
+    # @todo Durran: There were no tests around the databases setter, not sure
+    # what the exact expectation was. Set with a hash?
+    def databases=(databases)
+    end
+
+    # Return field names that could cause destructive things to happen if
+    # defined in a Mongoid::Document.
+    #
+    # @example Get the destructive fields.
+    #   config.destructive_fields
+    #
+    # @return [ Array<String> ] 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 Configure Mongoid.
+    #   config.from_hash({})
+    #
+    # @param [ Hash ] options The settings to use.
+    def from_hash(options = {})
+      options.except("database", "slaves", "databases").each_pair do |name, value|
+        send("#{name}=", value) if respond_to?("#{name}=")
+      end
+      configure_databases(options)
+      configure_extras(options["databases"])
+    end
+
+    # Returns the logger, or defaults to Rails logger or stdout logger.
+    #
+    # @example Get the logger.
+    #   config.logger
+    #
+    # @return [ Logger ] The desired logger.
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : ::Logger.new($stdout)
+    end
+
+    # Sets the logger for Mongoid to use.
+    #
+    # @example Set the logger.
+    #   config.logger = Logger.new($stdout, :warn)
+    #
+    # @return [ Logger ] The newly set logger.
+    def logger=(logger)
+      @logger = logger
+      @master.connection.instance_variable_set(:@logger, logger)
+    end
+
+    # Sets whether the times returned from the database use the ruby or
+    # the ActiveSupport time zone.
+    # If you omit this setting, then times will use the ruby time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_activesupport_time_zone = true</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    def use_activesupport_time_zone=(value)
+      @use_activesupport_time_zone = value || false
+    end
+
+    # Sets whether the times returned from the database use the ruby or
+    # the ActiveSupport time zone.
+    # If the setting is false, then times will use the ruby time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_activesupport_time_zone</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    attr_reader :use_activesupport_time_zone
+    alias_method :use_activesupport_time_zone?, :use_activesupport_time_zone
+
+    # 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 Set the master database.
+    #   config.master = Mongo::Connection.db("test")
+    #
+    # @param [ Mongo::DB ] db The master database.
+    #
+    # @raise [ Errors::InvalidDatabase ] If the master isnt a valid object.
+    #
+    # @return [ Mongo::DB ] The master instance.
+    def master=(db)
+      check_database!(db)
+      @master = db
+    end
+    alias :database= :master=
+
+    # Returns the master database, or if none has been set it will raise an
+    # error.
+    #
+    # @example Get the master database.
+    #   config.master
+    #
+    # @raise [ Errors::InvalidDatabase ] If the database was not set.
+    #
+    # @return [ Mongo::DB ] The master database.
+    def master
+      unless @master
+        configure_databases(@settings) unless @settings.blank?
+        raise Errors::InvalidDatabase.new(nil) unless @master
+      end
+      if @reconnect
+        @reconnect = false
+        reconnect!
+      end
+      @master
+    end
+    alias :database :master
+
+    # Convenience method for connecting to the master database after forking a
+    # new process.
+    #
+    # @example Reconnect to the master.
+    #   Mongoid.reconnect!
+    #
+    # @param [ true, false ] now Perform the reconnection immediately?
+    def reconnect!(now = true)
+      if now
+        master.connection.connect
+      else
+        # We set a @reconnect flag so that #master knows to reconnect the next
+        # time the connection is accessed.
+        @reconnect = true
+      end
+    end
+
+    # Reset the configuration options to the defaults.
+    #
+    # @example Reset the configuration options.
+    #   config.reset
+    def reset
+      settings.clear
+    end
+
+    # Sets the Mongo::DB slave databases to be used. If the objects provided
+    # are not valid +Mongo::DBs+ an error will be raised.
+    #
+    # @example Set the slaves.
+    #   config.slaves = [ Mongo::Connection.db("test") ]
+    #
+    # @param [ Array<Mongo::DB> ] dbs The slave databases.
+    #
+    # @raise [ Errors::InvalidDatabase ] If the slaves arent valid objects.
+    #
+    # @return [ Array<Mongo::DB> ] 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 Get the slaves.
+    #   config.slaves
+    #
+    # @return [ Array<Mongo::DB>, nil ] The slave databases.
+    def slaves
+      unless @slaves
+        configure_databases(@settings) if @settings && @settings[:database]
+      end
+      @slaves
+    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 Set the use of UTC.
+    #   config.use_utc = true
+    #
+    # @param [ true, false ] value Whether to use UTC or not.
+    #
+    # @return [ true, false ] Are we using UTC?
+    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 Are we using UTC?
+    #   config.use_utc
+    #
+    # @return [ true, false ] True if UTC, false if not.
+    attr_reader :use_utc
+    alias :use_utc? :use_utc
+
+    protected
+
+    # Check if the database is valid and the correct version.
+    #
+    # @example Check if the database is valid.
+    #   config.check_database!
+    #
+    # @param [ Mongo::DB ] database The db to check.
+    #
+    # @raise [ Errors::InvalidDatabase ] If the object is not valid.
+    # @raise [ Errors::UnsupportedVersion ] If the db version is too old.
+    def check_database!(database)
+      raise Errors::InvalidDatabase.new(database) unless database.kind_of?(Mongo::DB)
+      unless skip_version_check
+        version = database.connection.server_version
+        raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
+      end
+    end
+
+    # Get a database from settings.
+    #
+    # @example Configure the master and slave dbs.
+    #   config.configure_databases("database" => "mongoid")
+    #
+    # @param [ Hash ] options The options to use.
+    #
+    # @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 [ Array<Hash> ] :slaves The slave db options.
+    # @option options [ String ] :uri The uri for the database.
+    # @option options [ String ] :username The user for authentication.
+    #
+    # @since 2.0.0.rc.1
+    def configure_databases(options)
+      if options.has_key?('hosts')
+        @master, @slaves = ReplsetDatabase.new(options).configure
+      else
+        @master, @slaves = Database.new(options).configure
+      end
+    end
+
+    # Get the secondary databases from settings.
+    #
+    # @example Configure the master and slave dbs.
+    #   config.configure_extras("databases" => settings)
+    #
+    # @param [ Hash ] options The options to use.
+    #
+    # @since 2.0.0.rc.1
+    def configure_extras(extras)
+      @databases = (extras || []).inject({}) do |dbs, (name, options)|
+        dbs.tap do |extra|
+        dbs[name], dbs["#{name}_slaves"] = Database.new(options).configure
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contexts/enumerable/sort.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Enumerable
+      class Sort
+        attr_reader :value, :direction
+
+        # Create a new sorting object. This requires a value and a sort
+        # direction of +:asc+ or +:desc+.
+        def initialize(value, direction)
+          @value     = value
+          @direction = direction
+        end
+
+        # Return +true+ if the direction is +:asc+, otherwise false.
+        def ascending?
+          direction == :asc
+        end
+
+        # Compare two +Sort+ objects against each other, taking into
+        # consideration the direction of the sorting.
+        def <=>(other)
+          cmp = compare(value, other.value)
+          ascending? ? cmp : cmp * -1
+        end
+
+        private
+
+        # Compare two values allowing for nil values.
+        def compare(a, b)
+          case
+          when a.nil?
+            b.nil? ? 0 : 1
+          when b.nil?
+            -1
+          else
+            a <=> b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contexts/enumerable.rb

@@ -0,0 +1,226 @@
+# encoding: utf-8
+
+require 'mongoid/contexts/enumerable/sort'
+
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Enumerable
+      include Ids, Paging
+      attr_accessor :criteria
+
+      delegate :blank?, :empty?, :first, :last, :to => :execute
+      delegate :klass, :documents, :options, :selector, :to => :criteria
+
+      # Return aggregation counts of the grouped documents. This will count by
+      # the first field provided in the fields array.
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, count as values
+      def aggregate
+        counts = {}
+        group.each_pair { |key, value| counts[key] = value.size }
+        counts
+      end
+
+      # Get the average value for the supplied field.
+      #
+      # Example:
+      #
+      # <tt>context.avg(:age)</tt>
+      #
+      # Returns:
+      #
+      # 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.
+      def count
+        @count ||= filter.size
+      end
+
+      # 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
+        count.tap { filter.each(&:delete) }
+      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
+        count.tap { filter.each(&:destroy) }
+      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:
+      #
+      # <tt>context.distinct(:title)</tt>
+      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.
+      #
+      # Returns:
+      #
+      # An +Array+ of documents that matched the selector.
+      def execute(paginating = false)
+        limit(sort(filter)) || []
+      end
+
+      # Groups the documents by the first field supplied in the field options.
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, arrays of documents as values.
+      def group
+        field = options[:fields].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:
+      #
+      # <tt>Mongoid::Contexts::Enumerable.new(criteria)</tt>
+      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:
+      #
+      # <tt>context.iterate { |doc| p doc }</tt>
+      def iterate(&block)
+        execute.each(&block)
+      end
+
+      # Get the largest value for the field in all the documents.
+      #
+      # Returns:
+      #
+      # The numerical largest value.
+      def max(field)
+        determine(field, :>=)
+      end
+
+      # Get the smallest value for the field in all the documents.
+      #
+      # Returns:
+      #
+      # The numerical smallest value.
+      def min(field)
+        determine(field, :<=)
+      end
+
+      # Get one document.
+      #
+      # Returns:
+      #
+      # The first document in the +Array+
+      alias :one :first
+
+      # Get one document and tell the criteria to skip this record on
+      # successive calls.
+      #
+      # Returns:
+      #
+      # 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.
+      #
+      # Returns:
+      #
+      # The numerical sum of all the document field values.
+      def sum(field)
+        sum = execute.inject(nil) do |memo, doc|
+          value = doc.send(field)
+          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
+      def filter
+        documents.select { |document| document.matches?(selector) }
+      end
+
+      # If the field exists, perform the comparison and set if true.
+      def determine(field, operator)
+        matching = documents.inject(nil) do |memo, doc|
+          value = doc.send(field)
+          (memo && memo.send(operator, value)) ? memo : value
+        end
+      end
+
+      # Limits the result set if skip and limit options.
+      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
+
+      # Sorts the result set if sort options have been set.
+      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

data/lib/mongoid/contexts/ids.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    module Ids
+      # Return documents based on an id search. Will handle if a single id has
+      # been passed or mulitple ids.
+      #
+      # Example:
+      #
+      #   context.id_criteria([1, 2, 3])
+      #
+      # Returns:
+      #
+      # The single or multiple documents.
+      def id_criteria(params)
+        self.criteria = criteria.id(params)
+        result = params.is_a?(Array) ? criteria.entries : one
+        if Mongoid.raise_not_found_error && !params.blank?
+          raise Errors::DocumentNotFound.new(klass, params) if result.blank?
+        end
+        return result
+      end
+    end
+  end
+end