mongoid 3.1.6 → 4.0.2

data/lib/mongoid/persistable/renamable.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $rename operations.
+    #
+    # @since 4.0.0
+    module Renamable
+      extend ActiveSupport::Concern
+
+      # Rename fields from one value to another via $rename.
+      #
+      # @example Rename the fields.
+      #   document.rename(title: "salutation", name: "nombre")
+      #
+      # @note This does not work for fields in embeds many relations.
+      #
+      # @param [ Hash ] renames The rename pairs of old name/new name.
+      #
+      # @return [ true, false ] If the rename suceeded.
+      #
+      # @since 4.0.0
+      def rename(renames)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(renames) do |old_field, new_field|
+            new_name = new_field.to_s
+            attributes[new_name] = attributes.delete(old_field)
+            ops[atomic_attribute_name(old_field)] = atomic_attribute_name(new_name)
+          end
+          { "$rename" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/savable.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that save documents.
+    #
+    # @since 4.0.0
+    module Savable
+
+      # Save the document - will perform an insert if the document is new, and
+      # update if not.
+      #
+      # @example Save the document.
+      #   document.save
+      #
+      # @param [ Hash ] options Options to pass to the save.
+      #
+      # @return [ true, false ] True is success, false if not.
+      #
+      # @since 1.0.0
+      def save(options = {})
+        if new_record?
+          !insert(options).new_record?
+        else
+          update_document(options)
+        end
+      end
+
+      # Save the document - will perform an insert if the document is new, and
+      # update if not. If a validation error occurs an error will get raised.
+      #
+      # @example Save the document.
+      #   document.save!
+      #
+      # @param [ Hash ] options Options to pass to the save.
+      #
+      # @raise [ Errors::Validations ] If validation failed.
+      # @raise [ Errors::Callback ] If a callback returns false.
+      #
+      # @return [ true, false ] True if validation passed.
+      #
+      # @since 1.0.0
+      def save!(options = {})
+        unless save(options)
+          fail_due_to_validation! unless errors.empty?
+          fail_due_to_callback!(:save!)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/settable.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $set operations.
+    #
+    # @since 4.0.0
+    module Settable
+      extend ActiveSupport::Concern
+
+      # Perform a $set operation on the provided field/value pairs and set the
+      # values in the document in memory.
+      #
+      # @example Set the values.
+      #   document.set(title: "sir", dob: Date.new(1970, 1, 1))
+      #
+      # @param [ Hash ] setters The field/value pairs to set.
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def set(setters)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(setters) do |field, value|
+            process_attribute(field.to_s, value)
+            ops[atomic_attribute_name(field)] = attributes[field]
+          end
+          { "$set" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/unsettable.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $unset operations.
+    #
+    # @since 4.0.0
+    module Unsettable
+      extend ActiveSupport::Concern
+
+      # Perform an $unset operation on the provided fields and in the
+      # values in the document in memory.
+      #
+      # @example Unset the values.
+      #   document.unset(:first_name, :last_name, :middle)
+      #
+      # @param [ Array<String, Symbol> ] fields The names of the fields to
+      #   unset.
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def unset(*fields)
+        prepare_atomic_operation do |ops|
+          fields.flatten.each do |field|
+            normalized = database_field_name(field)
+            attributes.delete(normalized)
+            ops[atomic_attribute_name(normalized)] = true
+          end
+          { "$unset" => ops }
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/persistable/updatable.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that update existing
+    # documents.
+    #
+    # @since 4.0.0
+    module Updatable
+
+      # Update a single attribute and persist the entire document.
+      # This skips validation but fires the callbacks.
+      #
+      # @example Update the attribute.
+      #   person.update_attribute(:title, "Sir")
+      #
+      # @param [ Symbol, String ] name The name of the attribute.
+      # @param [ Object ] value The new value of the attribute.a
+      #
+      # @raise [ Errors::ReadonlyAttribute ] If the field cannot be changed due
+      #   to being flagged as reaodnly.
+      #
+      # @return [ true, false ] True if save was successfull, false if not.
+      #
+      # @since 2.0.0
+      def update_attribute(name, value)
+        normalized = name.to_s
+        unless attribute_writable?(normalized)
+          raise Errors::ReadonlyAttribute.new(normalized, value)
+        end
+        setter = "#{normalized}="
+        if respond_to?(setter)
+          send(setter, value)
+        else
+          write_attribute(database_field_name(normalized), value)
+        end
+        save(validate: false)
+      end
+
+      # Update the document attributes in the database.
+      #
+      # @example Update the document's attributes
+      #   document.update(:title => "Sir")
+      #
+      # @param [ Hash ] attributes The attributes to update.
+      #
+      # @return [ true, false ] True if validation passed, false if not.
+      #
+      # @since 1.0.0
+      def update(attributes = {})
+        assign_attributes(attributes)
+        save
+      end
+      alias :update_attributes :update
+
+      # Update the document attributes in the database and raise an error if
+      # validation failed.
+      #
+      # @example Update the document's attributes.
+      #   document.update!(:title => "Sir")
+      #
+      # @param [ Hash ] attributes The attributes to update.
+      #
+      # @raise [ Errors::Validations ] If validation failed.
+      # @raise [ Errors::Callbacks ] If a callback returns false.
+      #
+      # @return [ true, false ] True if validation passed.
+      #
+      # @since 1.0.0
+      def update!(attributes = {})
+        result = update_attributes(attributes)
+        unless result
+          fail_due_to_validation! unless errors.empty?
+          fail_due_to_callback!(:update_attributes!)
+        end
+        result
+      end
+      alias :update_attributes! :update!
+
+      private
+
+      # Initialize the atomic updates.
+      #
+      # @api private
+      #
+      # @example Initialize the atomic updates.
+      #   document.init_atomic_updates
+      #
+      # @return [ Array<Hash> ] The updates and conflicts.
+      #
+      # @since 4.0.0
+      def init_atomic_updates
+        updates = atomic_updates
+        conflicts = updates.delete(:conflicts) || {}
+        [ updates, conflicts ]
+      end
+
+      # Prepare the update for execution. Validates and runs callbacks, etc.
+      #
+      # @api private
+      #
+      # @example Prepare for update.
+      #   document.prepare_update do
+      #     collection.update(atomic_selector)
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @return [ true, false ] The result of the update.
+      #
+      # @since 4.0.0
+      def prepare_update(options = {})
+        return false if performing_validations?(options) &&
+          invalid?(options[:context] || :update)
+        process_flagged_destroys
+        result = run_callbacks(:save) do
+          run_callbacks(:update) do
+            yield(self)
+            true
+          end
+        end
+        post_process_persist(result, options) and result
+      end
+
+      # Update the document in the database.
+      #
+      # @example Update an existing document.
+      #   document.update
+      #
+      # @param [ Hash ] options Options to pass to update.
+      #
+      # @option options [ true, false ] :validate Whether or not to validate.
+      #
+      # @return [ true, false ] True if succeeded, false if not.
+      #
+      # @since 1.0.0
+      def update_document(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
+        prepare_update(options) do
+          updates, conflicts = init_atomic_updates
+          unless updates.empty?
+            coll = _root.collection
+            selector = atomic_selector
+            coll.find(selector).update(positionally(selector, updates))
+            conflicts.each_pair do |key, value|
+              coll.find(selector).update(positionally(selector, { key => value }))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/upsertable.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that upsert documents.
+    #
+    # @since 4.0.0
+    module Upsertable
+
+      # Perform an upsert of the document. If the document does not exist in the
+      # database, then Mongo will insert a new one, otherwise the fields will get
+      # overwritten with new values on the existing document.
+      #
+      # @example Upsert the document.
+      #   document.upsert
+      #
+      # @param [ Hash ] options The validation options.
+      #
+      # @return [ true ] True.
+      #
+      # @since 3.0.0
+      def upsert(options = {})
+        prepare_upsert(options) do
+          collection.find(atomic_selector).update(as_document, [ :upsert ])
+        end
+      end
+
+      private
+
+      # Prepare the upsert for execution.
+      #
+      # @api private
+      #
+      # @example Prepare the upsert
+      #   document.prepare_upsert do
+      #     collection.find(selector).update(as_document)
+      #   end
+      #
+      # @param [ Hash ] options The options hash.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def prepare_upsert(options = {})
+        return false if performing_validations?(options) && invalid?(:upsert)
+        result = run_callbacks(:upsert) do
+          yield(self)
+          true
+        end
+        self.new_record = false
+        post_process_persist(result, options) and result
+      end
+    end
+  end
+end

data/lib/mongoid/positional.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module is responsible for taking update selectors and switching out
+  # the indexes for the $ positional operator where appropriate.
+  #
+  # @since 4.0.0
+  module Positional
+
+    # Takes the provided selector and atomic operations and replaces the
+    # indexes of the embedded documents with the positional operator when
+    # needed.
+    #
+    # @note The only time we can accurately know when to use the positional
+    #   operator is at the exact time we are going to persist something. So
+    #   we can tell by the selector that we are sending if it is actually
+    #   possible to use the positional operator at all. For example, if the
+    #   selector is: { "_id" => 1 }, then we could not use the positional
+    #   operator for updating embedded documents since there would never be a
+    #   match - we base whether we can based on the number of levels deep the
+    #   selector goes, and if the id values are not nil.
+    #
+    # @example Process the operations.
+    #   positionally(
+    #     { "_id" => 1, "addresses._id" => 2 },
+    #     { "$set" => { "addresses.0.street" => "hobrecht" }}
+    #   )
+    #
+    # @param [ Hash ] selector The selector.
+    # @param [ Hash ] operations The update operations.
+    # @param [ Hash ] processed The processed update operations.
+    #
+    # @return [ Hash ] The new operations.
+    #
+    # @since 3.1.0
+    def positionally(selector, operations, processed = {})
+      if selector.size == 1 || selector.values.any? { |val| val.nil? }
+        return operations
+      end
+      keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
+      keys = keys.sort_by { |s| s.length*-1 }
+      process_operations(keys, operations, processed)
+    end
+
+    private
+
+    def process_operations(keys, operations, processed)
+      operations.each_pair do |operation, update|
+        processed[operation] = process_updates(keys, update)
+      end
+      processed
+    end
+
+    def process_updates(keys, update, updates = {})
+      update.each_pair do |position, value|
+        updates[replace_index(keys, position)] = value
+      end
+      updates
+    end
+
+    def replace_index(keys, position)
+      # replace to $ only if that key is on the selector
+      keys.each do |kk|
+        if position =~ /^#{kk}\.\d+\.(.*)/
+          return "#{kk}.$.#{$1}"
+        end
+      end
+      position
+    end
+  end
+end

data/lib/mongoid/query_cache.rb

@@ -0,0 +1,255 @@
+# encoding: utf-8
+module Mongoid
+
+  # A cache of database queries on a per-request basis.
+  #
+  # @since 4.0.0
+  module QueryCache
+    class << self
+
+      # Get the cached queries.
+      #
+      # @example Get the cached queries from the current thread.
+      #   QueryCache.cache_table
+      #
+      # @return [ Hash ] The hash of cached queries.
+      #
+      # @since 4.0.0
+      def cache_table
+        Thread.current["[mongoid]:query_cache"] ||= {}
+      end
+
+      # Clear the query cache.
+      #
+      # @example Clear the cache.
+      #   QueryCache.clear_cache
+      #
+      # @return [ nil ] Always nil.
+      #
+      # @since 4.0.0
+      def clear_cache
+        Thread.current["[mongoid]:query_cache"] = nil
+      end
+
+      # Set whether the cache is enabled.
+      #
+      # @example Set if the cache is enabled.
+      #   QueryCache.enabled = true
+      #
+      # @param [ true, false ] value The enabled value.
+      #
+      # @since 4.0.0
+      def enabled=(value)
+        Thread.current["[mongoid]:query_cache:enabled"] = value
+      end
+
+      # Is the query cache enabled on the current thread?
+      #
+      # @example Is the query cache enabled?
+      #   QueryCache.enabled?
+      #
+      # @return [ true, false ] If the cache is enabled.
+      #
+      # @since 4.0.0
+      def enabled?
+        !!Thread.current["[mongoid]:query_cache:enabled"]
+      end
+
+      # Execute the block while using the query cache.
+      #
+      # @example Execute with the cache.
+      #   QueryCache.cache { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 4.0.0
+      def cache
+        enabled = QueryCache.enabled?
+        QueryCache.enabled = true
+        yield
+      ensure
+        QueryCache.enabled = enabled
+      end
+    end
+
+    # The middleware to be added to a rack application in order to activate the
+    # query cache.
+    #
+    # @since 4.0.0
+    class Middleware
+
+      # Instantiate the middleware.
+      #
+      # @example Create the new middleware.
+      #   Middleware.new(app)
+      #
+      # @param [ Object ] app The rack applciation stack.
+      #
+      # @since 4.0.0
+      def initialize(app)
+        @app = app
+      end
+
+      # Execute the request, wrapping in a query cache.
+      #
+      # @example Execute the request.
+      #   middleware.call(env)
+      #
+      # @param [ Object ] env The environment.
+      #
+      # @return [ Object ] The result of the call.
+      #
+      # @since 4.0.0
+      def call(env)
+        QueryCache.cache { @app.call(env) }
+      ensure
+        QueryCache.clear_cache
+      end
+    end
+
+    module Base # :nodoc:
+
+      def alias_query_cache_clear(*method_names)
+        method_names.each do |method_name|
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{method_name}_with_clear_cache(*args)   # def upsert_with_clear_cache(*args)
+                QueryCache.clear_cache                     #   QueryCache.clear_cache
+                #{method_name}_without_clear_cache(*args)  #   upsert_without_clear_cache(*args)
+              end                                          # end
+            CODE
+
+          alias_method_chain method_name, :clear_cache
+        end
+      end
+    end
+
+    # Module to include in objects which need to wrap caching behaviour around
+    # them.
+    #
+    # @since 4.0.0
+    module Cacheable
+
+      private
+
+      def with_cache(context = :cursor, more = false, &block)
+        return yield unless QueryCache.enabled?
+        return yield if system_collection?
+        key = cache_key.push(context)
+
+        if more
+          docs = yield
+          QueryCache.cache_table[key].push(*docs)
+          docs
+        elsif QueryCache.cache_table.has_key?(key)
+          instrument(key) { QueryCache.cache_table[key] }
+        else
+          QueryCache.cache_table[key] = yield
+        end
+      end
+
+      def instrument(key, &block)
+        ActiveSupport::Notifications.instrument("query_cache.mongoid", key: key, &block)
+      end
+    end
+
+    # Adds behaviour around caching to a Moped Query object.
+    #
+    # @since 4.0.0
+    module Query
+      extend ActiveSupport::Concern
+      include Cacheable
+
+      included do
+        extend QueryCache::Base
+        alias_method_chain :cursor, :cache
+        alias_method_chain :first, :cache
+        alias_query_cache_clear :remove, :remove_all, :update, :update_all, :upsert
+      end
+
+      # Provide a wrapped query cache cursor.
+      #
+      # @example Get the wrapped caching cursor.
+      #   query.cursor_with_cache
+      #
+      # @return [ CachedCursor ] The cached cursor.
+      #
+      # @since 4.0.0
+      def cursor_with_cache
+        CachedCursor.new(session, operation)
+      end
+
+      # Override first with caching.
+      #
+      # @example Get the first with a cache.
+      #   query.first_with_cache
+      #
+      # @return [ Hash ] The first document.
+      #
+      # @since 4.0.0
+      def first_with_cache
+        with_cache(:first) do
+          first_without_cache
+        end
+      end
+
+      private
+
+      def cache_key
+        [ operation.database, operation.collection, operation.selector, operation.limit, operation.skip, operation.fields ]
+      end
+
+      def system_collection?
+        operation.collection =~ /^system./
+      end
+    end
+
+    # Adds behaviour to the query cache for collections.
+    #
+    # @since 4.0.0
+    module Collection
+      extend ActiveSupport::Concern
+
+      included do
+        extend QueryCache::Base
+        alias_query_cache_clear :insert
+      end
+    end
+
+    # A Cursor that attempts to load documents from memory first before hitting
+    # the database if the same query has already been executed.
+    #
+    # @since 4.0.0
+    class CachedCursor < Moped::Cursor
+      include Cacheable
+
+      # Override the loading of docs to attempt to fetch from the cache.
+      #
+      # @example Load the documents.
+      #   cursor.load_docs
+      #
+      # @return [ Array<Hash> ] The documents.
+      #
+      # @since 4.0.0
+      def load_docs
+        with_cache { super }
+      end
+
+      def get_more
+        with_cache(:cursor, true) { super }
+      end
+
+      private
+
+      def cache_key
+        [ @database, @collection, @selector, @options[:limit], @options[:skip], @options[:fields] ]
+      end
+
+      def system_collection?
+        @collection =~ /^system./
+      end
+    end
+  end
+end
+
+Moped::Query.__send__(:include, Mongoid::QueryCache::Query)
+Moped::Collection.__send__(:include, Mongoid::QueryCache::Collection)