mongoid 5.4.0 → 6.4.8

data/lib/mongoid/matchable/or.rb

@@ -8,20 +8,20 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher.matches?("$or" => [ { field => value } ])
+      #   matcher._matches?("$or" => [ { field => value } ])
       #
       # @param [ Array ] conditions The or expression.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 2.0.0.rc.7
-      def matches?(conditions)
+      def _matches?(conditions)
         conditions.each do |condition|
           res = true
           condition.keys.each do |k|
             key = k
             value = condition[k]
-            res &&= document.matches?(key => value)
+            res &&= document._matches?(key => value)
             break unless res
           end
           return res if res

data/lib/mongoid/matchable/regexp.rb

@@ -7,15 +7,15 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher.matches?(/^Em/)
-      #   matcher.matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/^Em/)
+      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #
       # @return [ true, false ] True if matches, false if not.
       #
       # @since 5.2.1
-      def matches?(regexp)
+      def _matches?(regexp)
         if native_regexp = regexp.try(:compile)
           super(native_regexp)
         else

data/lib/mongoid/matchable/size.rb

@@ -8,12 +8,12 @@ module Mongoid
       # Return true if the attribute size is equal to the first value.
       #
       # @example Do the values match?
-      #   matcher.matches?({ :key => 10 })
+      #   matcher._matches?({ :key => 10 })
       #
       # @param [ Hash ] value The values to check.
       #
       # @return [ true, false ] If a value exists.
-      def matches?(value)
+      def _matches?(value)
         @attribute.size == value.values.first
       end
     end

data/lib/mongoid/matchable.rb

@@ -11,7 +11,9 @@ require "mongoid/matchable/lte"
 require "mongoid/matchable/ne"
 require "mongoid/matchable/nin"
 require "mongoid/matchable/or"
+require "mongoid/matchable/nor"
 require "mongoid/matchable/size"
+require "mongoid/matchable/elem_match"
 require "mongoid/matchable/regexp"
 
 module Mongoid
@@ -28,6 +30,7 @@ module Mongoid
     # @since 1.0.0
     MATCHERS = {
       "$all" => All,
+      "$elemMatch" => ElemMatch,
       "$and" => And,
       "$exists" => Exists,
       "$gt" => Gt,
@@ -38,6 +41,7 @@ module Mongoid
       "$ne" => Ne,
       "$nin" => Nin,
       "$or" => Or,
+      "$nor" => Nor,
       "$size" => Size
     }.with_indifferent_access.freeze
 
@@ -45,26 +49,26 @@ module Mongoid
     # MongoDB selector. Used for matching on embedded associations.
     #
     # @example Does the document match?
-    #   document.matches?(:title => { "$in" => [ "test" ] })
+    #   document._matches?(:title => { "$in" => [ "test" ] })
     #
     # @param [ Hash ] selector The MongoDB selector.
     #
     # @return [ true, false ] True if matches, false if not.
     #
     # @since 1.0.0
-    def matches?(selector)
+    def _matches?(selector)
       selector.each_pair do |key, value|
         if value.is_a?(Hash)
           value.each do |item|
             if item[0].to_s == "$not".freeze
               item = item[1]
-              return false if matcher(self, key, item).matches?(item)
+              return false if matcher(self, key, item)._matches?(item)
             else
-              return false unless matcher(self, key, Hash[*item]).matches?(Hash[*item])
+              return false unless matcher(self, key, Hash[*item])._matches?(Hash[*item])
             end
           end
         else
-          return false unless matcher(self, key, value).matches?(value)
+          return false unless matcher(self, key, value)._matches?(value)
         end
       end
       true
@@ -122,6 +126,7 @@ module Mongoid
           case key.to_s
             when "$or" then Or.new(value, document)
             when "$and" then And.new(value, document)
+            when "$nor" then Nor.new(value, document)
             else Default.new(extract_attribute(document, key))
           end
         end
@@ -144,7 +149,7 @@ module Mongoid
       # @since 2.2.1
       def extract_attribute(document, key)
         if (key_string = key.to_s) =~ /.+\..+/
-          key_string.split('.').inject(document.as_document) do |_attribs, _key|
+          key_string.split('.').inject(document.send(:as_attributes)) do |_attribs, _key|
             if _attribs.is_a?(::Array)
               if _key =~ /\A\d+\z/ && _attribs.none? {|doc| doc.is_a?(Hash)}
                 _attribs.try(:[], _key.to_i)
@@ -156,7 +161,11 @@ module Mongoid
             end
           end
         else
-          document.attributes[key_string]
+          if document.is_a?(Hash)
+            document[key_string]
+          else
+            document.attributes[key_string]
+          end
         end
       end
     end

data/lib/mongoid/persistable/creatable.rb

@@ -42,7 +42,7 @@ module Mongoid
       #
       # @since 2.1.0
       def atomic_inserts
-        { atomic_insert_modifier => { atomic_position => as_document }}
+        { atomic_insert_modifier => { atomic_position => as_attributes }}
       end
 
       # Insert the embedded document.
@@ -61,7 +61,9 @@ module Mongoid
           _parent.insert
         else
           selector = _parent.atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, atomic_inserts))
+          _root.collection.find(selector).update_one(
+              positionally(selector, atomic_inserts),
+              session: _session)
         end
       end
 
@@ -76,7 +78,7 @@ module Mongoid
       #
       # @since 4.0.0
       def insert_as_root
-        collection.insert_one(as_document)
+        collection.insert_one(as_attributes, session: _session)
       end
 
       # Post process an insert, which sets the new record attribute to false

data/lib/mongoid/persistable/deletable.rb

@@ -62,7 +62,9 @@ module Mongoid
         _parent.remove_child(self) if notifying_parent?(options)
         if _parent.persisted?
           selector = _parent.atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, atomic_deletes))
+          _root.collection.find(selector).update_one(
+              positionally(selector, atomic_deletes),
+              session: _session)
         end
         true
       end
@@ -78,7 +80,7 @@ module Mongoid
       #
       # @since 4.0.0
       def delete_as_root
-        collection.find(atomic_selector).delete_one
+        collection.find(atomic_selector).delete_one(session: _session)
         true
       end
 
@@ -137,7 +139,7 @@ module Mongoid
         # @since 1.0.0
         def delete_all(conditions = {})
           selector = hereditary? ? conditions.merge(_type: name) : conditions
-          collection.find(selector).delete_many.deleted_count
+          where(selector).delete
         end
       end
     end

data/lib/mongoid/persistable/destroyable.rb

@@ -48,11 +48,7 @@ module Mongoid
         #
         # @since 1.0.0
         def destroy_all(conditions = nil)
-          selector = conditions || {}
-          documents = where(selector)
-          destroyed = documents.count
-          documents.each { |doc| doc.destroy }
-          destroyed
+          where(conditions || {}).destroy
         end
       end
     end

data/lib/mongoid/persistable/settable.rb

@@ -25,15 +25,15 @@ module Mongoid
 
             field_and_value_hash = hasherizer(field.split('.'), value)
             field = field_and_value_hash.keys.first.to_s
+            value = field_and_value_hash[field]
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field)
+            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
               merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = attributes[field].merge(field_and_value_hash[field], &merger)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[field])
+              value = (attributes[field] || {}).merge(value, &merger)
             end
 
+            process_attribute(field.to_s, value)
+
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
             end

data/lib/mongoid/persistable/updatable.rb

@@ -24,17 +24,11 @@ module Mongoid
       #
       # @since 2.0.0
       def update_attribute(name, value)
-        normalized = name.to_s
-        unless attribute_writable?(normalized)
-          raise Errors::ReadonlyAttribute.new(normalized, value)
+        as_writable_attribute!(name, value) do |access|
+          normalized = name.to_s
+          process_attribute(normalized, value)
+          save(validate: false)
         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.
@@ -135,15 +129,14 @@ module Mongoid
       #
       # @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
+            coll = collection(_root)
             selector = atomic_selector
-            coll.find(selector).update_one(positionally(selector, updates))
+            coll.find(selector).update_one(positionally(selector, updates), session: _session)
             conflicts.each_pair do |key, value|
-              coll.find(selector).update_one(positionally(selector, { key => value }))
+              coll.find(selector).update_one(positionally(selector, { key => value }), session: _session)
             end
           end
         end

data/lib/mongoid/persistable/upsertable.rb

@@ -21,7 +21,8 @@ module Mongoid
       # @since 3.0.0
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).update_one(as_document, upsert: true)
+          collection.find(atomic_selector).update_one(
+              as_attributes, upsert: true, session: _session)
         end
       end
 

data/lib/mongoid/persistable.rb

@@ -162,12 +162,10 @@ module Mongoid
     # @since 4.0.0
     def process_atomic_operations(operations)
       operations.each do |field, value|
-        unless attribute_writable?(field)
-          raise Errors::ReadonlyAttribute.new(field, value)
+        as_writable_attribute!(field, value) do |access|
+          yield(access, value)
+          remove_change(access)
         end
-        normalized = database_field_name(field)
-        yield(normalized, value)
-        remove_change(normalized)
       end
     end
 
@@ -206,7 +204,7 @@ module Mongoid
     def persist_atomic_operations(operations)
       if persisted? && operations
         selector = atomic_selector
-        _root.collection.find(selector).update_one(positionally(selector, operations))
+        _root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
       end
     end
   end

data/lib/mongoid/persistence_context.rb

@@ -0,0 +1,220 @@
+module Mongoid
+
+  # Object encapsulating logic for setting/getting a collection and database name
+  # and a client with particular options to use when persisting models.
+  #
+  # @since 6.0.0
+  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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    def collection(parent = nil)
+      parent ? parent.collection.with(client_options) : 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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    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.
+    #
+    # @since 6.0.0
+    def client
+      client_options = send(:client_options)
+      if client_options[:read].is_a?(Symbol)
+        client_options = client_options.merge(read: {mode: client_options[:read]})
+      end
+      @client ||= (client = Clients.with_name(client_name)
+                    client = client.use(database_name) if database_name_option
+                    client.with(client_options))
+    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.
+    #
+    # @since 6.0.0
+    def ==(other)
+      return false unless other.is_a?(PersistenceContext)
+      options == other.options
+    end
+
+    private
+
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
+    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 ||= options.select do |k, v|
+                            Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
+                          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.
+      #
+      # @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.
+      #
+      # @since 6.0.0
+      def set(object, options_or_context)
+        context = PersistenceContext.new(object, options_or_context.is_a?(PersistenceContext) ?
+                                                   options_or_context.options : options_or_context)
+        Thread.current["[mongoid][#{object.object_id}]:context"] = 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.
+      #
+      # @since 6.0.0
+      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.
+      #
+      # @since 6.0.0
+      def clear(object, cluster = nil)
+        if context = get(object)
+          context.client.close unless (context.cluster.equal?(cluster) || cluster.nil?)
+        end
+      ensure
+        Thread.current["[mongoid][#{object.object_id}]:context"] = nil
+      end
+    end
+  end
+end

data/lib/mongoid/query_cache.rb

@@ -159,11 +159,14 @@ module Mongoid
       private
 
       def process(result)
-        @remaining -= result.returned_count if limited?
-        @cursor_id = result.cursor_id
-        @coll_name ||= result.namespace.sub("#{database.name}.", '') if result.namespace
-        documents = result.documents
-        (@cached_documents ||= []).concat(documents)
+        documents = super
+
+        if @cursor_id.zero? && !@after_first_batch
+          @cached_documents ||= []
+          @cached_documents.concat(documents)
+        end
+
+        @after_first_batch = true
         documents
       end
     end
@@ -183,7 +186,8 @@ module Mongoid
               end
             CODE
 
-          alias_method_chain method_name, :clear_cache
+          alias_method "#{method_name}_without_clear_cache", method_name
+          alias_method method_name, "#{method_name}_with_clear_cache"
         end
       end
     end
@@ -217,39 +221,73 @@ module Mongoid
       #
       # @since 5.0.0
       def each
-        if system_collection? || !QueryCache.enabled?
+        if system_collection? || !QueryCache.enabled? || (respond_to?(:write?, true) && write?)
           super
         else
-          unless cursor = cached_cursor
-            server = read_or_server_selector.select_server(cluster)
-            cursor = CachedCursor.new(view, send_initial_query(server), server)
-            QueryCache.cache_table[cache_key] = cursor
+          @cursor = nil
+          unless @cursor = cached_cursor
+
+            if driver_supports_cursor_sessions?
+              session = client.send(:get_session, @options)
+              read_with_retry(session, server_selector) do |server|
+                result = send_initial_query(server, session)
+                @cursor = get_cursor(result, server, session)
+              end
+            else
+              read_with_retry do
+                server = server_selector.select_server(cluster)
+                result = send_initial_query(server)
+                @cursor = get_cursor(result, server)
+              end
+            end
+          end
+
+          if block_given?
+            if limit && limit != -1
+              @cursor.to_a[0...limit].each do |doc|
+                yield doc
+              end
+            else
+              @cursor.each do |doc|
+                yield doc
+              end
+            end
+          else
+            @cursor.to_enum
           end
-          cursor.each do |doc|
-            yield doc
-          end if block_given?
-          cursor
         end
       end
 
       private
 
-      def read_or_server_selector
-        respond_to?(:server_selector, true) ? server_selector : read
-      end
-
       def cached_cursor
         if limit
           key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
           cursor = QueryCache.cache_table[key]
-          if cursor
-            limited_docs = cursor.to_a[0...limit.abs]
-            cursor.instance_variable_set(:@cached_documents, limited_docs)
-          end
         end
         cursor || QueryCache.cache_table[cache_key]
       end
 
+      def get_cursor(result, server, session = nil)
+        if result.cursor_id == 0 || result.cursor_id.nil?
+          cursor = if session
+            CachedCursor.new(view, result, server, session: session)
+          else
+            CachedCursor.new(view, result, server)
+          end
+
+          QueryCache.cache_table[cache_key] = cursor
+        else
+          cursor = if session
+            Mongo::Cursor.new(view, result, server, session: session)
+          else
+            Mongo::Cursor.new(view, result, server)
+          end
+        end
+
+        cursor
+      end
+
       def cache_key
         [ collection.namespace, selector, limit, skip, sort, projection, collation ]
       end
@@ -257,6 +295,12 @@ module Mongoid
       def system_collection?
         collection.namespace =~ /^system./
       end
+
+      def driver_supports_cursor_sessions?
+        # Driver versions 2.9 and newer support passing in a session to the
+        # cursor object.
+        (Mongo::VERSION.split('.').map(&:to_i) <=> [2, 9, 0]) > 0
+      end
     end
 
     # Adds behaviour to the query cache for collections.