mongoid 3.1.5 → 8.0.2

data/lib/mongoid/persistable.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require "mongoid/persistable/creatable"
+require "mongoid/persistable/deletable"
+require "mongoid/persistable/destroyable"
+require "mongoid/persistable/incrementable"
+require "mongoid/persistable/logical"
+require "mongoid/persistable/poppable"
+require "mongoid/persistable/pullable"
+require "mongoid/persistable/pushable"
+require "mongoid/persistable/renamable"
+require "mongoid/persistable/savable"
+require "mongoid/persistable/settable"
+require "mongoid/persistable/updatable"
+require "mongoid/persistable/upsertable"
+require "mongoid/persistable/unsettable"
+
+module Mongoid
+
+  # Contains general behavior for persistence operations.
+  module Persistable
+    extend ActiveSupport::Concern
+    include Creatable
+    include Deletable
+    include Destroyable
+    include Incrementable
+    include Logical
+    include Poppable
+    include Positional
+    include Pullable
+    include Pushable
+    include Renamable
+    include Savable
+    include Settable
+    include Updatable
+    include Upsertable
+    include Unsettable
+
+    # The atomic operations that deal with arrays or sets in the db.
+    LIST_OPERATIONS = [ "$addToSet", "$push", "$pull", "$pullAll" ].freeze
+
+    # Execute operations atomically (in a single database call) for everything
+    # that would happen inside the block. This method supports nesting further
+    # calls to atomically, which will behave according to the options described
+    # below.
+    #
+    # An option join_context can be given which, when true, will merge the
+    # operations declared by the given block with the atomically block wrapping
+    # the current invocation for the same document, if one exists. If this
+    # block or any other block sharing the same context raises before
+    # persisting, then all the operations of that context will not be
+    # persisted, and will also be reset in memory.
+    #
+    # When join_context is false, the given block of operations will be
+    # persisted independently of other contexts. Failures in other contexts will
+    # not affect this one, so long as this block was able to run and persist
+    # changes.
+    #
+    # The default value of join_context is set by the global configuration
+    # option join_contexts, whose own default is false.
+    #
+    # @example Execute the operations atomically.
+    #   document.atomically do
+    #     document.set(name: "Tool").inc(likes: 10)
+    #   end
+    #
+    # @example Execute some inner operations atomically, but independently from the outer operations.
+    #
+    #   document.atomically do
+    #     document.inc likes: 10
+    #     document.atomically join_context: false do
+    #       # The following is persisted to the database independently.
+    #       document.unset :origin
+    #     end
+    #     document.atomically join_context: true do
+    #       # The following is persisted along with the other outer operations.
+    #       document.inc member_count: 3
+    #     end
+    #     document.set name: "Tool"
+    #   end
+    #
+    # @param [ true | false ] join_context Join the context (i.e. merge
+    #   declared atomic operations) of the atomically block wrapping this one
+    #   for the same document, if one exists.
+    #
+    # @return [ true | false ] If the operation succeeded.
+    def atomically(join_context: nil)
+      join_context = Mongoid.join_contexts if join_context.nil?
+      call_depth = @atomic_depth ||= 0
+      has_own_context = call_depth.zero? || !join_context
+      @atomic_updates_to_execute_stack ||= []
+      _mongoid_push_atomic_context if has_own_context
+
+      if block_given?
+        @atomic_depth += 1
+        yield(self)
+        @atomic_depth -= 1
+      end
+
+      if has_own_context
+        persist_atomic_operations @atomic_context
+        _mongoid_remove_atomic_context_changes
+      end
+
+      true
+    rescue Exception => e
+      _mongoid_reset_atomic_context_changes! if has_own_context
+      raise e
+    ensure
+      _mongoid_pop_atomic_context if has_own_context
+
+      if call_depth.zero?
+        @atomic_depth = nil
+        @atomic_updates_to_execute_stack = nil
+      end
+    end
+
+    # Raise an error if validation failed.
+    #
+    # @example Raise the validation error.
+    #   Person.fail_due_to_validation!(person)
+    #
+    # @raise [ Errors::Validations ] The validation error.
+    def fail_due_to_validation!
+      raise Errors::Validations.new(self)
+    end
+
+    # Raise an error if a callback failed.
+    #
+    # @example Raise the callback error.
+    #   Person.fail_due_to_callback!(person, :create!)
+    #
+    # @param [ Symbol ] method The method being called.
+    #
+    # @raise [ Errors::Callback ] The callback error.
+    def fail_due_to_callback!(method)
+      raise Errors::Callback.new(self.class, method)
+    end
+
+    private
+
+    # Are we executing an atomically block on the current document?
+    #
+    # @api private
+    #
+    # @example Are we executing atomically?
+    #   document.executing_atomically?
+    #
+    # @return [ true | false ] If we are current executing atomically.
+    def executing_atomically?
+      !@atomic_updates_to_execute_stack.nil?
+    end
+
+    # Post process the persistence operation.
+    #
+    # @api private
+    #
+    # @example Post process the persistence operation.
+    #   document.post_process_persist(true)
+    #
+    # @param [ Object ] result The result of the operation.
+    # @param [ Hash ] options The options.
+    #
+    # @return [ true ] true.
+    def post_process_persist(result, options = {})
+      post_persist unless result == false
+      errors.clear unless performing_validations?(options)
+      true
+    end
+
+    # Prepare an atomic persistence operation. Yields an empty hash to be sent
+    # to the update.
+    #
+    # @api private
+    #
+    # @example Prepare the atomic operation.
+    #   document.prepare_atomic_operation do |coll, selector, opts|
+    #     ...
+    #   end
+    #
+    # @return [ Object ] The result of the operation.
+    def prepare_atomic_operation
+      operations = yield({})
+      persist_or_delay_atomic_operation(operations)
+      self
+    end
+
+    # Process the atomic operations - this handles the common behavior of
+    # iterating through each op, getting the aliased field name, and removing
+    # appropriate dirty changes.
+    #
+    # @api private
+    #
+    # @example Process the atomic operations.
+    #   document.process_atomic_operations(pulls) do |field, value|
+    #     ...
+    #   end
+    #
+    # @param [ Hash ] operations The atomic operations.
+    #
+    # @return [ Hash ] The operations.
+    def process_atomic_operations(operations)
+      operations.each do |field, value|
+        access = database_field_name(field)
+        yield(access, value)
+        remove_change(access) unless executing_atomically?
+      end
+    end
+
+    # Remove the dirty changes for all fields changed in the current atomic
+    # context.
+    #
+    # @api private
+    #
+    # @example Remove the current atomic context's dirty changes.
+    #   document._mongoid_remove_atomic_context_changes
+    def _mongoid_remove_atomic_context_changes
+      return unless executing_atomically?
+      _mongoid_atomic_context_changed_fields.each { |f| remove_change f }
+    end
+
+    # Reset the attributes for all fields changed in the current atomic
+    # context.
+    #
+    # @api private
+    #
+    # @example Reset the current atomic context's changed attributes.
+    #   document._mongoid_reset_atomic_context_changes!
+    def _mongoid_reset_atomic_context_changes!
+      return unless executing_atomically?
+      _mongoid_atomic_context_changed_fields.each { |f| reset_attribute! f }
+    end
+
+    # Push a new atomic context onto the stack.
+    #
+    # @api private
+    #
+    # @example Push a new atomic context onto the stack.
+    #   document._mongoid_push_atomic_context
+    def _mongoid_push_atomic_context
+      return unless executing_atomically?
+      @atomic_context = {}
+      @atomic_updates_to_execute_stack << @atomic_context
+    end
+
+    # Pop an atomic context off the stack.
+    #
+    # @api private
+    #
+    # @example Pop an atomic context off the stack.
+    #   document._mongoid_pop_atomic_context
+    def _mongoid_pop_atomic_context
+      return unless executing_atomically?
+      @atomic_updates_to_execute_stack.pop
+      @atomic_context = @atomic_updates_to_execute_stack.last
+    end
+
+    # Return the current atomic context's changed fields.
+    #
+    # @api private
+    #
+    # @example Return the current atomic context's changed fields.
+    #   document._mongoid_atomic_context_changed_fields
+    #
+    # @return [ Array ] The changed fields.
+    def _mongoid_atomic_context_changed_fields
+      @atomic_context.values.flat_map(&:keys)
+    end
+
+    # If we are in an atomically block, add the operations to the delayed group,
+    # otherwise persist immediately.
+    #
+    # @api private
+    #
+    # @example Persist immediately or delay the operations.
+    #   document.persist_or_delay_atomic_operation(ops)
+    #
+    # @param [ Hash ] operation The operation.
+    def persist_or_delay_atomic_operation(operation)
+      if executing_atomically?
+        operation.each do |(name, hash)|
+          @atomic_context[name] ||= {}
+          @atomic_context[name].merge!(hash)
+        end
+      else
+        persist_atomic_operations(operation)
+      end
+    end
+
+    # Persist the atomic operations.
+    #
+    # @api private
+    #
+    # @example Persist the atomic operations.
+    #   persist_atomic_operations(ops)
+    #
+    # @param [ Hash ] operations The atomic operations.
+    def persist_atomic_operations(operations)
+      if persisted? && operations && !operations.empty?
+        selector = atomic_selector
+        _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
+      end
+    end
+  end
+end

data/lib/mongoid/persistence_context.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Object encapsulating logic for setting/getting a collection and database name
+  # and a client with particular options to use when persisting models.
+  class PersistenceContext
+    extend Forwardable
+
+    # Delegate the cluster method to the client.
+    def_delegators :client, :cluster
+
+    # Delegate the storage options method to the object.
+    def_delegators :@object, :storage_options
+
+    # The options defining this persistence context.
+    #
+    # @return [ Hash ] The persistence context options.
+    attr_reader :options
+
+    # Extra options in addition to driver client options that determine the
+    # persistence context.
+    #
+    # @return [ Array<Symbol> ] The list of extra options besides client options
+    #   that determine the persistence context.
+    EXTRA_OPTIONS = [ :client,
+                      :collection
+                    ].freeze
+
+    # The full list of valid persistence context options.
+    #
+    # @return [ Array<Symbol> ] The full list of options defining the persistence
+    #   context.
+    VALID_OPTIONS = ( Mongo::Client::VALID_OPTIONS + EXTRA_OPTIONS ).freeze
+
+    # Initialize the persistence context object.
+    #
+    # @example Create a new persistence context.
+    #   PersistenceContext.new(model, collection: 'other')
+    #
+    # @param [ Object ] object The class or model instance for which a persistence context
+    #   should be created.
+    # @param [ Hash ] opts The persistence context options.
+    def initialize(object, opts = {})
+      @object = object
+      set_options!(opts)
+    end
+
+    # Get the collection for this persistence context.
+    #
+    # @example Get the collection for this persistence context.
+    #   context.collection
+    #
+    # @param [ Object ] parent The parent object whose collection name is used
+    #   instead of this persistence context's collection name.
+    #
+    # @return [ Mongo::Collection ] The collection for this persistence
+    #   context.
+    def collection(parent = nil)
+      parent ?
+        parent.collection.with(client_options.except(:database, "database")) :
+        client[collection_name.to_sym]
+    end
+
+    # Get the collection name for this persistence context.
+    #
+    # @example Get the collection name for this persistence context.
+    #   context.collection_name
+    #
+    # @return [ String ] The collection name for this persistence
+    #  context.
+    def collection_name
+      @collection_name ||= (__evaluate__(options[:collection] ||
+                             storage_options[:collection]))
+    end
+
+    # Get the database name for this persistence context.
+    #
+    # @example Get the database name for this persistence context.
+    #   context.database_name
+    #
+    # @return [ String ] The database name for this persistence
+    #  context.
+    def database_name
+      __evaluate__(database_name_option) || client.database.name
+    end
+
+    # Get the client for this persistence context.
+    #
+    # @example Get the client for this persistence context.
+    #   context.client
+    #
+    # @return [ Mongo::Client ] The client for this persistence
+    #  context.
+    def client
+      @client ||= begin
+        client = Clients.with_name(client_name)
+        if database_name_option
+          client = client.use(database_name)
+        end
+        unless client_options.empty?
+          client = client.with(client_options)
+        end
+        client
+      end
+    end
+
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
+    # Determine if this persistence context is equal to another.
+    #
+    # @example Compare two persistence contexts.
+    #   context == other_context
+    #
+    # @param [ Object ] other The object to be compared with this one.
+    #
+    # @return [ true | false ] Whether the two persistence contexts are equal.
+    def ==(other)
+      return false unless other.is_a?(PersistenceContext)
+      options == other.options
+    end
+
+    # Whether the client of the context can be reused later, and therefore should
+    # not be closed.
+    #
+    # If the persistence context is requested with :client option only, it means
+    # that the context should use a client configured in mongoid.yml.
+    # Such clients should not be closed when the context is cleared since they
+    # will be reused later.
+    #
+    # @return [ true | false ] True if client can be reused, otherwise false.
+    #
+    # @api private
+    def reusable_client?
+      @options.keys == [:client]
+    end
+
+    private
+
+    def set_options!(opts)
+      @options ||= opts.each.reduce({}) do |_options, (key, value)|
+                     unless VALID_OPTIONS.include?(key.to_sym)
+                       raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS)
+                     end
+                     value ? _options.merge!(key => value) : _options
+                   end
+    end
+
+    def __evaluate__(name)
+      return nil unless name
+      name.respond_to?(:call) ? name.call.to_sym : name.to_sym
+    end
+
+    def client_options
+      @client_options ||= begin
+        opts = options.select do |k, v|
+                              Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
+                            end
+        if opts[:read].is_a?(Symbol)
+          opts[:read] = {mode: opts[:read]}
+        end
+        opts
+      end
+    end
+
+    def database_name_option
+      @database_name_option ||= options[:database] ||
+                                  Threaded.database_override ||
+                                  storage_options && storage_options[:database]
+    end
+
+    class << self
+
+      # Set the persistence context for a particular class or model instance.
+      #
+      # If there already is a persistence context set, options in the existing
+      # context are combined with options given to the set call.
+      #
+      # @example Set the persistence context for a class or model instance.
+      #  PersistenceContext.set(model)
+      #
+      # @param [ Object ] object The class or model instance.
+      # @param [ Hash | Mongoid::PersistenceContext ] options_or_context The persistence
+      #   options or a persistence context object.
+      #
+      # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
+      def set(object, options_or_context)
+        key = "[mongoid][#{object.object_id}]:context"
+        existing_context = Thread.current[key]
+        existing_options = if existing_context
+          existing_context.options
+        else
+          {}
+        end
+        if options_or_context.is_a?(PersistenceContext)
+          options_or_context = options_or_context.options
+        end
+        new_options = existing_options.merge(options_or_context)
+        context = PersistenceContext.new(object, new_options)
+        Thread.current[key] = context
+      end
+
+      # Get the persistence context for a particular class or model instance.
+      #
+      # @example Get the persistence context for a class or model instance.
+      #  PersistenceContext.get(model)
+      #
+      # @param [ Object ] object The class or model instance.
+      #
+      # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
+      def get(object)
+        Thread.current["[mongoid][#{object.object_id}]:context"]
+      end
+
+      # Clear the persistence context for a particular class or model instance.
+      #
+      # @example Clear the persistence context for a class or model instance.
+      #  PersistenceContext.clear(model)
+      #
+      # @param [ Class | Object ] object The class or model instance.
+      # @param [ Mongo::Cluster ] cluster The original cluster before this context was used.
+      # @param [ Mongoid::PersistenceContext ] original_context The original persistence
+      #   context that was set before this context was used.
+      def clear(object, cluster = nil, original_context = nil)
+        if context = get(object)
+          unless cluster.nil? || context.cluster.equal?(cluster)
+            context.client.close unless context.reusable_client?
+          end
+        end
+      ensure
+        Thread.current["[mongoid][#{object.object_id}]:context"] = original_context
+      end
+    end
+  end
+end

data/lib/mongoid/positional.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module is responsible for taking update selectors and switching out
+  # the indexes for the $ positional operator where appropriate.
+  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.
+    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 index with $ only if that key is in the selector and it is only
+      # nested a single level deep.
+      matches = position.scan(/\.\d+\./)
+      if matches.size == 1
+        keys.each do |kk|
+          if position =~ /\A#{kk}\.\d+\.(.*)\z/
+            return "#{kk}.$.#{$1}"
+          end
+        end
+      end
+      position
+    end
+  end
+end

data/lib/mongoid/query_cache.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # A cache of database queries on a per-request basis.
+  module QueryCache
+
+    class << self
+
+      # Clear the query cache.
+      #
+      # @example Clear the cache.
+      #   QueryCache.clear_cache
+      #
+      # @return [ nil ] Always nil.
+      def clear_cache
+        Mongo::QueryCache.clear
+      end
+
+      # Set whether the cache is enabled.
+      #
+      # @example Set if the cache is enabled.
+      #   QueryCache.enabled = true
+      #
+      # @param [ true | false ] value The enabled value.
+      def enabled=(value)
+        Mongo::QueryCache.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.
+      def enabled?
+        Mongo::QueryCache.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.
+      def cache(&block)
+        Mongo::QueryCache.cache(&block)
+      end
+
+      # Execute the block with the query cache disabled.
+      #
+      # @example Execute without the cache.
+      #   QueryCache.uncached { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      def uncached(&block)
+        Mongo::QueryCache.uncached(&block)
+      end
+    end
+
+    Middleware = Mongo::QueryCache::Middleware
+  end
+end
+