mongoid_rails4 4.0.0

data/lib/mongoid/config/validators.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require "mongoid/config/validators/option"
+require "mongoid/config/validators/session"

data/lib/mongoid/config/validators/option.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+    module Validators
+
+      # Validator for configuration options.
+      module Option
+        extend self
+
+        # Validate a configuration option.
+        #
+        # @example Validate a configuraiton option.
+        #
+        # @param [ String ] option The name of the option.
+        #
+        # @since 3.0.0
+        def validate(option)
+          unless Config.settings.keys.include?(option.to_sym)
+            raise Errors::InvalidConfigOption.new(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/validators/session.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+    module Validators
+
+      # Validator for session specific configuration.
+      module Session
+        extend self
+
+        STANDARD = [ :database, :hosts, :username, :password ]
+
+        # Validate the session configuration.
+        #
+        # @example Validate the session config.
+        #   Session.validate({ default: { hosts: [ "localhost:27017" ] }})
+        #
+        # @param [ Hash ] sessions The sessions config.
+        #
+        # @since 3.0.0
+        def validate(sessions)
+          unless sessions.has_key?(:default)
+            raise Errors::NoDefaultSession.new(sessions.keys)
+          end
+          sessions.each_pair do |name, config|
+            validate_session_database(name, config)
+            validate_session_hosts(name, config)
+            validate_session_uri(name, config)
+          end
+        end
+
+        private
+
+        # Validate that the session config has database.
+        #
+        # @api private
+        #
+        # @example Validate the session has database.
+        #   validator.validate_session_database(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_database(name, config)
+          if no_database_or_uri?(config)
+            raise Errors::NoSessionDatabase.new(name, config)
+          end
+        end
+
+        # Validate that the session config has hosts.
+        #
+        # @api private
+        #
+        # @example Validate the session has hosts.
+        #   validator.validate_session_hosts(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_hosts(name, config)
+          if no_hosts_or_uri?(config)
+            raise Errors::NoSessionHosts.new(name, config)
+          end
+        end
+
+        # Validate that not both a uri and standard options are provided for a
+        # single session.
+        #
+        # @api private
+        #
+        # @example Validate the uri and options.
+        #   validator.validate_session_uri(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_uri(name, config)
+          if both_uri_and_standard?(config)
+            raise Errors::MixedSessionConfiguration.new(name, config)
+          end
+        end
+
+        # Return true if the configuration has no database or uri option
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_database_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If no database or uri is defined.
+        #
+        # @since 3.0.0
+        def no_database_or_uri?(config)
+          !config.has_key?(:database) && !config.has_key?(:uri)
+        end
+
+        # Return true if the configuration has no hosts or uri option
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_hosts_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If no hosts or uri is defined.
+        #
+        # @since 3.0.0
+        def no_hosts_or_uri?(config)
+          !config.has_key?(:hosts) && !config.has_key?(:uri)
+        end
+
+        # Return true if the configuration has both standard options and a uri
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_database_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If both standard and uri are defined.
+        #
+        # @since 3.0.0
+        def both_uri_and_standard?(config)
+          config.has_key?(:uri) && config.keys.any? do |key|
+            STANDARD.include?(key.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contextual.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require "mongoid/contextual/queryable"
+require "mongoid/contextual/mongo"
+require "mongoid/contextual/memory"
+
+module Mongoid
+  module Contextual
+
+    # The aggregate operations provided in the aggregate module get delegated
+    # through to the context from the criteria.
+    delegate(*Aggregable::Mongo.public_instance_methods(false), to: :context)
+
+    # The atomic operations provided in the atomic context get delegated
+    # through to the context from the criteria.
+    delegate(*Atomic.public_instance_methods(false), to: :context)
+
+    # The methods in the contexts themselves should all get delegated to,
+    # including destructive, modification, and optional methods.
+    delegate(*(Mongo.public_instance_methods(false) - [ :skip, :limit ]), to: :context)
+
+    # This gets blank and empty included.
+    delegate(*Queryable.public_instance_methods(false), to: :context)
+
+    # Get the context in which criteria queries should execute. This is either
+    # in memory (for embedded documents) or mongo (for root level documents.)
+    #
+    # @example Get the context.
+    #   criteria.context
+    #
+    # @return [ Memory, Mongo ] The context.
+    #
+    # @since 3.0.0
+    def context
+      @context ||= create_context
+    end
+
+    private
+
+    # Create the context for the queries to execute. Will be memory for
+    # embedded documents and mongo for root documents.
+    #
+    # @api private
+    #
+    # @example Create the context.
+    #   contextual.create_context
+    #
+    # @return [ Mongo, Memory ] The context.
+    #
+    # @since 3.0.0
+    def create_context
+      embedded ? Memory.new(self) : Mongo.new(self)
+    end
+  end
+end

data/lib/mongoid/contextual/aggregable/memory.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    module Aggregable
+      # Contains behaviour for aggregating values in memory.
+      module Memory
+
+        # Get the average value of the provided field.
+        #
+        # @example Get the average of a single field.
+        #   aggregable.avg(:likes)
+        #
+        # @param [ Symbol ] field The field to average.
+        #
+        # @return [ Float ] The average.
+        #
+        # @since 3.0.0
+        def avg(field)
+          count > 0 ? sum(field).to_f / count.to_f : nil
+        end
+
+        # Get the max value of the provided field. If provided a block, will
+        # return the Document with the greatest value for the field, in
+        # accordance with Ruby's enumerable API.
+        #
+        # @example Get the max of a single field.
+        #   aggregable.max(:likes)
+        #
+        # @example Get the document with the max value.
+        #   aggregable.max do |a, b|
+        #     a.likes <=> b.likes
+        #   end
+        #
+        # @param [ Symbol ] field The field to max.
+        #
+        # @return [ Float, Document ] The max value or document with the max
+        #   value.
+        #
+        # @since 3.0.0
+        def max(field = nil)
+          block_given? ? super() : aggregate_by(field, :max_by)
+        end
+
+        # Get the min value of the provided field. If provided a block, will
+        # return the Document with the smallest value for the field, in
+        # accordance with Ruby's enumerable API.
+        #
+        # @example Get the min of a single field.
+        #   aggregable.min(:likes)
+        #
+        # @example Get the document with the min value.
+        #   aggregable.min do |a, b|
+        #     a.likes <=> b.likes
+        #   end
+        #
+        # @param [ Symbol ] field The field to min.
+        #
+        # @return [ Float, Document ] The min value or document with the min
+        #   value.
+        #
+        # @since 3.0.0
+        def min(field = nil)
+          block_given? ? super() : aggregate_by(field, :min_by)
+        end
+
+        # Get the sum value of the provided field. If provided a block, will
+        # return the sum in accordance with Ruby's enumerable API.
+        #
+        # @example Get the sum of a single field.
+        #   aggregable.sum(:likes)
+        #
+        # @example Get the sum for the provided block.
+        #   aggregable.sum(&:likes)
+        #
+        # @param [ Symbol ] field The field to sum.
+        #
+        # @return [ Float ] The sum value.
+        #
+        # @since 3.0.0
+        def sum(field = nil)
+          if block_given?
+            super()
+          else
+            count > 0 ? super(0) { |doc| doc.send(field) } : 0
+          end
+        end
+
+        private
+
+        # Aggregate by the provided field and method.
+        #
+        # @api private
+        #
+        # @example Aggregate by the field and method.
+        #   aggregable.aggregate_by(:name, :min_by)
+        #
+        # @param [ Symbol ] field The field to aggregate on.
+        # @param [ Symbol ] method The method (min_by or max_by).
+        #
+        # @return [ Integer ] The aggregate.
+        #
+        # @since 3.0.0
+        def aggregate_by(field, method)
+          count > 0 ? send(method) { |doc| doc.send(field) }.send(field) : nil
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    module Aggregable
+      # Contains behaviour for aggregating values in Mongo.
+      module Mongo
+
+        # Get all the aggregate values for the provided field.
+        #
+        # @example Get all the aggregate values.
+        #   aggregable.aggregates(:likes)
+        #
+        # @param [ String, Symbol ] field The field name.
+        #
+        # @return [ Hash ] The aggregate values in the form:
+        #   {
+        #     "count" => 2.0,
+        #     "max" => 1000.0,
+        #     "min" => 500.0,
+        #     "sum" => 1500.0,
+        #     "avg" => 750.0
+        #   }
+        #
+        # @since 3.0.0
+        def aggregates(field)
+          if query.count > 0
+            result = collection.aggregate(pipeline(field)).to_a
+            if result.empty?
+              { "count" => query.count, "avg" => 0, "sum" => 0 }
+            else
+              result.first
+            end
+          else
+            { "count" => 0 }
+          end
+        end
+
+        # Get the average value of the provided field.
+        #
+        # @example Get the average of a single field.
+        #   aggregable.avg(:likes)
+        #
+        # @param [ Symbol ] field The field to average.
+        #
+        # @return [ Float ] The average.
+        #
+        # @since 3.0.0
+        def avg(field)
+          aggregates(field)["avg"]
+        end
+
+        # Get the max value of the provided field. If provided a block, will
+        # return the Document with the greatest value for the field, in
+        # accordance with Ruby's enumerable API.
+        #
+        # @example Get the max of a single field.
+        #   aggregable.max(:likes)
+        #
+        # @example Get the document with the max value.
+        #   aggregable.max do |a, b|
+        #     a.likes <=> b.likes
+        #   end
+        #
+        # @param [ Symbol ] field The field to max.
+        #
+        # @return [ Float, Document ] The max value or document with the max
+        #   value.
+        #
+        # @since 3.0.0
+        def max(field = nil)
+          block_given? ? super() : aggregates(field)["max"]
+        end
+
+        # Get the min value of the provided field. If provided a block, will
+        # return the Document with the smallest value for the field, in
+        # accordance with Ruby's enumerable API.
+        #
+        # @example Get the min of a single field.
+        #   aggregable.min(:likes)
+        #
+        # @example Get the document with the min value.
+        #   aggregable.min do |a, b|
+        #     a.likes <=> b.likes
+        #   end
+        #
+        # @param [ Symbol ] field The field to min.
+        #
+        # @return [ Float, Document ] The min value or document with the min
+        #   value.
+        #
+        # @since 3.0.0
+        def min(field = nil)
+          block_given? ? super() : aggregates(field)["min"]
+        end
+
+        # Get the sum value of the provided field. If provided a block, will
+        # return the sum in accordance with Ruby's enumerable API.
+        #
+        # @example Get the sum of a single field.
+        #   aggregable.sum(:likes)
+        #
+        # @example Get the sum for the provided block.
+        #   aggregable.sum(&:likes)
+        #
+        # @param [ Symbol ] field The field to sum.
+        #
+        # @return [ Float ] The sum value.
+        #
+        # @since 3.0.0
+        def sum(field = nil)
+          block_given? ? super() : aggregates(field)["sum"] || 0
+        end
+
+        private
+
+        # Get the aggregation pipeline for provided field.
+        #
+        # @api private
+        #
+        # @example Get the pipeline.
+        #   aggregable.pipeline(:likes)
+        #
+        # @param [ String, Symbol ] field The name of the field.
+        #
+        # @return [ Array ] The array of pipeline operators.
+        #
+        # @since 3.1.0
+        def pipeline(field)
+          db_field = "$#{database_field_name(field)}"
+          pipeline = []
+          pipeline << { "$match" => criteria.nin(field => nil).selector }
+          pipeline << { "$limit" => criteria.options[:limit] } if criteria.options[:limit]
+          pipeline << {
+            "$group"  => {
+              "_id"   => field.to_s,
+              "count" => { "$sum" => 1 },
+              "max"   => { "$max" => db_field },
+              "min"   => { "$min" => db_field },
+              "sum"   => { "$sum" => db_field },
+              "avg"   => { "$avg" => db_field }
+            }
+          }
+        end
+      end
+    end
+  end
+end