mongoid 9.0.8 → 9.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '032258516f15736f4121de82ee4cdcdb625515f653f85a66b0df613665236e4d'
-  data.tar.gz: 443ec24d9a54bb10c87023cd6304081aa48bf92bf5654044cc935f79ca954b9c
+  metadata.gz: fefd49681b6f78b222f201fbaea83af9f1599464034e52a73117c0ae94e201f2
+  data.tar.gz: d86f966109921d2a0f1a4ce0b78d81e0d722123c1d420f0f695385ca43687626
 SHA512:
-  metadata.gz: 3c875bf631d019da208fa59221a74e3468931a802664e43ce2e8ed669e990722a499d8976a8acafb8078dbeff8c02a76df96b9d76f8e33c0c979658f40748fd9
-  data.tar.gz: 46943ea7b081db4784159bacc2056b75b6511f8c8892910dc2c2bfc7ee1229a6ddf0d9141f52137a12a04eea841c24e16b4eae7fb8fc15bd26e2dec7d0273ecc
+  metadata.gz: '09799846ca2a44c7dc4d7aff76fba0f9fdcbe38c5bfb001dccd08eb467800f8fac675cecfa06be94eb76ca35f6f1b57b64557ed171e9c0040bcbe0a701d7827f'
+  data.tar.gz: bc0a741e2e26a84e84238f1461a26a29ae13584d9bd050dffc1ccd04f70e4e6a7fa63b20e7dcda8137ce3c37d383a5ae916b0d72ff950d4f330e66e0635ea89c

data/lib/mongoid/association/embedded/embeds_many/proxy.rb

@@ -14,6 +14,7 @@ module Mongoid
         # the array of child documents.
         class Proxy < Association::Many
           include Batchable
+          extend Forwardable
 
           # Class-level methods for the Proxy class.
           module ClassMethods
@@ -54,6 +55,8 @@ module Mongoid
 
           extend ClassMethods
 
+          def_delegators :criteria, :find, :pluck
+
           # Instantiate a new embeds_many association.
           #
           # @example Create the new association.
@@ -312,35 +315,6 @@ module Mongoid
             end
           end
 
-          # Finds a document in this association through several different
-          # methods.
-          #
-          # This method delegates to +Mongoid::Criteria#find+. If this method is
-          # not given a block, it returns one or many documents for the provided
-          # _id values.
-          #
-          # If this method is given a block, it returns the first document
-          # of those found by the current Criteria object for which the block
-          # returns a truthy value.
-          #
-          # @example Find a document by its id.
-          #   person.addresses.find(BSON::ObjectId.new)
-          #
-          # @example Find documents for multiple ids.
-          #   person.addresses.find([ BSON::ObjectId.new, BSON::ObjectId.new ])
-          #
-          # @example Finds the first matching document using a block.
-          #   person.addresses.find { |addr| addr.state == 'CA' }
-          #
-          # @param [ Object... ] *args Various arguments.
-          # @param &block Optional block to pass.
-          # @yield [ Object ] Yields each enumerable element to the block.
-          #
-          # @return [ Document | Array<Document> | nil ] A document or matching documents.
-          def find(...)
-            criteria.find(...)
-          end
-
           # Get all the documents in the association that are loaded into memory.
           #
           # @example Get the in memory documents.

data/lib/mongoid/association/referenced/has_and_belongs_to_many/proxy.rb

@@ -53,8 +53,6 @@ module Mongoid
           # @param [ Document... ] *args Any number of documents.
           #
           # @return [ Array<Document> ] The loaded docs.
-          #
-          # rubocop:disable Metrics/AbcSize
           def <<(*args)
             docs = args.flatten
             return concat(docs) if docs.size > 1
@@ -89,7 +87,6 @@ module Mongoid
             end
             unsynced(_base, foreign_key) and self
           end
-          # rubocop:enable Metrics/AbcSize
 
           alias push <<
 
@@ -360,8 +357,6 @@ module Mongoid
           #   in bulk
           # @param [ Array ] inserts the list of Hashes of attributes that will
           #   be inserted (corresponding to the ``docs`` list)
-          #
-          # rubocop:disable Metrics/AbcSize
           def append_document(doc, ids, docs, inserts)
             return unless doc
 
@@ -379,7 +374,6 @@ module Mongoid
               unsynced(_base, foreign_key)
             end
           end
-          # rubocop:enable Metrics/AbcSize
         end
       end
     end

data/lib/mongoid/association/referenced/has_many/enumerable.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # rubocop:todo all
 
+require 'mongoid/pluckable'
+
 module Mongoid
   module Association
     module Referenced
@@ -12,6 +14,7 @@ module Mongoid
         class Enumerable
           extend Forwardable
           include ::Enumerable
+          include Pluckable
 
           # The three main instance variables are collections of documents.
           #
@@ -374,6 +377,43 @@ module Mongoid
             @_added, @_loaded, @_unloaded, @executed = data
           end
 
+          # Plucks the given field names from the documents in the target.
+          # If the collection has been loaded, it plucks from the loaded
+          # documents; otherwise, it plucks from the unloaded criteria.
+          # Regardless, it also plucks from any added documents.
+          #
+          # @param [ Symbol... ] *fields The field names to pluck.
+          #
+          # @return [ Array | Array<Array> ] The array of field values. If
+          #   multiple fields are given, an array of arrays is returned.
+          def pluck(*keys)
+            [].tap do |results|
+              if _loaded? || _added.any?
+                klass = @_association.klass
+                prepared = prepare_pluck(keys, document_class: klass)
+              end
+
+              if _loaded?
+                docs = _loaded.values.map { |v| BSON::Document.new(v.attributes) }
+                results.concat pluck_from_documents(docs, prepared[:field_names], document_class: klass)
+              elsif _unloaded
+                criteria = if _added.any?
+                  ids_to_exclude = _added.keys
+                  _unloaded.not(:_id.in => ids_to_exclude)
+                else
+                  _unloaded
+                end
+
+                results.concat criteria.pluck(*keys)
+              end
+
+              if _added.any?
+                docs = _added.values.map { |v| BSON::Document.new(v.attributes) }
+                results.concat pluck_from_documents(docs, prepared[:field_names], document_class: klass)
+              end
+            end
+          end
+
           # Reset the enumerable back to its persisted state.
           #
           # @example Reset the enumerable.

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -33,7 +33,7 @@ module Mongoid
 
           extend ClassMethods
 
-          def_delegator :criteria, :count
+          def_delegators :criteria, :count
           def_delegators :_target, :first, :in_memory, :last, :reset, :uniq
 
           # Instantiate a new references_many association. Will set the foreign key
@@ -281,6 +281,22 @@ module Mongoid
 
           alias nullify_all nullify
 
+          # Plucks the given field names from the documents in the
+          # association. It is safe to use whether the association is
+          # loaded or not, and whether there are unsaved documents in the
+          # association or not.
+          #
+          # @example Pluck the titles of all posts.
+          #   person.posts.pluck(:title)
+          #
+          # @param [ Symbol... ] *fields The field names to pluck.
+          #
+          # @return [ Array | Array<Array> ] The array of field values. If
+          #   multiple fields are given, an array of arrays is returned.
+          def pluck(*fields)
+            _target.pluck(*fields)
+          end
+
           # Clear the association. Will delete the documents from the db if they are
           # already persisted.
           #

data/lib/mongoid/attributes.rb

@@ -104,7 +104,8 @@ module Mongoid
     # @api private
     def process_raw_attribute(name, raw, field)
       value = field ? field.demongoize(raw) : raw
-      attribute_will_change!(name) if value.resizable?
+      is_relation = relations.key?(name)
+      attribute_will_change!(name) if value.resizable? && !is_relation
       value
     end
 
@@ -175,7 +176,7 @@ module Mongoid
           localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
           typed_value = typed_value_for(field_name, value)
-          unless attributes[field_name] == typed_value || attribute_changed?(field_name)
+          unless attribute_will_not_change?(field_name, typed_value) || attribute_changed?(field_name)
             attribute_will_change!(field_name)
           end
           if localized
@@ -366,5 +367,23 @@ module Mongoid
       end
       value.present?
     end
+
+    # If `value` is a `BSON::Decimal128`, convert it to a `BigDecimal` for
+    # comparison purposes. This is necessary because `BSON::Decimal128` does
+    # not implement `#==` in a way that is compatible with `BigDecimal`.
+    def normalize_value(value)
+      value.is_a?(BSON::Decimal128) ? BigDecimal(value.to_s) : value
+    end
+
+    # Determine if the attribute will not change, by comparing the current
+    # value with the new value. The values are normalized to account for
+    # types that do not implement `#==` in a way that is compatible with
+    # each other, such as `BSON::Decimal128` and `BigDecimal`.
+    def attribute_will_not_change?(field_name, typed_value)
+      normalized_attribute = normalize_value(attributes[field_name])
+      normalized_typed_value = normalize_value(typed_value)
+
+      normalized_attribute == normalized_typed_value
+    end
   end
 end

data/lib/mongoid/clients/factory.rb

@@ -131,6 +131,10 @@ module Mongoid
             [MONGOID_WRAPPING_LIBRARY] + options[:wrapping_libraries]
           else
             [MONGOID_WRAPPING_LIBRARY]
+          end.tap do |wrap|
+            if defined?(::Rails) && ::Rails.respond_to?(:version)
+              wrap << { name: 'Rails', version: ::Rails.version }
+            end
           end
           options[:wrapping_libraries] = wrap_lib
         end

data/lib/mongoid/contextual/mongo.rb

@@ -2,6 +2,7 @@
 # rubocop:todo all
 
 require 'mongoid/atomic_update_preparer'
+require 'mongoid/pluckable'
 require "mongoid/contextual/mongo/documents_loader"
 require "mongoid/contextual/atomic"
 require "mongoid/contextual/aggregable/mongo"
@@ -22,6 +23,7 @@ module Mongoid
       include Atomic
       include Association::EagerLoadable
       include Queryable
+      include Pluckable
 
       # Options constant.
       OPTIONS = [ :hint,
@@ -331,23 +333,12 @@ module Mongoid
       #   in the array will be a single value. Otherwise, each
       #   result in the array will be an array of values.
       def pluck(*fields)
-        # Multiple fields can map to the same field name. For example, plucking
-        # a field and its _translations field map to the same field in the database.
-        # because of this, we need to keep track of the fields requested.
-        normalized_field_names = []
-        normalized_select = fields.inject({}) do |hash, f|
-          db_fn = klass.database_field_name(f)
-          normalized_field_names.push(db_fn)
-          hash[klass.cleanse_localized_field_names(f)] = true
-          hash
-        end
-
-        view.projection(normalized_select).reduce([]) do |plucked, doc|
-          values = normalized_field_names.map do |n|
-            extract_value(doc, n)
-          end
-          plucked << (values.size == 1 ? values.first : values)
-        end
+        # Multiple fields can map to the same field name. For example,
+        # plucking a field and its _translations field map to the same
+        # field in the database. because of this, we need to prepare the
+        # projection specifically.
+        prep = prepare_pluck(fields, prepare_projection: true)
+        pluck_from_documents(view.projection(prep[:projection]), prep[:field_names])
       end
 
       # Pick the single field values from the database.
@@ -893,78 +884,6 @@ module Mongoid
         collection.write_concern.nil? || collection.write_concern.acknowledged?
       end
 
-      # Fetch the element from the given hash and demongoize it using the
-      # given field. If the obj is an array, map over it and call this method
-      # on all of its elements.
-      #
-      # @param [ Hash | Array<Hash> ] obj The hash or array of hashes to fetch from.
-      # @param [ String ] meth The key to fetch from the hash.
-      # @param [ Field ] field The field to use for demongoization.
-      #
-      # @return [ Object ] The demongoized value.
-      #
-      # @api private
-      def fetch_and_demongoize(obj, meth, field)
-        if obj.is_a?(Array)
-          obj.map { |doc| fetch_and_demongoize(doc, meth, field) }
-        else
-          res = obj.try(:fetch, meth, nil)
-          field ? field.demongoize(res) : res.class.demongoize(res)
-        end
-      end
-
-      # Extracts the value for the given field name from the given attribute
-      # hash.
-      #
-      # @param [ Hash ] attrs The attributes hash.
-      # @param [ String ] field_name The name of the field to extract.
-      #
-      # @param [ Object ] The value for the given field name
-      def extract_value(attrs, field_name)
-        i = 1
-        num_meths = field_name.count('.') + 1
-        curr = attrs.dup
-
-        klass.traverse_association_tree(field_name) do |meth, obj, is_field|
-          field = obj if is_field
-          is_translation = false
-          # If no association or field was found, check if the meth is an
-          # _translations field.
-          if obj.nil? & tr = meth.match(/(.*)_translations\z/)&.captures&.first
-            is_translation = true
-            meth = tr
-          end
-
-          # 1. If curr is an array fetch from all elements in the array.
-          # 2. If the field is localized, and is not an _translations field
-          #    (_translations fields don't show up in the fields hash).
-          #    - If this is the end of the methods, return the translation for
-          #      the current locale.
-          #    - Otherwise, return the whole translations hash so the next method
-          #      can select the language it wants.
-          # 3. If the meth is an _translations field, do not demongoize the
-          #    value so the full hash is returned.
-          # 4. Otherwise, fetch and demongoize the value for the key meth.
-          curr = if curr.is_a? Array
-            res = fetch_and_demongoize(curr, meth, field)
-            res.empty? ? nil : res
-          elsif !is_translation && field&.localized?
-            if i < num_meths
-              curr.try(:fetch, meth, nil)
-            else
-              fetch_and_demongoize(curr, meth, field)
-            end
-          elsif is_translation
-            curr.try(:fetch, meth, nil)
-          else
-            fetch_and_demongoize(curr, meth, field)
-          end
-
-          i += 1
-        end
-        curr
-      end
-
       # Recursively demongoize the given value. This method recursively traverses
       # the class tree to find the correct field to use to demongoize the value.
       #

data/lib/mongoid/criteria.rb

@@ -41,24 +41,57 @@ module Mongoid
     include Clients::Sessions
     include Options
 
+    # Allowed methods for from_hash to prevent arbitrary method execution.
+    # Only query-building methods are allowed, not execution or modification methods.
+    ALLOWED_FROM_HASH_METHODS = %i[
+      all all_in all_of and any_in any_of asc ascending
+      batch_size between
+      collation comment cursor_type
+      desc descending
+      elem_match eq exists extras
+      geo_spatial group gt gte
+      hint
+      in includes
+      limit lt lte
+      max_distance max_scan max_time_ms merge mod
+      ne near near_sphere nin no_timeout none none_of nor not not_in
+      offset only or order order_by
+      project
+      raw read reorder
+      scoped skip slice snapshot
+      text_search type
+      unscoped unwind
+      where with_size with_type without
+    ].freeze
+
     class << self
       # Convert the given hash to a criteria. Will iterate over each keys in the
-      # hash which must correspond to method on a criteria object. The hash
-      # must also include a "klass" key.
+      # hash which must correspond to an allowed method on a criteria object. The hash
+      # can include a "klass" key that specifies the model class for the criteria.
       #
       # @example Convert the hash to a criteria.
       #   Criteria.from_hash({ klass: Band, where: { name: "Depeche Mode" })
       #
+      # @deprecated This method is deprecated and will
+      #  be removed in a future release.
+      #
       # @param [ Hash ] hash The hash to convert.
       #
       # @return [ Criteria ] The criteria.
+      #
+      # @raise [ ArgumentError ] If a method is not allowed in from_hash.
       def from_hash(hash)
         criteria = Criteria.new(hash.delete(:klass) || hash.delete('klass'))
         hash.each_pair do |method, args|
-          criteria = criteria.__send__(method, args)
+          method_sym = method.to_sym
+          unless ALLOWED_FROM_HASH_METHODS.include?(method_sym)
+            raise ArgumentError, "Method '#{method}' is not allowed in from_hash"
+          end
+          criteria = criteria.public_send(method_sym, args)
         end
         criteria
       end
+      Mongoid.deprecate(self, :from_hash)
     end
 
     # Static array used to check with method missing - we only need to ever
@@ -246,7 +279,8 @@ module Mongoid
     #   criteria.merge(other_criteria)
     #
     # @example Merge the criteria with a hash. The hash must contain a klass
-    #   key and the key/value pairs correspond to method names/args.
+    #   key that specifies the model class for the criteria and the key/value
+    #   pairs correspond to method names/args.
     #
     #   criteria.merge({
     #     klass: Band,
@@ -254,7 +288,7 @@ module Mongoid
     #     order_by: { name: 1 }
     #   })
     #
-    # @param [ Criteria ] other The other criterion to merge with.
+    # @param [ Criteria | Hash ] other The other criterion to merge with.
     #
     # @return [ Criteria ] A cloned self.
     def merge(other)

data/lib/mongoid/pluckable.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # Provides shared behavior for any document with "pluck" functionality.
+  #
+  # @api private
+  module Pluckable
+    extend ActiveSupport::Concern
+
+    private
+
+    # Prepares the field names for plucking by normalizing them to their
+    # database field names. Also prepares a projection hash if requested.
+    def prepare_pluck(field_names, document_class: klass, prepare_projection: false)
+      normalized_field_names = []
+      projection = {}
+
+      field_names.each do |f|
+        db_fn = document_class.database_field_name(f)
+        normalized_field_names.push(db_fn)
+
+        next unless prepare_projection
+
+        cleaned_name = document_class.cleanse_localized_field_names(f)
+        canonical_name = document_class.database_field_name(cleaned_name)
+        projection[canonical_name] = true
+      end
+
+      { field_names: normalized_field_names, projection: projection }
+    end
+
+    # Plucks the given field names from the given documents.
+    def pluck_from_documents(documents, field_names, document_class: klass)
+      documents.reduce([]) do |plucked, doc|
+        values = field_names.map { |name| extract_value(doc, name.to_s, document_class) }
+        plucked << ((values.size == 1) ? values.first : values)
+      end
+    end
+
+    # Fetch the element from the given hash and demongoize it using the
+    # given field. If the obj is an array, map over it and call this method
+    # on all of its elements.
+    #
+    # @param [ Hash | Array<Hash> ] obj The hash or array of hashes to fetch from.
+    # @param [ String ] key The key to fetch from the hash.
+    # @param [ Field ] field The field to use for demongoization.
+    #
+    # @return [ Object ] The demongoized value.
+    def fetch_and_demongoize(obj, key, field)
+      if obj.is_a?(Array)
+        obj.map { |doc| fetch_and_demongoize(doc, key, field) }
+      else
+        value = obj.try(:fetch, key, nil)
+        field ? field.demongoize(value) : value.class.demongoize(value)
+      end
+    end
+
+    # Extracts the value for the given field name from the given attribute
+    # hash.
+    #
+    # @param [ Hash ] attrs The attributes hash.
+    # @param [ String ] field_name The name of the field to extract.
+    #
+    # @return [ Object ] The value for the given field name
+    def extract_value(attrs, field_name, document_class)
+      i = 1
+      num_meths = field_name.count('.') + 1
+      curr = attrs.dup
+
+      document_class.traverse_association_tree(field_name) do |meth, obj, is_field|
+        field = obj if is_field
+
+        # use the correct document class to check for localized fields on
+        # embedded documents.
+        document_class = obj.klass if obj.respond_to?(:klass)
+
+        is_translation = false
+        # If no association or field was found, check if the meth is an
+        # _translations field.
+        if obj.nil? && (tr = meth.match(/(.*)_translations\z/)&.captures&.first)
+          is_translation = true
+          meth = document_class.database_field_name(tr)
+        end
+
+        curr = descend(i, curr, meth, field, num_meths, is_translation)
+
+        i += 1
+      end
+      curr
+    end
+
+    # Descend one level in the attribute hash.
+    #
+    # @param [ Integer ] part The current part index.
+    # @param [ Hash | Array<Hash> ] current The current level in the attribute hash.
+    # @param [ String ] method_name The method name to descend to.
+    # @param [ Field|nil ] field The field to use for demongoization.
+    # @param [ Boolean ] is_translation Whether the method is an _translations field.
+    # @param [ Integer ] part_count The total number of parts in the field name.
+    #
+    # @return [ Object ] The value at the next level.
+    #
+    # rubocop:disable Metrics/ParameterLists
+    def descend(part, current, method_name, field, part_count, is_translation)
+      # 1. If curr is an array fetch from all elements in the array.
+      # 2. If the field is localized, and is not an _translations field
+      #    (_translations fields don't show up in the fields hash).
+      #    - If this is the end of the methods, return the translation for
+      #      the current locale.
+      #    - Otherwise, return the whole translations hash so the next method
+      #      can select the language it wants.
+      # 3. If the meth is an _translations field, do not demongoize the
+      #    value so the full hash is returned.
+      # 4. Otherwise, fetch and demongoize the value for the key meth.
+      if current.is_a? Array
+        res = fetch_and_demongoize(current, method_name, field)
+        res.empty? ? nil : res
+      elsif !is_translation && field&.localized?
+        if part < part_count
+          current.try(:fetch, method_name, nil)
+        else
+          fetch_and_demongoize(current, method_name, field)
+        end
+      elsif is_translation
+        current.try(:fetch, method_name, nil)
+      else
+        fetch_and_demongoize(current, method_name, field)
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/mongoid/traversable.rb

@@ -131,7 +131,6 @@ module Mongoid
       # @param [ String ] value The discriminator key to set.
       #
       # @api private
-      # rubocop:disable Metrics/AbcSize
       def discriminator_key=(value)
         raise Errors::InvalidDiscriminatorKeyTarget.new(self, superclass) if hereditary?
 
@@ -159,7 +158,6 @@ module Mongoid
         default_proc = -> { self.class.discriminator_value }
         field(discriminator_key, default: default_proc, type: String)
       end
-      # rubocop:enable Metrics/AbcSize
 
       # Returns the discriminator key.
       #

data/lib/mongoid/version.rb

@@ -5,5 +5,5 @@ module Mongoid
   #
   # Note that this file is automatically updated via `rake candidate:create`.
   # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '9.0.8'
+  VERSION = '9.0.10'
 end