mongoid 7.6.2 → 8.0.1

data/lib/mongoid/config.rb

@@ -75,114 +75,55 @@ module Mongoid
     # Return stored times as UTC.
     option :use_utc, default: false
 
+    # Store BigDecimals as Decimal128s instead of strings in the db.
+    option :map_big_decimal_to_decimal128, default: true
+
     # Update embedded documents correctly when setting it, unsetting it
     # and resetting it. See MONGOID-5206 and MONGOID-5240 for more details.
-    option :broken_updates, default: true
+    option :broken_updates, default: false
 
     # Maintain legacy behavior of === on Mongoid documents, which returns
     # true in a number of cases where Ruby's === implementation would
     # return false.
-    option :legacy_triple_equals, default: true
+    option :legacy_triple_equals, default: false
 
     # When exiting a nested `with_scope' block, set the current scope to
     # nil instead of the parent scope for backwards compatibility.
-    option :broken_scoping, default: true
+    option :broken_scoping, default: false
 
     # Maintain broken behavior of sum over empty result sets for backwards
     # compatibility.
-    option :broken_aggregables, default: true
+    option :broken_aggregables, default: false
 
     # Ignore aliased fields in embedded documents when performing pluck and
     # distinct operations, for backwards compatibility.
-    option :broken_alias_handling, default: true
+    option :broken_alias_handling, default: false
 
     # Maintain broken `and' behavior when using the same operator on the same
     # field multiple times for backwards compatibility.
-    option :broken_and, default: true
+    option :broken_and, default: false
 
     # Use millisecond precision when comparing Time objects with the _matches?
     # function.
-    option :compare_time_by_ms, default: false
+    option :compare_time_by_ms, default: true
 
     # Use bson-ruby's implementation of as_json for BSON::ObjectId instead of
     # the one monkey-patched into Mongoid.
-    option :object_id_as_json_oid, default: true
+    option :object_id_as_json_oid, default: false
 
     # Maintain legacy behavior of pluck and distinct, which does not
     # demongoize the values on returning them.
-    option :legacy_pluck_distinct, default: true
+    option :legacy_pluck_distinct, default: false
 
     # Combine chained operators, which use the same field and operator,
     # using and's instead of overwriting them.
-    option :overwrite_chained_operators, default: true
+    option :overwrite_chained_operators, default: false
 
     # When this flag is true, the attributes method on a document will return
     # a BSON::Document when that document is retrieved from the database, and
     # a Hash otherwise. When this flag is false, the attributes method will
     # always return a Hash.
-    option :legacy_attributes, default: true
-
-    # The maximum number of seconds that evaluating a single query in memory
-    # may spend executing regular expressions. Queries against an embedded
-    # association are evaluated in the calling thread, so a pattern built from
-    # user input runs locally and can otherwise consume unbounded CPU. The
-    # limit is cumulative over the whole query, since cost grows with the
-    # number of documents and conditions as well as with the pattern.
-    #
-    # Set to nil to remove the limit. On Ruby 3.2 and later the remaining
-    # budget is compiled into the pattern, so the limit counts only the time
-    # spent matching. Earlier Rubies have no per-Regexp timeout, so the query
-    # is bounded with Timeout instead and the limit is wall clock over the
-    # whole in-memory evaluation.
-    #
-    # See https://jira.mongodb.org/browse/MONGOID-5981 for details.
-    option :in_memory_regexp_time_limit, default: 5.0
-
-    # When false (default), query operators are restricted when building a
-    # selector, so that user-supplied input reaching the query builder cannot
-    # make MongoDB execute arbitrary JavaScript. Two rules are enforced:
-    #
-    # - An operator at the top level of an expression must appear in
-    #   +Criteria::Queryable::Selectable::ALLOWED_QUERY_OPERATORS+.
-    # - +$where+, +$function+, and +$accumulator+ are rejected at any depth,
-    #   including inside +$expr+ and the logical operators.
-    #
-    # This applies to every query method that accepts an expression, including
-    # +where+, +find_by+, +and+, +or+, +nor+, +not+, +any_of+, and +none_of+.
-    # It also governs the string form of +where+, e.g.
-    # +where("this.name == 'admin'")+, which the server evaluates as +$where+.
-    # Applications relying on that form must set this option to true.
-    #
-    # The APIs that request JavaScript explicitly, +Criteria#for_js+ and
-    # +js_query+, are unaffected: there the developer has asked for it.
-    #
-    # Set to true to restore the unrestricted pass-through behavior.
-    #
-    # Note that this option is deliberately not tied to +load_defaults+: an
-    # application that has opted into older defaults still gets the guard, and
-    # must set this option explicitly to turn it off.
-    #
-    # See https://jira.mongodb.org/browse/MONGOID-5939,
-    # https://jira.mongodb.org/browse/MONGOID-5993,
-    # https://jira.mongodb.org/browse/MONGOID-5994 for details.
-    option :allow_unsafe_query_operators, default: false
-
-    # When this flag is true, it will be possible to add a record to a
-    # "has_many" or "has_and_belongs_to_many" association by passing that
-    # record's id in the nested attributes for another parent record, even
-    # when the record does not already belong to that association. For a
-    # "has_many" association this moves the record to the new parent.
-    #
-    # When this flag is false, an id in nested attributes is only resolved
-    # within the association itself, and anything else raises an error.
-    #
-    # The default is `false`. Note that allowing reparenting via nested attributes
-    # is a potential security risk, since it could allow a malicious user to move
-    # records that they do not own to a parent record that they do own.
-    #
-    # This option will be removed in Mongoid 10, and the only behavior will be
-    # as if this option were set to false.
-    option :allow_reparenting_via_nested_attributes, default: false
+    option :legacy_attributes, default: false
 
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
@@ -275,6 +216,7 @@ module Mongoid
       configuration = settings.with_indifferent_access
       self.options = configuration[:options]
       self.clients = configuration[:clients]
+      Mongo.options = configuration[:driver_options] || {}
       set_log_levels
     end
 

data/lib/mongoid/contextual/aggregable/memory.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-require 'mongoid/field_readable'
-
 module Mongoid
   module Contextual
     module Aggregable
       # Contains behavior for aggregating values in memory.
       module Memory
-        include FieldReadable
 
         # Get all the aggregate values for the provided field.
         # Provided for interface consistency with Aggregable::Mongo.
@@ -30,9 +27,13 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to average.
         #
-        # @return [ Float ] The average.
+        # @return [ Numeric ] The average.
         def avg(field)
-          count > 0 ? sum(field).to_f / count.to_f : nil
+          total = count { |doc| !doc.send(field).nil? }
+          return nil unless total > 0
+
+          total = total.to_f if total.is_a?(Integer)
+          sum(field) / total
         end
 
         # Get the max value of the provided field. If provided a block, will
@@ -49,10 +50,12 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to max.
         #
-        # @return [ Float, Document ] The max value or document with the max
+        # @return [ Numeric | Document ] The max value or document with the max
         #   value.
         def max(field = nil)
-          block_given? ? super() : aggregate_by(field, :max_by)
+          return super() if block_given?
+
+          aggregate_by(field, :max)
         end
 
         # Get the min value of the provided field. If provided a block, will
@@ -69,10 +72,12 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to min.
         #
-        # @return [ Float, Document ] The min value or document with the min
+        # @return [ Numeric | Document ] The min value or document with the min
         #   value.
         def min(field = nil)
-          block_given? ? super() : aggregate_by(field, :min_by)
+          return super() if block_given?
+
+          aggregate_by(field, :min)
         end
 
         # Get the sum value of the provided field. If provided a block, will
@@ -86,13 +91,11 @@ module Mongoid
         #
         # @param [ Symbol ] field The field to sum.
         #
-        # @return [ Float ] The sum value.
+        # @return [ Numeric ] The sum value.
         def sum(field = nil)
-          if block_given?
-            super()
-          else
-            count > 0 ? map { |doc| read_field_value(doc, field) }.compact.sum : 0
-          end
+          return super() if block_given?
+
+          aggregate_by(field, :sum) || 0
         end
 
         private
@@ -102,17 +105,16 @@ module Mongoid
         # @api private
         #
         # @example Aggregate by the field and method.
-        #   aggregable.aggregate_by(:name, :min_by)
+        #   aggregable.aggregate_by(:likes, :min_by)
         #
         # @param [ Symbol ] field The field to aggregate on.
         # @param [ Symbol ] method The method (min_by or max_by).
         #
-        # @return [ Integer ] The aggregate.
+        # @return [ Numeric | nil ] The aggregate.
         def aggregate_by(field, method)
-          return nil if count == 0
+          return nil unless any?
 
-          doc = send(method) { |doc| read_field_value(doc, field) }
-          read_field_value(doc, field)
+          map { |doc| doc.public_send(field) }.compact.public_send(method)
         end
       end
     end

data/lib/mongoid/contextual/aggregable/mongo.rb

@@ -26,7 +26,7 @@ module Mongoid
         #   If no documents are found, then returned Hash will have
         #   count, sum of 0 and max, min, avg of nil.
         def aggregates(field)
-          result = collection.find.aggregate(pipeline(field), session: _session).to_a
+          result = collection.aggregate(pipeline(field), session: _session).to_a
           if result.empty?
             if Mongoid.broken_aggregables
               { "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil }

data/lib/mongoid/contextual/map_reduce.rb

@@ -121,7 +121,7 @@ module Mongoid
       # @return [ MapReduce ] The map/reduce object.
       def out(location)
         normalized = location.dup
-        normalized.update_values do |value|
+        normalized.transform_values! do |value|
           value.is_a?(::Symbol) ? value.to_s : value
         end
         @map_reduce = @map_reduce.out(normalized)
@@ -147,7 +147,7 @@ module Mongoid
       def raw
         validate_out!
         cmd = command
-        opts = { read: cmd.delete(:read) } if cmd[:read]
+        opts = { read: criteria.options.fetch(:read) } if criteria.options[:read]
         @map_reduce.database.command(cmd, (opts || {}).merge(session: _session)).first
       end
       alias :results :raw

data/lib/mongoid/contextual/memory.rb

@@ -2,7 +2,6 @@
 
 require "mongoid/contextual/aggregable/memory"
 require "mongoid/association/eager_loadable"
-require "mongoid/field_readable"
 
 module Mongoid
   module Contextual
@@ -12,7 +11,6 @@ module Mongoid
       include Association::EagerLoadable
       include Queryable
       include Positional
-      include FieldReadable
 
       # @attribute [r] root The root document.
       # @attribute [r] path The atomic path.
@@ -76,12 +74,12 @@ module Mongoid
       # @example Get the distinct values.
       #   context.distinct(:name)
       #
-      # @param [ String, Symbol ] field The name of the field.
+      # @param [ String | Symbol ] field The name of the field.
       #
       # @return [ Array<Object> ] The distinct values for the field.
       def distinct(field)
         if Mongoid.legacy_pluck_distinct
-          documents.map { |doc| read_field_value(doc, field) }.uniq
+          documents.map{ |doc| doc.send(field) }.uniq
         else
           pluck(field).uniq
         end
@@ -114,7 +112,7 @@ module Mongoid
       #
       # @return [ true, false ] If the count is more than zero.
       def exists?
-        count > 0
+        any?
       end
 
       # Get the first document in the database for the criteria's selector.
@@ -122,15 +120,14 @@ module Mongoid
       # @example Get the first document.
       #   context.first
       #
-      # @param [ Integer | Hash ] limit_or_opts The number of documents to
-      #   return, or a hash of options.
+      # @param [ Integer ] limit The number of documents to return.
       #
       # @return [ Document ] The first document.
-      def first(limit_or_opts = nil)
-        if limit_or_opts.nil? || limit_or_opts.is_a?(Hash)
-          eager_load([documents.first]).first
+      def first(limit = nil)
+        if limit
+          eager_load(documents.first(limit))
         else
-          eager_load(documents.first(limit_or_opts))
+          eager_load([documents.first]).first
         end
       end
       alias :one :first
@@ -144,20 +141,10 @@ module Mongoid
       # @param [ Criteria ] criteria The criteria.
       def initialize(criteria)
         @criteria, @klass = criteria, criteria.klass
-
-        # Resolving the collection can build a Mongo::Client the first time it
-        # runs, so it happens before the budget opens. Where the budget is
-        # enforced with Timeout the exception is asynchronous, and landing in
-        # the middle of that would leave a half-built client behind.
-        if (first = criteria.documents.first)
-          @root = first._root
-          @collection = @root.collection
-        end
-
-        # One regexp budget covers the whole scan, so that the limit bounds the
-        # query rather than each document individually.
-        @documents = Matcher::RegexpBudget.open(criteria.selector) do
-          criteria.documents.select { |doc| doc._matches?(criteria.selector) }
+        @documents = criteria.documents.select do |doc|
+          @root ||= doc._root
+          @collection ||= root.collection
+          doc._matches?(criteria.selector)
         end
         apply_sorting
         apply_options
@@ -182,18 +169,14 @@ module Mongoid
       # @example Get the last document.
       #   context.last
       #
-      # @param [ Integer | Hash ] limit_or_opts The number of documents to
-      #   return, or a hash of options.
-      #
-      # @option limit_or_opts [ :none ] :id_sort This option is deprecated.
-      #   Don't apply a sort on _id if no other sort is defined on the criteria.
+      # @param [ Integer ] limit The number of documents to return.
       #
       # @return [ Document ] The last document.
-      def last(limit_or_opts = nil)
-        if limit_or_opts.nil? || limit_or_opts.is_a?(Hash)
-          eager_load([documents.last]).first
+      def last(limit = nil)
+        if limit
+          eager_load(documents.last(limit))
         else
-          eager_load(documents.last(limit_or_opts))
+          eager_load([documents.last]).first
         end
       end
 
@@ -248,28 +231,44 @@ module Mongoid
       #
       # @param [ Integer ] value The number of documents to return.
       #
-      # @return [ Mongo ] The context.
+      # @return [ Memory ] The context.
       def limit(value)
         self.limiting = value
         self
       end
 
+      # Pluck the field values in memory.
+      #
+      # @example Get the values in memory.
+      #   context.pluck(:name)
+      #
+      # @param [ String | Symbol ] *fields Field(s) to pluck.
+      #
+      # @return [ Array ] The array of plucked values.
       def pluck(*fields)
         if Mongoid.legacy_pluck_distinct
           documents.pluck(*fields)
         else
-          documents.map do |d|
-            if fields.length == 1
-              retrieve_value_at_path(d, fields.first)
-            else
-              fields.map do |field|
-                retrieve_value_at_path(d, field)
-              end
-            end
+          documents.map do |doc|
+            pluck_from_doc(doc, *fields)
           end
         end
       end
 
+      # Pick the field values in memory.
+      #
+      # @example Get the values in memory.
+      #   context.pick(:name)
+      #
+      # @param [ String | Symbol ] *fields Field(s) to pick.
+      #
+      # @return [ Object, Array<Object> ] The picked values.
+      def pick(*fields)
+        if doc = documents.first
+          pluck_from_doc(doc, *fields)
+        end
+      end
+
       # Tally the field values in memory.
       #
       # @example Get the counts of values in memory.
@@ -293,7 +292,7 @@ module Mongoid
       #
       # @param [ Integer ] value The number of documents to skip.
       #
-      # @return [ Mongo ] The context.
+      # @return [ Memory ] The context.
       def skip(value)
         self.skipping = value
         self
@@ -307,7 +306,7 @@ module Mongoid
       # @param [ Hash ] values The sorting values as field/direction(1/-1)
       #   pairs.
       #
-      # @return [ Mongo ] The context.
+      # @return [ Memory ] The context.
       def sort(values)
         in_place_sort(values) and self
       end
@@ -535,10 +534,11 @@ module Mongoid
             # _translations hash so that we can get the specified translation in
             # the remaining
             if field&.localized?
-              document.public_send("#{segment}_translations")
+              document.send("#{segment}_translations")
             end
           end
-          res.nil? ? read_field_value(document, segment) : res
+          meth = klass.aliased_associations[segment] || segment
+          res.nil? ? document.try(meth) : res
         elsif document.is_a?(Hash)
           # TODO: Remove the indifferent access when implementing MONGOID-5410.
           document.key?(segment.to_s) ?
@@ -557,6 +557,22 @@ module Mongoid
           retrieve_value_at_path(curr, remaining)
         end
       end
+
+      # Pluck the field values from the given document.
+      #
+      # @param [ Document ] doc The document to pluck from.
+      # @param [ String | Symbol ] *fields Field(s) to pluck.
+      #
+      # @return [ Object, Array<Object> ] The plucked values.
+      def pluck_from_doc(doc, *fields)
+        if fields.length == 1
+          retrieve_value_at_path(doc, fields.first)
+        else
+          fields.map do |field|
+            retrieve_value_at_path(doc, field)
+          end
+        end
+      end
     end
   end
 end