mongoid 2.4.10 → 3.0.0

data/lib/mongoid/contexts/mongo.rb

@@ -1,487 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Contexts #:nodoc:
-    class Mongo
-      attr_accessor :criteria
-
-      delegate :cached?, :klass, :options, :field_list, :selector, :to => :criteria
-      delegate :collection, :to => :klass
-
-      # Perform an add to set on the matching documents.
-      #
-      # @example Add to set on all matching.
-      #   Person.where(:name => "Alex").add_to_set(:aliases, "value")
-      #
-      # @param [ String ] field The field to add to.
-      # @param [ Object ] value The value to add.
-      #
-      # @return [ Object ] The update value.
-      #
-      # @since 2.1.0
-      def add_to_set(field, value)
-        klass.collection.update(
-          selector,
-          { "$addToSet" => { field => value } },
-          :multi => true
-        )
-      end
-
-      # Aggregate the context. This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with counts.
-      #
-      # @example Aggreate the context.
-      #   context.aggregate
-      #
-      # @return [ Hash ] A +Hash+ with field values as keys, counts as values
-      def aggregate
-        klass.collection.group(
-          :key => field_list,
-          :cond => selector,
-          :initial => { :count => 0 },
-          :reduce => Javascript.aggregate
-        )
-      end
-
-      # Get the average value for the supplied field.
-      #
-      # This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with averages.
-      #
-      # @example Get the average for a field.
-      #   context.avg(:age)
-      #
-      # @param [ Symbol ] field The field to get the average for.
-      #
-      # @return [ Numeric ] A numeric value that is the average.
-      def avg(field)
-        total = sum(field)
-        total ? (total / count) : nil
-      end
-
-      # Determine if the context is empty or blank given the criteria. Will
-      # perform a quick has_one asking only for the id.
-      #
-      # @example Is the context empty?
-      #   context.blank?a
-      #
-      # @return [ true, false ] True if blank.
-      def blank?
-        klass.collection.find_one(selector, { :fields => [ :_id ] }).nil?
-      end
-      alias :empty? :blank?
-
-      # Get the count of matching documents in the database for the context.
-      #
-      # @example Get the count without skip and limit taken into consideration.
-      #   context.count
-      #
-      # @example Get the count with skip and limit applied.
-      #   context.count(true)
-      #
-      # @param [Boolean] extras True to inclued previous skip/limit
-      #   statements in the count; false to ignore them. Defaults to `false`.
-      #
-      # @return [ Integer ] The count of documents.
-      def count(extras = false)
-        if cached?
-          @count ||= collection.find(selector, process_options).count(extras)
-        else
-          collection.find(selector, process_options).count(extras)
-        end
-      end
-      alias :size :count
-      alias :length :count
-
-      # 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
-        klass.delete_all(:conditions => selector)
-      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
-        klass.destroy_all(:conditions => selector)
-      end
-      alias :destroy :destroy_all
-
-      # Gets an array of distinct values for the supplied field across the
-      # entire collection or the susbset given the criteria.
-      #
-      # @example Get the distinct values.
-      #   context.distinct(:title)
-      #
-      # @param [ Symbol ] field The field to get the values for.
-      #
-      # @return [ Array<Object> ] The distinct values for the field.
-      def distinct(field)
-        klass.collection.distinct(field, selector)
-      end
-
-      # Eager load the inclusions for the provided documents.
-      #
-      # @example Eager load the inclusions.
-      #   context.eager_load(docs)
-      #
-      # @param [ Array<Document> ] docs The docs returning from the db.
-      #
-      # @since 2.4.1
-      def eager_load(docs)
-        criteria.inclusions.reject! do |metadata|
-          unless docs.empty?
-            parent_ids = docs.map(&:id)
-            if metadata.macro == :referenced_in
-              child_ids = load_ids(metadata.foreign_key)
-              metadata.eager_load(child_ids)
-            else
-              metadata.eager_load(parent_ids)
-            end
-          end
-        end
-      end
-
-      # Execute the context. This will take the selector and options
-      # and pass them on to the Ruby driver's +find()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned new documents of the type of class provided will be instantiated.
-      #
-      # @example Execute the criteria on the context.
-      #   context.execute
-      #
-      # @return [ Cursor ] An enumerable +Cursor+ of results.
-      def execute
-        collection, options = klass.collection, process_options
-        if criteria.inclusions.any?
-          collection.find(selector, options).entries.tap do |docs|
-            eager_load(docs)
-          end
-        else
-          collection.find(selector, options)
-        end
-      end
-
-      # Loads an array of ids only for the current criteria. Used by eager
-      # loading to determine the documents to load.
-      #
-      # @example Load the related ids.
-      #   criteria.load_ids("person_id")
-      #
-      # @param [ String ] key The id or foriegn key string.
-      #
-      # @return [ Array<String, BSON::ObjectId> ] The ids to load.
-      #
-      # @since 2.2.0
-      def load_ids(key)
-        klass.collection.driver.find(
-          selector,
-          process_options.merge({ :fields => { key => 1 }})
-        ).map { |doc| doc[key] }
-      end
-
-      # Return the first result for the +Context+.
-      #
-      # @example Get the first document.
-      #   context.one
-      #
-      # @return [ Document ] The first document in the collection.
-      def first
-        attributes = klass.collection.find_one(selector, options_with_default_sorting)
-        return nil unless attributes
-        selecting do
-          Mongoid::Factory.from_db(klass, attributes).tap do |doc|
-            eager_load([ doc ]) if criteria.inclusions.any?
-          end
-        end
-      end
-      alias :one :first
-
-      # Groups the context. This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with objects.
-      #
-      # @example Get the criteria as a group.
-      #   context.group
-      #
-      # @return [ Hash ] Hash with field values as keys, arrays of documents as values.
-      def group
-        klass.collection.group(
-          :key => field_list,
-          :cond => selector,
-          :initial => { :group => [] },
-          :reduce => Javascript.group
-        ).collect do |docs|
-          docs["group"] = docs["group"].collect do |attrs|
-            Mongoid::Factory.from_db(klass, attrs)
-          end
-          docs
-        end
-      end
-
-      # Create the new mongo context. This will execute the queries given the
-      # selector and options against the database.
-      #
-      # @example Create a new context.
-      #   Mongoid::Contexts::Mongo.new(criteria)
-      #
-      # @param [ Criteria ] criteria The criteria to create with.
-      def initialize(criteria)
-        @criteria = criteria
-        if klass.hereditary? && !criteria.selector.keys.include?(:_type)
-          @criteria = criteria.in(:_type => criteria.klass._types)
-        end
-        @criteria.cache if klass.cached?
-      end
-
-      # Iterate over each +Document+ in the results. This can take an optional
-      # block to pass to each argument in the results.
-      #
-      # @example Iterate over the results.
-      #   context.iterate { |doc| p doc }
-      def iterate(&block)
-        selecting do
-          return caching(&block) if cached?
-          if block_given?
-            execute.each { |doc| yield doc }
-          end
-        end
-      end
-
-      # Return the last result for the +Context+. Essentially does a find_one on
-      # the collection with the sorting reversed. If no sorting parameters have
-      # been provided it will default to ids.
-      #
-      # @example Get the last document.
-      #   context.last
-      #
-      # @return [ Document ] The last document in the collection.
-      def last
-        opts = options_with_default_sorting
-        opts[:sort] = opts[:sort].map{ |option| [ option[0], option[1].invert ] }.uniq
-        attributes = klass.collection.find_one(selector, opts)
-        return nil unless attributes
-        selecting do
-          Mongoid::Factory.from_db(klass, attributes).tap do |doc|
-            eager_load([ doc ]) if criteria.inclusions.any?
-          end
-        end
-      end
-
-      # Return the max value for a field.
-      #
-      # This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with sums.
-      #
-      # @example Get the max value.
-      #   context.max(:age)
-      #
-      # @param [ Symbol ] field The field to get the max for.
-      #
-      # @return [ Numeric ] A numeric max value.
-      def max(field)
-        grouped(:max, field.to_s, Javascript.max, Javascript.max_finalize)
-      end
-
-      # Return the min value for a field.
-      #
-      # This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with sums.
-      #
-      # @example Get the min value.
-      #   context.min(:age)
-      #
-      # @param [ Symbol ] field The field to get the min for.
-      #
-      # @return [ Numeric ] A numeric minimum value.
-      def min(field)
-        grouped(:min, field.to_s, Javascript.min, Javascript.min_finalize)
-      end
-
-      # Perform a pull on the matching documents.
-      #
-      # @example Pull on all matching.
-      #   Person.where(:name => "Alex").pull(:aliases, "value")
-      #
-      # @param [ String ] field The field to pull from.
-      # @param [ Object ] value The value to pull.
-      #
-      # @return [ Object ] The update value.
-      #
-      # @since 2.1.0
-      def pull(field, value)
-        klass.collection.update(
-          selector,
-          { "$pull" => { field => value } },
-          :multi => true
-        )
-      end
-
-      # Return the first result for the +Context+ and skip it
-      # for successive calls.
-      #
-      # @example Get the first document and shift.
-      #   context.shift
-      #
-      # @return [ Document ] The first document in the collection.
-      def shift
-        first.tap { criteria.skip((options[:skip] || 0) + 1) }
-      end
-
-      # Sum the context.
-      #
-      # This will take the internally built selector and options
-      # and pass them on to the Ruby driver's +group()+ method on the collection. The
-      # collection itself will be retrieved from the class provided, and once the
-      # query has returned it will provided a grouping of keys with sums.
-      #
-      # @example Get the sum for a field.
-      #   context.sum(:age)
-      #
-      # @param [ Symbol ] field The field who's values to sum.
-      #
-      # @return [ Numeric ] A numeric value that is the sum.
-      def sum(field)
-        grouped(:sum, field.to_s, Javascript.sum, Javascript.sum_finalize)
-      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.4
-      def update_all(attributes = {})
-        klass.collection.update(
-          selector,
-          { "$set" => attributes },
-          Safety.merge_safety_options(:multi => true)
-        ).tap do
-          Threaded.clear_options!
-        end
-      end
-      alias :update :update_all
-
-      protected
-
-      # Iterate over each +Document+ in the results and cache the collection.
-      #
-      # @example Execute with caching.
-      #   context.caching
-      def caching(&block)
-        if defined? @collection
-          @collection.each(&block)
-        else
-          @collection = []
-          execute.each do |doc|
-            @collection << doc
-            yield doc if block_given?
-          end
-        end
-      end
-
-      # Common functionality for grouping operations. Currently used by min, max
-      # and sum. Will gsub the field name in the supplied reduce function.
-      #
-      # @example Execute the group function.
-      #   context.group(0, :avg, "")
-      #
-      # @param [ Object ] start The value to start the map/reduce with.
-      # @param [ String ] field The field to aggregate.
-      # @param [ String ] reduce The reduce JS function.
-      #
-      # @return [ Numeric ] A numeric result.
-      def grouped(start, field, reduce, finalize)
-        collection = klass.collection.group(
-          :cond => selector,
-          :initial => { start => "start" },
-          :finalize => finalize,
-          :reduce => reduce.gsub("[field]", field)
-        )
-        collection.empty? ? nil : collection.first[start.to_s]
-      end
-
-      # Get the options hash with the default sorting options provided.
-      #
-      # @example Get the options.
-      #   criteria.options_with_default_sorting
-      #
-      # @return [ Hash ] The options.
-      #
-      # @since 2.3.2
-      def options_with_default_sorting
-        process_options.tap do |opts|
-          if opts[:sort].blank?
-            opts[:sort] = [[ :_id, :asc ]]
-          end
-        end
-      end
-
-      # Filters the field list. If no fields have been supplied, then it will be
-      # empty. If fields have been defined then _type will be included as well.
-      #
-      # @example Process the field list.
-      #   context.process_options
-      #
-      # @return [ Hash ] The options.
-      def process_options
-        fields = options[:fields]
-        if fields && fields.size > 0 && !fields.include?(:_type)
-          if fields.kind_of?(Hash)
-            fields[:_type] = 1 if fields.first.last != 0 # Not excluding
-          else
-            fields << :type
-          end
-          options[:fields] = fields
-        end
-        options.dup
-      end
-
-      # If we are limiting results, we need to set the field limitations on a
-      # thread local to avoid overriding the default values.
-      #
-      # @example Execute with selection.
-      #   context.selecting do
-      #     collection.find
-      #   end
-      #
-      # @return [ Object ] The yielded value.
-      #
-      # @since 2.4.4
-      def selecting
-        begin
-          unless options[:fields].blank?
-            Threaded.selection = options[:fields]
-          end
-          yield
-        ensure
-          Threaded.selection = nil
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/contexts.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-require "mongoid/contexts/enumerable"
-require "mongoid/contexts/mongo"
-
-module Mongoid
-  module Contexts
-    extend self
-
-    # Determines the context to be used for this criteria. If the class is an
-    # embedded document, then the context will be the array in the has_many
-    # association it is in. If the class is a root, then the database itself
-    # will be the context.
-    #
-    # @example Get the context for the criteria.
-    #   Contexts.context_for(criteria)
-    #
-    # @param [ Criteria ] criteria The criteria to use.
-    # @param [ true, false ] embedded Whether this is on embedded documents.
-    #
-    # @return [ Enumerable, Mongo ] The appropriate context.
-    def context_for(criteria, embedded = false)
-      embedded ? Enumerable.new(criteria) : Mongo.new(criteria)
-    end
-  end
-end

data/lib/mongoid/criterion/builder.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Criterion #:nodoc:
-
-    # This module defines criteria behavior for building documents for
-    # specified conditions.
-    module Builder
-
-      # Build a document given the selector and return it.
-      # Complex criteria, such as $in and $or operations will get ignored.
-      #
-      # @example build the document.
-      #   Person.where(:title => "Sir").build
-      #
-      # @example Build with selectors getting ignored.
-      #   Person.where(:age.gt => 5).build
-      #
-      # @return [ Document ] A non-persisted document.
-      #
-      # @since 2.0.0
-      def build(attrs = {})
-        klass.new(
-          selector.inject(attrs) do |hash, (key, value)|
-            hash.tap do |attrs|
-              unless key.to_s =~ /\$/ || value.is_a?(Hash)
-                attrs[key] = value
-              end
-            end
-          end
-        )
-      end
-    end
-  end
-end

data/lib/mongoid/criterion/complex.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Criterion #:nodoc:
-
-    # Complex criterion are used when performing operations on symbols to get
-    # get a shorthand syntax for where clauses.
-    #
-    # @example Conversion of a simple to complex criterion.
-    #   { :field => { "$lt" => "value" } }
-    #   becomes:
-    #   { :field.lt => "value }
-    class Complex
-      attr_accessor :key, :operator
-
-      # Create the new complex criterion.
-      #
-      # @example Instantiate a new complex criterion.
-      #   Complex.new(:key => :field, :operator => "$gt")
-      #
-      # @param [ Hash ] opts The options to convert.
-      def initialize(opts = {})
-        @key, @operator = opts[:key], opts[:operator]
-      end
-
-      # Get the criterion as a hash.
-      #
-      # @example Get the criterion as a hash.
-      #   criterion.hash
-      #
-      # @return [ Hash ] The keys and operators.
-      def hash
-        [@key, @operator].hash
-      end
-
-      # Create a mongo query with given value
-      #
-      # @example Create query
-      #   criterion.to_mongo_hash(value)
-      #
-      # @params [] Whatever is a valid input for given operator
-      # @return [ Hash ] The query
-      def to_mongo_query(v)
-        {"$#{self.operator}" => v}
-      end
-
-      # Is the criterion equal to the other?
-      #
-      # @example Check equality.
-      #   criterion.eql?(other)
-      #
-      # @param [ Complex ] other The other complex criterion.
-      #
-      # @return [ true, false ] If they are equal.
-      def eql?(other)
-        self == (other)
-      end
-
-      # Is the criterion equal to the other?
-      #
-      # @example Check equality.
-      #   criterion == other
-      #
-      # @param [ Complex ] other The other complex criterion.
-      #
-      # @return [ true, false ] If they are equal.
-      def ==(other)
-        return false unless other.is_a?(self.class)
-        self.key == other.key && self.operator == other.operator
-      end
-
-      # Returns the name of the key as a string.
-      #
-      # @example Get the name of the key.
-      #   criterion.to_s
-      #
-      # @return [ String ] The field name.
-      #
-      # @since 2.1.0
-      def to_s
-        key.to_s
-      end
-    end
-  end
-end

data/lib/mongoid/criterion/creational.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Criterion #:nodoc:
-
-    # This module defines criteria behavior for creating documents in the
-    # database for specified conditions.
-    module Creational
-
-      # Create a document in the database given the selector and return it.
-      # Complex criteria, such as $in and $or operations will get ignored.
-      #
-      # @example Create the document.
-      #   Person.where(:title => "Sir").create
-      #
-      # @example Create with selectors getting ignored.
-      #   Person.where(:age.gt => 5).create
-      #
-      # @return [ Document ] A newly created document.
-      #
-      # @since 2.0.0.rc.1
-      def create(attrs = {})
-        klass.create(
-          selector.inject(attrs) do |hash, (key, value)|
-            hash.tap do |attrs|
-              unless key.to_s =~ /\$/ || value.is_a?(Hash)
-                attrs[key] = value
-              end
-            end
-          end
-        )
-      end
-    end
-  end
-end