mongoid 2.4.10 → 3.0.0.rc

data/lib/mongoid/contextual/map_reduce.rb

@@ -0,0 +1,273 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    class MapReduce
+      include Enumerable
+      include Command
+
+      delegate :[], to: :results
+      delegate :==, :empty?, :inspect, to: :entries
+
+      # Get all the counts returned by the map/reduce.
+      #
+      # @example Get the counts.
+      #   map_reduce.counts
+      #
+      # @return [ Hash ] The counts.
+      #
+      # @since 3.0.0
+      def counts
+        results["counts"]
+      end
+
+      # Iterates over each of the documents in the map/reduce, excluding the
+      # extra information that was passed back from the database.
+      #
+      # @example Iterate over the results.
+      #   map_reduce.each do |doc|
+      #     p doc
+      #   end
+      #
+      # @return [ Enumerator ] The enumerator.
+      #
+      # @since 3.0.0
+      def each
+        if block_given?
+          documents.each do |doc|
+            yield doc
+          end
+        else
+          to_enum
+        end
+      end
+
+      # Get the number of documents emitted by the map/reduce.
+      #
+      # @example Get the emitted document count.
+      #   map_reduce.emitted
+      #
+      # @return [ Integer ] The number of emitted documents.
+      #
+      # @since 3.0.0
+      def emitted
+        counts["emit"]
+      end
+
+      # Provide a finalize js function for the map/reduce.
+      #
+      # @example Provide a finalize function.
+      #   map_reduce.finalize(func)
+      #
+      # @param [ String ] function The finalize function.
+      #
+      # @return [ MapReduce ] The map reduce.
+      #
+      # @since 3.0.0
+      def finalize(function)
+        command[:finalize] = function
+        self
+      end
+
+      # Initialize the new map/reduce directive.
+      #
+      # @example Initialize the new map/reduce.
+      #   MapReduce.new(criteria, map, reduce)
+      #
+      # @param [ Criteria ] criteria The Mongoid criteria.
+      # @param [ String ] map The map js function.
+      # @param [ String ] reduce The reduce js function.
+      #
+      # @since 3.0.0
+      def initialize(criteria, map, reduce)
+        @criteria = criteria
+        command[:mapreduce] = criteria.klass.collection_name.to_s
+        command[:map], command[:reduce] = map, reduce
+        apply_criteria_options
+      end
+
+      # Get the number of documents that were input into the map/reduce.
+      #
+      # @example Get the count of input documents.
+      #   map_reduce.input
+      #
+      # @return [ Integer ] The number of input documents.
+      #
+      # @since 3.0.0
+      def input
+        counts["input"]
+      end
+
+      # Sets the map/reduce to use jsMode.
+      #
+      # @example Set the map/reduce to jsMode.
+      #   map_reduce.js_mode
+      #
+      # @return [ MapReduce ] The map/reduce.
+      #
+      # @since 3.0.0
+      def js_mode
+        command[:jsMode] = true
+        self
+      end
+
+      # Specifies where the map/reduce output is to be stored.
+      #
+      # @example Store output in memory.
+      #   map_reduce.out(inline: 1)
+      #
+      # @example Store output in a collection, replacing existing documents.
+      #   map_reduce.out(replace: "collection_name")
+      #
+      # @example Store output in a collection, merging existing documents.
+      #   map_reduce.out(merge: "collection_name")
+      #
+      # @example Store output in a collection, reducing existing documents.
+      #   map_reduce.out(reduce: "collection_name")
+      #
+      # @param [ Hash ] location The place to store the results.
+      #
+      # @return [ MapReduce ] The map/reduce object.
+      #
+      # @since 3.0.0
+      def out(location)
+        normalized = location.dup
+        normalized.update_values do |value|
+          value.is_a?(::Symbol) ? value.to_s : value
+        end
+        command[:out] = normalized
+        self
+      end
+
+      # Get the number of documents output by the map/reduce.
+      #
+      # @example Get the output document count.
+      #   map_reduce.output
+      #
+      # @return [ Integer ] The number of output documents.
+      #
+      # @since 3.0.0
+      def output
+        counts["output"]
+      end
+
+      # Get the raw output from the map/reduce operation.
+      #
+      # @example Get the raw output.
+      #   map_reduce.raw
+      #
+      # @return [ Hash ] The raw output.
+      #
+      # @since 3.0.0
+      def raw
+        results
+      end
+
+      # Get the number of documents reduced by the map/reduce.
+      #
+      # @example Get the reduced document count.
+      #   map_reduce.reduced
+      #
+      # @return [ Integer ] The number of reduced documents.
+      #
+      # @since 3.0.0
+      def reduced
+        counts["reduce"]
+      end
+
+      # Adds a javascript object to the global scope of the map/reduce.
+      #
+      # @example Add an object to the global scope.
+      #   map_reduce.scope(name: value)
+      #
+      # @param [ Hash ] object A hash of key/values for the global scope.
+      #
+      # @return [ MapReduce ]
+      #
+      # @since 3.0.0
+      def scope(object)
+        command[:scope] = object
+        self
+      end
+
+      # Get the execution time of the map/reduce.
+      #
+      # @example Get the execution time.
+      #   map_reduce.time
+      #
+      # @return [ Float ] The time in milliseconds.
+      #
+      # @since 3.0.0
+      def time
+        results["timeMillis"]
+      end
+
+      private
+
+      # Apply criteria specific options - query, sort, limit.
+      #
+      # @api private
+      #
+      # @example Apply the criteria options
+      #   map_reduce.apply_criteria_options
+      #
+      # @return [ nil ] Nothing.
+      #
+      # @since 3.0.0
+      def apply_criteria_options
+        command[:query] = criteria.selector
+        if sort = criteria.options[:sort]
+          command[:orderby] = sort
+        end
+        if limit = criteria.options[:limit]
+          command[:limit] = limit
+        end
+      end
+
+      # Get the result documents from the map/reduce. If the output was inline
+      # then we grab them from the results key. If the output was a temp
+      # collection then we need to execute a find on that collection.
+      #
+      # @api private
+      #
+      # @example Get the documents.
+      #   map_reduce.documents
+      #
+      # @return [ Array, Cursor ] The documents.
+      #
+      # @since 3.0.0
+      def documents
+        return results["results"] if results.has_key?("results")
+        session[output_collection].find
+      end
+
+      # Get the collection that the map/reduce results were stored in.
+      #
+      # @api private
+      #
+      # @example Get the output collection.
+      #   map_reduce.output_collection
+      #
+      # @return [ Symbol, String ] The output collection.
+      #
+      # @since 3.0.0
+      def output_collection
+        command[:out].values.first
+      end
+
+      # Execute the map/reduce command and get the results.
+      #
+      # @api private
+      #
+      # @example Get the results.
+      #   map_reduce.results
+      #
+      # @return [ Hash ] The results of the command.
+      #
+      # @since 3.0.0
+      def results
+        raise Errors::NoMapReduceOutput.new(command) unless command[:out]
+        @results ||= session.command(command)
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/memory.rb

@@ -0,0 +1,383 @@
+# encoding: utf-8
+require "mongoid/contextual/aggregable/memory"
+
+module Mongoid
+  module Contextual
+    class Memory
+      include Enumerable
+      include Aggregable::Memory
+
+      # @attribute [r] collection The root collection.
+      # @attribute [r] criteria The criteria for the context.
+      # @attribute [r] klass The criteria class.
+      # @attribute [r] root The root document.
+      # @attribute [r] path The atomic path.
+      # @attribute [r] selector The root document selector.
+      # @attribute [r] matching The in memory documents that match the selector.
+      attr_reader \
+        :collection,
+        :criteria,
+        :documents,
+        :klass,
+        :path,
+        :root,
+        :selector
+
+      # Check if the context is equal to the other object.
+      #
+      # @example Check equality.
+      #   context == []
+      #
+      # @param [ Array ] other The other array.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 3.0.0
+      def ==(other)
+        return false unless other.respond_to?(:entries)
+        entries == other.entries
+      end
+
+      # Is the enumerable of matching documents empty?
+      #
+      # @example Is the context empty?
+      #   context.blank?
+      #
+      # @return [ true, false ] If the context is empty.
+      #
+      # @since 3.0.0
+      def blank?
+        count == 0
+      end
+      alias :empty? :blank?
+
+      # Delete all documents in the database that match the selector.
+      #
+      # @example Delete all the documents.
+      #   context.delete
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def delete
+        deleted = count
+        removed = map do |doc|
+          prepare_remove(doc)
+          doc.as_document
+        end
+        unless removed.empty?
+          collection.find(selector).update("$pullAll" => { path => removed })
+        end
+        deleted
+      end
+      alias :delete_all :delete
+
+      # Destroy all documents in the database that match the selector.
+      #
+      # @example Destroy all the documents.
+      #   context.destroy
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def destroy
+        deleted = count
+        each do |doc|
+          documents.delete_one(doc)
+          doc.destroy
+        end
+        deleted
+      end
+      alias :destroy_all :destroy
+
+      # Get the distinct values in the db for the provided field.
+      #
+      # @example Get the distinct values.
+      #   context.distinct(:name)
+      #
+      # @param [ String, Symbol ] field The name of the field.
+      #
+      # @return [ Array<Object> ] The distinct values for the field.
+      #
+      # @since 3.0.0
+      def distinct(field)
+        documents.map{ |doc| doc.send(field) }.uniq
+      end
+
+      # Iterate over the context. If provided a block, yield to a Mongoid
+      # document for each, otherwise return an enum.
+      #
+      # @example Iterate over the context.
+      #   context.each do |doc|
+      #     puts doc.name
+      #   end
+      #
+      # @return [ Enumerator ] The enumerator.
+      #
+      # @since 3.0.0
+      def each
+        if block_given?
+          documents[skipping || 0, limiting || documents.length].each do |doc|
+            yield doc
+          end
+        else
+          to_enum
+        end
+      end
+
+      # Do any documents exist for the context.
+      #
+      # @example Do any documents exist for the context.
+      #   context.exists?
+      #
+      # @return [ true, false ] If the count is more than zero.
+      #
+      # @since 3.0.0
+      def exists?
+        count > 0
+      end
+
+      # Get the first document in the database for the criteria's selector.
+      #
+      # @example Get the first document.
+      #   context.first
+      #
+      # @return [ Document ] The first document.
+      #
+      # @since 3.0.0
+      def first
+        documents.first
+      end
+      alias :one :first
+
+      # Create the new in memory context.
+      #
+      # @example Create the new context.
+      #   Memory.new(criteria)
+      #
+      # @param [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def initialize(criteria)
+        @criteria, @klass = criteria, criteria.klass
+        @documents = criteria.documents.select do |doc|
+          @root ||= doc._root
+          @collection ||= root.collection
+          doc.matches?(criteria.selector)
+        end
+        apply_sorting
+        apply_options
+      end
+
+      # Get the last document in the database for the criteria's selector.
+      #
+      # @example Get the last document.
+      #   context.last
+      #
+      # @return [ Document ] The last document.
+      #
+      # @since 3.0.0
+      def last
+        documents.last
+      end
+
+      # Get the length of matching documents in the context.
+      #
+      # @example Get the length of matching documents.
+      #   context.length
+      #
+      # @return [ Integer ] The matching length.
+      #
+      # @since 3.0.0
+      def length
+        documents.length
+      end
+      alias :size :length
+
+      # Limits the number of documents that are returned.
+      #
+      # @example Limit the documents.
+      #   context.limit(20)
+      #
+      # @param [ Integer ] value The number of documents to return.
+      #
+      # @return [ Mongo ] The context.
+      #
+      # @since 3.0.0
+      def limit(value)
+        self.limiting = value
+        self
+      end
+
+      # Skips the provided number of documents.
+      #
+      # @example Skip the documents.
+      #   context.skip(20)
+      #
+      # @param [ Integer ] value The number of documents to skip.
+      #
+      # @return [ Mongo ] The context.
+      #
+      # @since 3.0.0
+      def skip(value)
+        self.skipping = value
+        self
+      end
+
+      # Sorts the documents by the provided spec.
+      #
+      # @example Sort the documents.
+      #   context.sort(name: -1, title: 1)
+      #
+      # @param [ Hash ] values The sorting values as field/direction(1/-1)
+      #   pairs.
+      #
+      # @return [ Mongo ] The context.
+      #
+      # @since 3.0.0
+      def sort(values)
+        in_place_sort(values) and self
+      end
+
+      # Update all the matching documents atomically.
+      #
+      # @example Update all the matching documents.
+      #   context.update(name: "Smiths")
+      #
+      # @param [ Hash ] attributes The new attributes for each document.
+      #
+      # @return [ nil, false ] False if no attributes were provided.
+      #
+      # @since 3.0.0
+      def update(attributes = nil)
+        return false unless attributes
+        updates = {}
+        each do |doc|
+          @selector ||= root.atomic_selector
+          doc.write_attributes(attributes)
+          updates.merge!(doc.atomic_position => attributes)
+        end
+        collection.find(selector).update("$set" => updates)
+      end
+      alias :update_all :update
+
+      private
+
+      # Get the limiting value.
+      #
+      # @api private
+      #
+      # @example Get the limiting value.
+      #
+      # @return [ Integer ] The limit.
+      #
+      # @since 3.0.0
+      def limiting
+        defined?(@limiting) ? @limiting : nil
+      end
+
+      # Set the limiting value.
+      #
+      # @api private
+      #
+      # @example Set the limiting value.
+      #
+      # @param [ Integer ] value The limit.
+      #
+      # @return [ Integer ] The limit.
+      #
+      # @since 3.0.0
+      def limiting=(value)
+        @limiting = value
+      end
+
+      # Get the skiping value.
+      #
+      # @api private
+      #
+      # @example Get the skiping value.
+      #
+      # @return [ Integer ] The skip.
+      #
+      # @since 3.0.0
+      def skipping
+        defined?(@skipping) ? @skipping : nil
+      end
+
+      # Set the skiping value.
+      #
+      # @api private
+      #
+      # @example Set the skiping value.
+      #
+      # @param [ Integer ] value The skip.
+      #
+      # @return [ Integer ] The skip.
+      #
+      # @since 3.0.0
+      def skipping=(value)
+        @skipping = value
+      end
+
+      # Apply criteria options.
+      #
+      # @api private
+      #
+      # @example Apply criteria options.
+      #   context.apply_options
+      #
+      # @return [ Memory ] self.
+      #
+      # @since 3.0.0
+      def apply_options
+        skip(criteria.options[:skip]).limit(criteria.options[:limit])
+      end
+
+      # Map the sort symbols to the correct MongoDB values.
+      #
+      # @example Apply the sorting params.
+      #   context.apply_sorting
+      #
+      # @since 3.0.0
+      def apply_sorting
+        if spec = criteria.options[:sort]
+          in_place_sort(spec)
+        end
+      end
+
+      # Sort the documents in place.
+      #
+      # @example Sort the documents.
+      #   context.in_place_sort(name: 1)
+      #
+      # @param [ Hash ] values The field/direction sorting pairs.
+      #
+      # @since 3.0.0
+      def in_place_sort(values)
+        values.each_pair do |field, dir|
+          documents.sort! do |a, b|
+            dir > 0 ? a[field] <=> b[field] : b[field] <=> a[field]
+          end
+        end
+      end
+
+      # Prepare the document for batch removal.
+      #
+      # @api private
+      #
+      # @example Prepare for removal.
+      #   context.prepare_remove(doc)
+      #
+      # @param [ Document ] doc The document.
+      #
+      # @since 3.0.0
+      def prepare_remove(doc)
+        @selector ||= root.atomic_selector
+        @path ||= doc.atomic_path
+        documents.delete_one(doc)
+        doc._parent.remove_child(doc)
+        doc.destroyed = true
+      end
+    end
+  end
+end