mongoid_rails4 4.0.0

data/lib/mongoid/contextual/atomic.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    module Atomic
+
+      # Execute an atomic $addToSet on the matching documents.
+      #
+      # @example Add the value to the set.
+      #   context.add_to_set(members: "Dave", genres: "Electro")
+      #
+      # @param [ Hash ] adds The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def add_to_set(adds)
+        query.update_all("$addToSet" => collect_operations(adds))
+      end
+
+      # Perform an atomic $bit operation on the matching documents.
+      #
+      # @example Perform the bitwise op.
+      #   context.bit(likes: { and: 14, or: 4 })
+      #
+      # @param [ Hash ] bits The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def bit(bits)
+        query.update_all("$bit" => collect_operations(bits))
+      end
+
+      # Perform an atomic $inc operation on the matching documents.
+      #
+      # @example Perform the atomic increment.
+      #   context.inc(likes: 10)
+      #
+      # @param [ Hash ] incs The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def inc(incs)
+        query.update_all("$inc" => collect_operations(incs))
+      end
+
+      # Perform an atomic $pop operation on the matching documents.
+      #
+      # @example Pop the first value on the matches.
+      #   context.pop(members: -1)
+      #
+      # @example Pop the last value on the matches.
+      #   context.pop(members: 1)
+      #
+      # @param [ Hash ] pops The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def pop(pops)
+        query.update_all("$pop" => collect_operations(pops))
+      end
+
+      # Perform an atomic $pull operation on the matching documents.
+      #
+      # @example Pull the value from the matches.
+      #   context.pull(members: "Dave")
+      #
+      # @note Expression pulling is not yet supported.
+      #
+      # @param [ Hash ] pulls The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def pull(pulls)
+        query.update_all("$pull" => collect_operations(pulls))
+      end
+
+      # Perform an atomic $pullAll operation on the matching documents.
+      #
+      # @example Pull all the matching values from the matches.
+      #   context.pull_all(:members, [ "Alan", "Vince" ])
+      #
+      # @param [ Hash ] pulls The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def pull_all(pulls)
+        query.update_all("$pullAll" => collect_operations(pulls))
+      end
+
+      # Perform an atomic $push operation on the matching documents.
+      #
+      # @example Push the value to the matching docs.
+      #   context.push(members: "Alan")
+      #
+      # @param [ Hash ] pushes The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def push(pushes)
+        query.update_all("$push" => collect_operations(pushes))
+      end
+
+      # Perform an atomic $pushAll operation on the matching documents.
+      #
+      # @example Push the values to the matching docs.
+      #   context.push(members: [ "Alan", "Fletch" ])
+      #
+      # @param [ Hash ] pushes The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def push_all(pushes)
+        query.update_all("$pushAll" => collect_operations(pushes))
+      end
+
+      # Perform an atomic $rename of fields on the matching documents.
+      #
+      # @example Rename the fields on the matching documents.
+      #   context.rename(members: :artists)
+      #
+      # @param [ Hash ] renames The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def rename(renames)
+        operations = renames.inject({}) do |ops, (old_name, new_name)|
+          ops[old_name] = new_name.to_s
+          ops
+        end
+        query.update_all("$rename" => collect_operations(operations))
+      end
+
+      # Perform an atomic $set of fields on the matching documents.
+      #
+      # @example Set the field value on the matches.
+      #   context.set(name: "Depeche Mode")
+      #
+      # @param [ Hash ] sets The operations.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def set(sets)
+        query.update_all("$set" => collect_operations(sets))
+      end
+
+      # Perform an atomic $unset of a field on the matching documents.
+      #
+      # @example Unset the field on the matches.
+      #   context.unset(:name)
+      #
+      # @param [ String, Symbol, Array ] fields The name of the fields.
+      #
+      # @return [ nil ] Nil.
+      #
+      # @since 3.0.0
+      def unset(*args)
+        fields = args.__find_args__.collect { |f| [database_field_name(f), true] }
+        query.update_all("$unset" => Hash[fields])
+      end
+
+      private
+
+      def collect_operations(ops)
+        ops.inject({}) do |operations, (field, value)|
+          operations[database_field_name(field)] = value.mongoize
+          operations
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/command.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    module Command
+
+      # @attribute [r] collection The collection to query against.
+      # @attribute [r] criteria The criteria for the context.
+      attr_reader :collection, :criteria
+
+      # The database command that is being built to send to the db.
+      #
+      # @example Get the command.
+      #   command.command
+      #
+      # @return [ Hash ] The db command.
+      #
+      # @since 3.0.0
+      def command
+        @command ||= {}
+      end
+
+      # Get the database session.
+      #
+      # @example Get the session.
+      #   command.session
+      #
+      # @return [ Session ] The Moped session.
+      #
+      # @since 3.0.0
+      def session
+        collection.database.session
+      end
+
+      private
+
+      # Execute the block setting field limitations.
+      #
+      # @api private
+      #
+      # @example Execute with field limitations.
+      #   text_search.selecting do
+      #     #...
+      #   end
+      #
+      # @param [ Symbol ] param The name of the command parameter.
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 4.0.0
+      def selecting(param)
+        begin
+          fields = command[param]
+          Threaded.set_selection(criteria.object_id, fields) unless fields.blank?
+          yield
+        ensure
+          Threaded.delete_selection(criteria.object_id)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/eager.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    module Eager
+
+      # @attribute [rw] eager_loaded Has the context been eager loaded?
+      attr_accessor :eager_loaded
+
+      private
+
+      # Eager load the inclusions for the provided documents.
+      #
+      # @api private
+      #
+      # @example Eager load the inclusions.
+      #   context.eager_load(docs)
+      #
+      # @param [ Array<Document> ] docs The docs returning from the db.
+      #
+      # @return [ true ] Always true.
+      #
+      # @since 3.0.0
+      def eager_load(docs)
+        load_inclusions(docs)
+        self.eager_loaded = true
+      end
+
+      # Eager load the inclusions for the provided document.
+      #
+      # @api private
+      #
+      # @example Eager load the inclusions.
+      #   context.eager_load(doc)
+      #
+      # @param [ Document ] doc The doc returning from the db.
+      #
+      # @return [ true ] Always true.
+      #
+      # @since 3.0.16
+      def eager_load_one(doc)
+        load_inclusions([ doc ])
+        inclusions_loaded[doc.id] = true
+      end
+
+      # Get the ids that to be used to eager load documents.
+      #
+      # @api private
+      #
+      # @example Get the ids.
+      #   context.eager_load(docs, metadata)
+      #
+      # @param [ Array<Document> ] docs The pre-loaded documents.
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ Array<Object> ] The ids.
+      #
+      # @since 3.0.0
+      def eager_loaded_ids(docs, metadata)
+        if metadata.stores_foreign_key?
+          docs.flat_map{ |doc| doc.send(metadata.foreign_key) }
+        else
+          docs.map(&:id)
+        end
+      end
+
+      # Is this context able to be eager loaded?
+      #
+      # @api private
+      #
+      # @example Is the context eager loadable?
+      #   context.eager_loadable?
+      #
+      # @example Is the single document eager loadable?
+      #   context.eager_loadable?(document)
+      #
+      # @param [ Document ] document The single document to load for.
+      #
+      # @return [ true, false ] If the context is able to be eager loaded.
+      #
+      # @since 3.0.0
+      def eager_loadable?(document = nil)
+        return false if criteria.inclusions.empty?
+        document ? !inclusions_loaded?(document) : !eager_loaded
+      end
+
+      # Has a hash of individual documents that have had their relations reager
+      # loaded.
+      #
+      # @api private
+      #
+      # @example Get the documents with relations eager loaded.
+      #   context.inclusions_loaded
+      #
+      # @return [ Hash ] The documents that have had eager loaded inclusions.
+      #
+      # @since 3.0.16
+      def inclusions_loaded
+        @inclusions_loaded ||= {}
+      end
+
+      # Has the document had its inclusions loaded?
+      #
+      # @api private
+      #
+      # @example Has the document had its inclusions loaded?
+      #   context.inclusions_loaded?(document)
+      #
+      # @param [ Document ] document The document to check.
+      #
+      # @return [ true, false ] If the document had it's inclusions loaded.
+      #
+      # @since 3.0.16
+      def inclusions_loaded?(document)
+        inclusions_loaded.has_key?(document.id)
+      end
+
+      # Eager load the inclusions for the provided documents.
+      #
+      # @api private
+      #
+      # @example Eager load the inclusions.
+      #   context.load_inclusions(docs)
+      #
+      # @param [ Array<Document> ] docs The docs returning from the db.
+      #
+      # @return [ true ] Always true.
+      #
+      # @since 3.0.16
+      def load_inclusions(docs)
+        criteria.inclusions.each do |metadata|
+          metadata.eager_load(eager_loaded_ids(docs, metadata)) if !docs.empty?
+        end
+      end
+
+      # If the provided document exists, eager load its dependencies or return
+      # nil.
+      #
+      # @api private
+      #
+      # @example Eager load if the document is not nil.
+      #   context.with_eager_loading(document)
+      #
+      # @param [ Hash ] document The document from the database.
+      #
+      # @return [ Document, nil ] The instantiated model document.
+      #
+      # @since 3.0.0
+      def with_eager_loading(document)
+        selecting do
+          return nil unless document
+          doc = Factory.from_db(klass, document, criteria.object_id)
+          eager_load_one(doc) if eager_loadable?(doc)
+          doc
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/contextual/find_and_modify.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Mongoid
+  module Contextual
+    class FindAndModify
+      include Command
+
+      # @attribute [r] criteria The criteria for the context.
+      # @attribute [r] options The command options.
+      # @attribute [r] update The updates.
+      # @attribute [r] query The Moped query.
+      attr_reader :criteria, :options, :update, :query
+
+      # Initialize the find and modify command, used for MongoDB's
+      # $findAndModify.
+      #
+      # @example Initialize the command.
+      #   FindAndModify.new(criteria, { "$set" => { likes: 1 }})
+      #
+      # @param [ Criteria ] criteria The criteria.
+      # @param [ Hash ] update The updates.
+      # @param [ Hash ] options The command options.
+      #
+      # @option options [ true, false ] :new Return the updated document.
+      # @option options [ true, false ] :remove Delete the first document.
+      # @option options [ true, false ] :upsert Create the document if it doesn't exist.
+      #
+      # @since 3.0.0
+      def initialize(collection, criteria, update, options = {})
+        @collection, @criteria, @options, @update =
+          collection, criteria, options, update.mongoize
+        @query = collection.find(criteria.selector)
+        apply_criteria_options
+      end
+
+      # Get the result of the $findAndModify.
+      #
+      # @example Get the result.
+      #   find_and_modify.result
+      #
+      # @return [ Hash ] The result of the command.
+      #
+      # @since 3.0.0
+      def result
+        query.modify(update, options)
+      end
+
+      private
+
+      # Apply criteria specific options - query, sort, fields.
+      #
+      # @api private
+      #
+      # @example Apply the criteria options
+      #   find_and_modify.apply_criteria_options
+      #
+      # @return [ nil ] Nothing.
+      #
+      # @since 3.0.0
+      def apply_criteria_options
+        if spec = criteria.options[:sort]
+          query.sort(spec)
+        end
+        if spec = criteria.options[:fields]
+          query.select(spec)
+        end
+      end
+    end
+  end
+end