mongoid 7.5.2 → 8.0.1

data/lib/mongoid/query_cache.rb

@@ -4,28 +4,8 @@ module Mongoid
 
   # A cache of database queries on a per-request basis.
   module QueryCache
-    # @api private
-    LEGACY_WARNING = <<~DOC
-      You are using the legacy Mongoid query cache which has known issues.
-      Please upgrade the `mongo' gem to at least 2.14.0 to use the improved driver query cache.
-      Refer to: https://docs.mongodb.com/mongoid/current/tutorials/mongoid-queries/#the-improved-driver-query-cache
-    DOC
 
     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.
-      # @api private
-      def cache_table
-        if defined?(Mongo::QueryCache)
-          raise NotImplementedError, "Mongoid does not expose driver's query cache table"
-        else
-          Thread.current["[mongoid]:query_cache"] ||= {}
-        end
-      end
 
       # Clear the query cache.
       #
@@ -34,11 +14,7 @@ module Mongoid
       #
       # @return [ nil ] Always nil.
       def clear_cache
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.clear
-        else
-          Thread.current["[mongoid]:query_cache"] = nil
-        end
+        Mongo::QueryCache.clear
       end
 
       # Set whether the cache is enabled.
@@ -48,11 +24,7 @@ module Mongoid
       #
       # @param [ true, false ] value The enabled value.
       def enabled=(value)
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.enabled = value
-        else
-          Thread.current["[mongoid]:query_cache:enabled"] = value
-        end
+        Mongo::QueryCache.enabled = value
       end
 
       # Is the query cache enabled on the current thread?
@@ -62,11 +34,7 @@ module Mongoid
       #
       # @return [ true, false ] If the cache is enabled.
       def enabled?
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.enabled?
-        else
-          !!Thread.current["[mongoid]:query_cache:enabled"]
-        end
+        Mongo::QueryCache.enabled?
       end
 
       # Execute the block while using the query cache.
@@ -76,21 +44,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def cache(&block)
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.cache(&block)
-        else
-          @legacy_query_cache_warned ||= begin
-            Mongoid.logger.warn(LEGACY_WARNING)
-            true
-          end
-          enabled = QueryCache.enabled?
-          QueryCache.enabled = true
-          begin
-            yield
-          ensure
-            QueryCache.enabled = enabled
-          end
-        end
+        Mongo::QueryCache.cache(&block)
       end
 
       # Execute the block with the query cache disabled.
@@ -100,217 +54,11 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def uncached(&block)
-        if defined?(Mongo::QueryCache)
-          Mongo::QueryCache.uncached(&block)
-        else
-          enabled = QueryCache.enabled?
-          QueryCache.enabled = false
-          begin
-            yield
-          ensure
-            QueryCache.enabled = enabled
-          end
-        end
-      end
-    end
-
-    if defined?(Mongo::QueryCache::Middleware)
-      Middleware = Mongo::QueryCache::Middleware
-    else
-      # The middleware to be added to a rack application in order to activate the
-      # query cache.
-      class Middleware
-
-        # Instantiate the middleware.
-        #
-        # @example Create the new middleware.
-        #   Middleware.new(app)
-        #
-        # @param [ Object ] app The rack application stack.
-        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.
-        def call(env)
-          QueryCache.cache do
-            @app.call(env)
-          end
-        ensure
-          QueryCache.clear_cache
-        end
-      end
-    end
-
-    # A Cursor that attempts to load documents from memory first before hitting
-    # the database if the same query has already been executed.
-    # @deprecated This class is only used with driver versions 2.13 and lower.
-    class CachedCursor < Mongo::Cursor
-
-      # We iterate over the cached documents if they exist already in the
-      # cursor otherwise proceed as normal.
-      #
-      # @example Iterate over the documents.
-      #   cursor.each do |doc|
-      #     # ...
-      #   end
-      def each
-        if @cached_documents
-          @cached_documents.each do |doc|
-            yield doc
-          end
-        else
-          super
-        end
-      end
-
-      # Get a human-readable string representation of +Cursor+.
-      #
-      # @example Inspect the cursor.
-      #   cursor.inspect
-      #
-      # @return [ String ] A string representation of a +Cursor+ instance.
-      def inspect
-        "#<Mongoid::QueryCache::CachedCursor:0x#{object_id} @view=#{@view.inspect}>"
-      end
-
-      private
-
-      def process(result)
-        documents = super
-        if @cursor_id.zero? && !@after_first_batch
-          @cached_documents ||= []
-          @cached_documents.concat(documents)
-        end
-        @after_first_batch = true
-        documents
-      end
-    end
-
-    # Included to add behavior for clearing out the query cache on certain
-    # operations.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module Base
-
-      def alias_query_cache_clear(*method_names)
-        method_names.each do |method_name|
-          define_method("#{method_name}_with_clear_cache") do |*args|
-            QueryCache.clear_cache
-            send("#{method_name}_without_clear_cache", *args)
-          end
-
-          alias_method "#{method_name}_without_clear_cache", method_name
-          alias_method method_name, "#{method_name}_with_clear_cache"
-        end
+        Mongo::QueryCache.uncached(&block)
       end
     end
 
-    # Contains enhancements to the Mongo::Collection::View in order to get a
-    # cached cursor or a regular cursor on iteration.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module View
-      extend ActiveSupport::Concern
-
-      included do
-        extend QueryCache::Base
-        alias_query_cache_clear :delete_one,
-                                :delete_many,
-                                :update_one,
-                                :update_many,
-                                :replace_one,
-                                :find_one_and_delete,
-                                :find_one_and_replace,
-                                :find_one_and_update
-      end
-
-      # Override the default enumeration to handle if the cursor can be cached
-      # or not.
-      #
-      # @example Iterate over the view.
-      #   view.each do |doc|
-      #     # ...
-      #   end
-      def each
-        if system_collection? || !QueryCache.enabled? || (respond_to?(:write?, true) && write?)
-          super
-        else
-          @cursor = nil
-          unless @cursor = cached_cursor
-            session = client.send(:get_session, @options)
-            read_with_retry(session, server_selector) do |server|
-              result = send_initial_query(server, session)
-              if result.cursor_id == 0 || result.cursor_id.nil?
-                @cursor = CachedCursor.new(view, result, server, session: session)
-                QueryCache.cache_table[cache_key] = @cursor
-              else
-                @cursor = Mongo::Cursor.new(view, result, server, session: session)
-              end
-            end
-          end
-          if block_given?
-            if limit
-              @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
-        end
-      end
-
-      private
-
-      def cached_cursor
-        if limit
-          key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
-          cursor = QueryCache.cache_table[key]
-        end
-        cursor || QueryCache.cache_table[cache_key]
-      end
-
-      def cache_key
-        [ collection.namespace, selector, limit, skip, sort, projection, collation ]
-      end
-
-      def system_collection?
-        collection.name.start_with?('system.')
-      end
-    end
-
-    # Adds behavior to the query cache for collections.
-    # @deprecated This module is only used with driver versions 2.13 and lower.
-    module Collection
-      extend ActiveSupport::Concern
-
-      included do
-        extend QueryCache::Base
-        alias_query_cache_clear :insert_one, :insert_many
-      end
-    end
-
-    # Bypass the query cache when reloading a document.
-    module Document
-      def reload
-        QueryCache.uncached { super }
-      end
-    end
+    Middleware = Mongo::QueryCache::Middleware
   end
 end
 
-unless defined?(Mongo::QueryCache)
-  Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
-  Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
-  Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
-end

data/lib/mongoid/railties/controller_runtime.rb

@@ -62,7 +62,7 @@ module Mongoid
         def started _; end
 
         def _completed e
-          Collector.runtime += e.duration
+          Collector.runtime += e.duration * 1000
         end
         alias :succeeded :_completed
         alias :failed :_completed

data/lib/mongoid/reloadable.rb

@@ -23,11 +23,15 @@ module Mongoid
 
       reloaded = _reload
       if Mongoid.raise_not_found_error && (reloaded.nil? || reloaded.empty?)
-        raise Errors::DocumentNotFound.new(self.class, _id, _id)
+        shard_keys = atomic_selector.with_indifferent_access.slice(*shard_key_fields, :_id)
+        raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
       end
       @attributes = reloaded
-      @attributes_before_type_cast = {}
-      changed_attributes.clear
+      @attributes_before_type_cast = @attributes.dup
+      @changed_attributes = {}
+      @previous_changes = {}
+      @previous_attributes = {}
+      @previously_new_record = false
       reset_readonly
       apply_defaults
       reload_relations

data/lib/mongoid/scopable.rb

@@ -289,17 +289,15 @@ module Mongoid
       # @return [ Method ] The defined method.
       def define_scope_method(name)
         singleton_class.class_eval do
-          ruby2_keywords(
-            define_method(name) do |*args|
-              scoping = _declared_scopes[name]
-              scope = instance_exec(*args, &scoping[:scope])
-              extension = scoping[:extension]
-              to_merge = scope || queryable
-              criteria = to_merge.empty_and_chainable? ? to_merge : with_default_scope.merge(to_merge)
-              criteria.extend(extension)
-              criteria
-            end
-          )
+          define_method(name) do |*args|
+            scoping = _declared_scopes[name]
+            scope = instance_exec(*args, &scoping[:scope])
+            extension = scoping[:extension]
+            to_merge = scope || queryable
+            criteria = to_merge.empty_and_chainable? ? to_merge : with_default_scope.merge(to_merge)
+            criteria.extend(extension)
+            criteria
+          end
         end
       end
 

data/lib/mongoid/selectable.rb

@@ -15,8 +15,7 @@ module Mongoid
     #
     # @return [ Hash ] The document's selector.
     def atomic_selector
-      @atomic_selector ||=
-        (embedded? ? embedded_atomic_selector : root_atomic_selector_in_db)
+      embedded? ? embedded_atomic_selector : root_atomic_selector_in_db
     end
 
     private

data/lib/mongoid/stateful.rb

@@ -6,7 +6,15 @@ module Mongoid
   # document can transition through.
   module Stateful
 
-    attr_writer :destroyed, :flagged_for_destroy, :new_record
+    attr_writer :destroyed, :flagged_for_destroy, :previously_new_record
+
+    def new_record=(new_value)
+      @new_record ||= false
+      if @new_record && !new_value
+        @previously_new_record = true
+      end
+      @new_record = new_value
+    end
 
     # Returns true if the +Document+ has not been persisted to the database,
     # false if it has. This is determined by the variable @new_record
@@ -20,6 +28,15 @@ module Mongoid
       @new_record ||= false
     end
 
+    # Returns true if this document was just created -- that is, prior to the last
+    # save, the object didn't exist in the database and new_record? would have
+    # returned true.
+    #
+    # @return [ true, false ] True if was just created, false if not.
+    def previously_new_record?
+      @previously_new_record ||= false
+    end
+
     # Checks if the document has been saved to the database. Returns false
     # if the document has been destroyed.
     #
@@ -31,6 +48,15 @@ module Mongoid
       !new_record? && !destroyed?
     end
 
+    # Checks if the document was previously saved to the database
+    # but now it has been deleted.
+    #
+    # @return [ true, false ] True if was persisted but now destroyed,
+    #   otherwise false.
+    def previously_persisted?
+      !new_record? && destroyed?
+    end
+
     # Returns whether or not the document has been flagged for deletion, but
     # not destroyed yet. Used for atomic pulls of child documents.
     #

data/lib/mongoid/timestamps/created.rb

@@ -23,7 +23,7 @@ module Mongoid
       #   person.set_created_at
       def set_created_at
         if !timeless? && !created_at
-          time = Time.now.utc
+          time = Time.configured.now
           self.updated_at = time if is_a?(Updated) && !updated_at_changed?
           self.created_at = time
         end

data/lib/mongoid/timestamps/updated.rb

@@ -24,7 +24,7 @@ module Mongoid
       #   person.set_updated_at
       def set_updated_at
         if able_to_set_updated_at?
-          self.updated_at = Time.now.utc unless updated_at_changed?
+          self.updated_at = Time.configured.now unless updated_at_changed?
         end
 
         clear_timeless_option

data/lib/mongoid/touchable.rb

@@ -19,10 +19,10 @@ module Mongoid
       #
       # @param [ Symbol ] field The name of an additional field to update.
       #
-      # @return [ true/false ] false if record is new_record otherwise true.
+      # @return [ true/false ] false if document is new_record otherwise true.
       def touch(field = nil)
         return false if _root.new_record?
-        current = Time.now
+        current = Time.configured.now
         field = database_field_name(field)
         write_attribute(:updated_at, current) if respond_to?("updated_at=")
         write_attribute(field, current) if field
@@ -60,7 +60,6 @@ module Mongoid
 
         # Callbacks are invoked on the composition root first and on the
         # leaf-most embedded document last.
-        # TODO add tests, see MONGOID-5015.
         run_callbacks(:touch)
         true
       end

data/lib/mongoid/traversable.rb

@@ -233,6 +233,7 @@ module Mongoid
     def remove_child(child)
       name = child.association_name
       if child.embedded_one?
+        self.attributes.delete(child._association.store_as)
         remove_ivar(name)
       else
         relation = send(name)

data/lib/mongoid/validatable/uniqueness.rb

@@ -16,7 +16,7 @@ module Mongoid
     #   end
     #
     # It is also possible to limit the uniqueness constraint to a set of
-    # records matching certain conditions:
+    # documents matching certain conditions:
     #   class Person
     #     include Mongoid::Document
     #     field :title
@@ -242,6 +242,7 @@ module Mongoid
         relation = document._parent.send(document.association_name)
         criteria = create_criteria(relation, document, attribute, value)
         criteria = criteria.merge(options[:conditions].call) if options[:conditions]
+        criteria = criteria.limit(2)
         add_error(document, attribute, value) if criteria.count > 1
       end
 

data/lib/mongoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mongoid
-  VERSION = "7.5.2"
+  VERSION = "8.0.1"
 end

data/lib/mongoid/warnings.rb

@@ -21,9 +21,8 @@ module Mongoid
       end
     end
 
-    warning :id_sort_deprecated, 'The :id_sort option has been deprecated. Use Mongo#take to get a document without a sort on _id.'
-    warning :criteria_cache_deprecated, 'The criteria cache has been deprecated and will be removed in Mongoid 8. Please enable the Mongoid QueryCache to have caching functionality.'
-    warning :map_field_deprecated, 'The field argument to the Mongo#map method has been deprecated, please pass in a block instead. Support will be dropped in Mongoid 8.'
+    warning :geo_haystack_deprecated, 'The geoHaystack type is deprecated.'
+    warning :as_json_compact_deprecated, '#as_json :compact option is deprecated. Please call #compact on the returned Hash object instead.'
+    warning :symbol_type_deprecated, 'The BSON Symbol type is deprecated by MongoDB. Please use String or StringifiedSymbol field types instead of the Symbol field type'
   end
 end
-

data/lib/mongoid.rb

@@ -16,6 +16,7 @@ require "mongo"
 require 'mongo/active_support'
 
 require "mongoid/version"
+require "mongoid/deprecable"
 require "mongoid/config"
 require "mongoid/persistence_context"
 require "mongoid/loggable"

data/spec/config/mongoid.yml

@@ -40,6 +40,22 @@ test:
     app_name: 'testing'
     background_indexing: false
     join_contexts: false
+  driver_options:
+    broken_view_options: false
+    # Don't set validate_update_replace here, as it is used to check if the
+    # default driver options are kept in Mongoid.
+test_nil:
+  clients:
+    default:
+      database: mongoid_test
+      hosts:
+        <% SpecConfig.instance.addresses.each do |address| %>
+          - <%= address %>
+        <% end %>
+  driver_options:
+    broken_view_options:
+    validate_update_replace: false
+
 test_with_max_staleness:
   clients:
     default:

data/spec/integration/app_spec.rb

@@ -163,6 +163,14 @@ describe 'Mongoid application tests' do
               before do
                 Dir.chdir(APP_PATH) do
                   remove_bundler_req
+
+                  if BSON::Environment.jruby?
+                    # Remove existing Gemfile.lock - see
+                    # https://github.com/rubygems/rubygems/issues/3231
+                    require 'fileutils'
+                    FileUtils.rm_f('Gemfile.lock')
+                  end
+
                   check_call(%w(bundle install), env: env)
                   write_mongoid_yml
                 end
@@ -287,18 +295,6 @@ describe 'Mongoid application tests' do
         f << lines.join
       end
     end
-
-    if rails_version == '5.1'
-      secrets = {
-        'development' => {
-          'secret_key_base' => 'abracadabra',
-          'my_secret_token' => 'very_secret',
-        },
-      }
-      File.open('config/secrets.yml', 'w') do |f|
-        f << YAML.dump(secrets)
-      end
-    end
   end
 
   def remove_bundler_req

data/spec/integration/associations/belongs_to_spec.rb

@@ -12,4 +12,22 @@ describe 'belongs_to associations' do
       expect(child).to be_valid
     end
   end
+
+  context 'when an anonymous class defines a belongs_to association' do
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+        belongs_to :movie
+      end
+    end
+
+    it 'loads the association correctly' do
+      expect { klass }.to_not raise_error
+      expect { klass.new.movie }.to_not raise_error
+      instance = klass.new
+      movie = Movie.new
+      instance.movie = movie
+      expect(instance.movie).to eq movie
+    end
+  end
 end

data/spec/integration/associations/embedded_spec.rb

@@ -265,4 +265,19 @@ describe 'embedded associations' do
       end
     end
   end
+
+  context "when summing properties on an embedded child" do
+    let(:user) { EmmUser.new }
+    before do
+      user.orders.build(amount: 200)
+      expect(user.orders.sum(:amount)).to eq(200)
+
+      user.orders.delete_all
+      user.orders.build(amount: 500)
+    end
+
+    it "the cache is cleared after deletion" do
+      expect(user.orders.sum(:amount)).to eq(500)
+    end
+  end
 end

data/spec/integration/associations/embeds_many_spec.rb

@@ -172,8 +172,6 @@ describe 'embeds_many associations' do
           # Mongoid uses the new value of `x` in the $pullAll query,
           # which doesn't match the document that is in the database,
           # resulting in the empty array assignment not taking effect.
-          pending 'MONGOID-5037'
-
           canvas.shapes.first.x = 1
           canvas.shapes = []
           canvas.save!
@@ -203,4 +201,19 @@ describe 'embeds_many associations' do
       end
     end
   end
+
+  context 'when an anonymous class defines an embeds_many association' do
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+        embeds_many :addresses
+      end
+    end
+
+    it 'loads the association correctly' do
+      expect { klass }.to_not raise_error
+      expect { klass.new.addresses }.to_not raise_error
+      expect(klass.new.addresses.build).to be_a Address
+    end
+  end
 end

data/spec/integration/associations/embeds_one_spec.rb

@@ -20,4 +20,22 @@ describe 'embeds_one associations' do
       end
     end
   end
+
+  context 'when an anonymous class defines an embeds_one association' do
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+        embeds_one :address
+      end
+    end
+
+    it 'loads the association correctly' do
+      expect { klass }.to_not raise_error
+      expect { klass.new.address }.to_not raise_error
+      instance = klass.new
+      address = Address.new
+      instance.address = address
+      expect(instance.address).to eq address
+    end
+  end
 end