mongoid 7.2.0 → 7.3.0

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

@@ -220,7 +220,7 @@ module Mongoid
           #
           # @since 2.0.0.beta.1
           def initialize(base, target, association)
-            enum = HasMany::Targets::Enumerable.new(target, base, association)
+            enum = HasMany::Enumerable.new(target, base, association)
             init(base, enum, association) do
               raise_mixed if klass.embedded? && !klass.cyclic?
             end
@@ -367,7 +367,7 @@ module Mongoid
             document.persisted? &&
                 document._association &&
                 document.respond_to?(document._association.foreign_key) &&
-                document.__send__(document._association.foreign_key) == _base.id
+                document.__send__(document._association.foreign_key) == _base._id
           end
 
           # Instantiate the binding associated with this association.

data/lib/mongoid/association/referenced/has_one/nested_builder.rb

@@ -69,7 +69,7 @@ module Mongoid
           #
           # @since 2.0.0
           def acceptable_id?
-            id = convert_id(existing.class, attributes[:id])
+            id = convert_id(existing.class, attributes[:_id])
             existing._id == id || id.nil? || (existing._id != id && update_only?)
           end
 
@@ -82,7 +82,7 @@ module Mongoid
           #
           # @since 2.0.0
           def delete?
-            destroyable? && !attributes[:id].nil?
+            destroyable? && !attributes[:_id].nil?
           end
 
           # Can the existing association potentially be destroyed?

data/lib/mongoid/attributes/projector.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Mongoid
+  module Attributes
+
+    # This module defines projection helpers.
+    #
+    # Projection rules are rather non-trivial. See
+    # https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection
+    # for server documentation.
+    # 4.4 server (and presumably all older ones) requires that a projection
+    # for content fields is either exclusionary or inclusionary, i.e. one
+    # cannot mix exclusions and inclusions in the same query.
+    # However, _id can be excluded in a projection that includes content
+    # fields.
+    # Integer projection values other than 0 and 1 aren't officially
+    # documented as of this writing; see DOCSP-15266.
+    # 4.4 server also allows nested hash projection specification
+    # in addition to dot notation, which I assume Mongoid doesn't handle yet.
+    #
+    # @api private
+    class Projector
+      def initialize(projection)
+        if projection
+          @content_projection = projection.dup
+          @content_projection.delete('_id')
+          @id_projection_value = projection['_id']
+        else
+          @content_projection = nil
+          @id_projection_value = nil
+        end
+      end
+
+      attr_reader :id_projection_value
+      attr_reader :content_projection
+
+      # Determine if the specified attribute, or a dot notation path, is allowed
+      # by the configured projection, if any.
+      #
+      # If there is no configured projection, returns true.
+      #
+      # @param [ String ] name The name of the attribute or a dot notation path.
+      #
+      # @return [ true, false ] Whether the attribute is allowed by projection.
+      #
+      # @api private
+      def attribute_or_path_allowed?(name)
+        # Special handling for _id.
+        if name == '_id'
+          result = unless id_projection_value.nil?
+            value_inclusionary?(id_projection_value)
+          else
+            true
+          end
+          return result
+        end
+
+        if content_projection.nil?
+          # No projection (as opposed to an empty projection).
+          # All attributes are allowed.
+          return true
+        end
+
+        # Find an item which matches or is a parent of the requested name/path.
+        # This handles the case when, for example, the projection was
+        # {foo: true} and we want to know if foo.bar is allowed.
+        item, value = content_projection.detect do |path, value|
+          (name + '.').start_with?(path + '.')
+        end
+        if item
+          return value_inclusionary?(value)
+        end
+
+        if content_inclusionary?
+          # Find an item which would be a strict child of the requested name/path.
+          # This handles the case when, for example, the projection was
+          # {"foo.bar" => true} and we want to know if foo is allowed.
+          # (It is as a container of bars.)
+          item, value = content_projection.detect do |path, value|
+            (path + '.').start_with?(name + '.')
+          end
+          if item
+            return true
+          end
+        end
+
+        !content_inclusionary?
+      end
+
+      private
+
+      # Determines whether the projection for content fields is inclusionary.
+      #
+      # An empty projection is inclusionary.
+      def content_inclusionary?
+        if content_projection.empty?
+          return value_inclusionary?(id_projection_value)
+        end
+
+        value_inclusionary?(content_projection.values.first)
+      end
+
+      def value_inclusionary?(value)
+        case value
+        when Integer
+          value >= 1
+        when true
+          true
+        when false
+          false
+        else
+          # The various expressions that are permitted as projection arguments
+          # imply an inclusionary projection.
+          true
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -5,6 +5,7 @@ require "active_model/attribute_methods"
 require "mongoid/attributes/dynamic"
 require "mongoid/attributes/nested"
 require "mongoid/attributes/processing"
+require "mongoid/attributes/projector"
 require "mongoid/attributes/readonly"
 
 module Mongoid
@@ -160,6 +161,11 @@ module Mongoid
     # @since 1.0.0
     def write_attribute(name, value)
       field_name = database_field_name(name)
+
+      if attribute_missing?(field_name)
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'"
+      end
+
       if attribute_writable?(field_name)
         _assigning do
           validate_attribute_value(field_name, value)
@@ -177,6 +183,8 @@ module Mongoid
           end
           typed_value
         end
+      else
+        # TODO: MONGOID-5072
       end
     end
     alias :[]= :write_attribute
@@ -231,11 +239,7 @@ module Mongoid
     #
     # @since 4.0.0
     def attribute_missing?(name)
-      selection = __selected_fields
-      return false unless selection
-      field = fields[name]
-      (selection.values.first == 0 && selection_excluded?(name, selection, field)) ||
-        (selection.values.first == 1 && !selection_included?(name, selection, field))
+      !Projector.new(__selected_fields).attribute_or_path_allowed?(name)
     end
 
     # Return type-casted attributes.
@@ -252,14 +256,6 @@ module Mongoid
 
     private
 
-    def selection_excluded?(name, selection, field)
-      selection[name] == 0
-    end
-
-    def selection_included?(name, selection, field)
-      selection.key?(name) || selection.keys.collect { |k| k.partition('.').first }.include?(name)
-    end
-
     # Does the string contain dot syntax for accessing hashes?
     #
     # @api private
@@ -293,9 +289,11 @@ module Mongoid
 
     def read_raw_attribute(name)
       normalized = database_field_name(name.to_s)
+
       if attribute_missing?(normalized)
-        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'."
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'"
       end
+
       if hash_dot_syntax?(normalized)
         attributes.__nested__(normalized)
       else
@@ -334,6 +332,26 @@ module Mongoid
         alias_method "#{name}_will_change!", "#{original}_will_change!"
         alias_method "#{name}_before_type_cast", "#{original}_before_type_cast"
       end
+
+      # Removes a field alias.
+      #
+      # @param [ Symbol ] name The aliased field name to remove.
+      def unalias_attribute(name)
+        unless aliased_fields.delete(name.to_s)
+          raise AttributeError, "Field #{name} is not an aliased field"
+        end
+
+        remove_method name
+        remove_method "#{name}="
+        remove_method "#{name}?"
+        remove_method "#{name}_change"
+        remove_method "#{name}_changed?"
+        remove_method "reset_#{name}!"
+        remove_method "reset_#{name}_to_default!"
+        remove_method "#{name}_was"
+        remove_method "#{name}_will_change!"
+        remove_method "#{name}_before_type_cast"
+      end
     end
 
     private

data/lib/mongoid/cacheable.rb

@@ -31,8 +31,8 @@ module Mongoid
     # @since 2.4.0
     def cache_key
       return "#{model_key}/new" if new_record?
-      return "#{model_key}/#{id}-#{updated_at.utc.to_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
-      "#{model_key}/#{id}"
+      return "#{model_key}/#{_id}-#{updated_at.utc.to_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
+      "#{model_key}/#{_id}"
     end
   end
 end

data/lib/mongoid/clients/factory.rb

@@ -5,6 +5,7 @@ module Mongoid
   module Clients
     module Factory
       extend self
+      extend Loggable
 
       # Create a new client given the named configuration. If no name is
       # provided, return a new client with the default configuration. If a
@@ -59,12 +60,20 @@ module Mongoid
       # @since 3.0.0
       def create_client(configuration)
         raise Errors::NoClientsConfig.new unless configuration
-        if configuration[:uri]
-          Mongo::Client.new(configuration[:uri], options(configuration))
+        config = configuration.dup
+        uri = config.delete(:uri)
+        database = config.delete(:database)
+        hosts = config.delete(:hosts)
+        opts = config.delete(:options) || {}
+        unless config.empty?
+          default_logger.warn("Unknown config options detected: #{config}.")
+        end
+        if uri
+          Mongo::Client.new(uri, options(opts))
         else
           Mongo::Client.new(
-            configuration[:hosts],
-            options(configuration).merge(database: configuration[:database])
+            hosts,
+            options(opts).merge(database: database)
           )
         end
       end
@@ -78,9 +87,14 @@ module Mongoid
         Mongo::VERSION.split('.')[0...2].map(&:to_i)
       end
 
-      def options(configuration)
-        config = configuration.dup
-        options = config.delete(:options) || {}
+      # Prepare options for Mongo::Client based on Mongoid client configuration.
+      #
+      # @param [ Hash ] opts Parameters from options section of Mongoid client configuration.
+      # @return [ Hash ] Options that should be passed to Mongo::Client constructor.
+      #
+      # @api private
+      def options(opts)
+        options = opts.dup
         options[:platform] = PLATFORM_DETAILS
         options[:app_name] = Mongoid::Config.app_name if Mongoid::Config.app_name
         if (driver_version <=> [2, 13]) >= 0
@@ -91,7 +105,7 @@ module Mongoid
           end
           options[:wrapping_libraries] = wrap_lib
         end
-        options.reject{ |k, v| k == :hosts }.to_hash.symbolize_keys!
+        options.reject{ |k, _v| k == :hosts }.to_hash.symbolize_keys!
       end
     end
   end

data/lib/mongoid/clients.rb

@@ -59,7 +59,7 @@ module Mongoid
       # @example Get a client with the name.
       #   Mongoid::Clients.with_name(:replica)
       #
-      # @param [ Symbol ] name The name of the client.
+      # @param [ String | Symbol ] name The name of the client.
       #
       # @return [ Mongo::Client ] The named client.
       #

data/lib/mongoid/config.rb

@@ -220,7 +220,7 @@ module Mongoid
     #
     # @since 2.0.2
     def purge!
-      Clients.default.database.collections.each(&:drop) and true
+      global_client.database.collections.each(&:drop) and true
     end
 
     # Truncate all data in all collections, but not the indexes.
@@ -234,7 +234,7 @@ module Mongoid
     #
     # @since 2.0.2
     def truncate!
-      Clients.default.database.collections.each do |collection|
+      global_client.database.collections.each do |collection|
         collection.find.delete_many
       end and true
     end
@@ -305,5 +305,22 @@ module Mongoid
       Validators::Client.validate(c)
       @clients = c
     end
+
+    # Get database client that respects global overrides
+    # Config.override_database and Config.override_client.
+    #
+    # @return [Mongo::Client] Client according to global overrides.
+    def global_client
+      client =  if Threaded.client_override
+                  Clients.with_name(Threaded.client_override)
+                else
+                  Clients.default
+                end
+      if Threaded.database_override
+        client.use(Threaded.database_override)
+      else
+        client
+      end
+    end
   end
 end

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

@@ -11,17 +11,19 @@ module Mongoid
         #
         # @example Get all the aggregate values.
         #   aggregable.aggregates(:likes)
+        #   # => {
+        #   #   "count" => 2.0,
+        #   #   "max" => 1000.0,
+        #   #   "min" => 500.0,
+        #   #   "sum" => 1500.0,
+        #   #   "avg" => 750.0
+        #   # }
         #
         # @param [ String, Symbol ] field The field name.
         #
-        # @return [ Hash ] count is a number of documents with the provided field. If there're none, then count is 0 and max, min, sum, avg are nil.
-        #   {
-        #     "count" => 2.0,
-        #     "max" => 1000.0,
-        #     "min" => 500.0,
-        #     "sum" => 1500.0,
-        #     "avg" => 750.0
-        #   }
+        # @return [ Hash ] count is a number of documents with the provided
+        #   field. If there're none, then count is 0 and max, min, sum, avg
+        #   are nil.
         #
         # @since 3.0.0
         def aggregates(field)

data/lib/mongoid/copyable.rb

@@ -21,7 +21,7 @@ module Mongoid
       # @note This next line is here to address #2704, even though having an
       # _id and id field in the document would cause problems with Mongoid
       # elsewhere.
-      attrs = clone_document.except("_id", "id")
+      attrs = clone_document.except(*self.class.id_fields)
       dynamic_attrs = {}
       _attribute_names = self.attribute_names
       attrs.reject! do |attr_name, value|

data/lib/mongoid/criteria/findable.rb

@@ -132,7 +132,7 @@ module Mongoid
       # @since 3.0.0
       def mongoize_ids(ids)
         ids.map do |id|
-          id = id[:id] if id.respond_to?(:keys) && id[:id]
+          id = id[:_id] if id.respond_to?(:keys) && id[:_id]
           klass.fields["_id"].mongoize(id)
         end
       end

data/lib/mongoid/criteria/queryable/expandable.rb

@@ -15,30 +15,6 @@ module Mongoid
 
         private
 
-        # Expands the specified condition to MongoDB syntax.
-        #
-        # The condition must be a hash in one of the following forms:
-        # - {field_name: value}
-        # - {'field_name' => value}
-        # - {key_instance: value}
-        # - {'$operator' => operator_value_expression}
-        #
-        # This method expands the key instance form to the the operator form,
-        # and also converts hash key to string.
-        #
-        # The hash may contain multiple items, each representing a separate
-        # condition.
-        #
-        # @param [ Hash ] condition The condition to expand.
-        #
-        # @return [ Hash ] The expanded condition.
-        def expand_condition(condition)
-          mapped = condition.map do |field, value|
-            expand_one_condition(field, value)
-          end
-          Hash[mapped]
-        end
-
         # Expands the specified condition to MongoDB syntax.
         #
         # This method is meant to be called when processing the items of

data/lib/mongoid/criteria/queryable/extensions/boolean.rb

@@ -33,4 +33,4 @@ module Mongoid
   end
 end
 
-::Boolean.__send__(:extend, Mongoid::Criteria::Queryable::Extensions::Boolean::ClassMethods)
+Mongoid::Boolean.__send__(:extend, Mongoid::Criteria::Queryable::Extensions::Boolean::ClassMethods)

data/lib/mongoid/criteria/queryable/extensions.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-unless defined?(Boolean)
-  class Boolean; end
-end
-
 if defined?(ActiveSupport)
   unless defined?(ActiveSupport::TimeWithZone)
     require "active_support/time_with_zone"

data/lib/mongoid/criteria/queryable/mergeable.rb

@@ -227,7 +227,16 @@ module Mongoid
         end
 
         # Takes a criteria hash and expands Key objects into hashes containing
-        # MQL corresponding to said key objects.
+        # MQL corresponding to said key objects. Also converts the input to
+        # BSON::Document to permit indifferent access.
+        #
+        # The argument must be a hash containing key-value pairs of the
+        # following forms:
+        # - {field_name: value}
+        # - {'field_name' => value}
+        # - {key_instance: value}
+        # - {:$operator => operator_value_expression}
+        # - {'$operator' => operator_value_expression}
         #
         # Ruby does not permit multiple symbol operators. For example,
         # {:foo.gt => 1, :foo.gt => 2} is collapsed to {:foo.gt => 2} by the
@@ -237,19 +246,23 @@ module Mongoid
         # Similarly, this method should never need to expand a literal value
         # and an operator at the same time.
         #
+        # This method effectively converts symbol keys to string keys in
+        # the input +expr+, such that the downstream code can assume that
+        # conditions always contain string keys.
+        #
         # @param [ Hash ] expr Criteria including Key instances.
         #
-        # @return [ Hash ] The expanded criteria.
+        # @return [ BSON::Document ] The expanded criteria.
         private def _mongoid_expand_keys(expr)
           unless expr.is_a?(Hash)
             raise ArgumentError, 'Argument must be a Hash'
           end
 
-          result = {}
+          result = BSON::Document.new
           expr.each do |field, value|
-            field.__expr_part__(value.__expand_complex__).each do |k, v|
-              if result[k]
-                if result[k].is_a?(Hash)
+            field.__expr_part__(value.__expand_complex__, negating?).each do |k, v|
+              if existing = result[k]
+                if existing.is_a?(Hash)
                   # Existing value is an operator.
                   # If new value is also an operator, ensure there are no
                   # conflicts and add
@@ -257,8 +270,8 @@ module Mongoid
                     # The new value is also an operator.
                     # If there are no conflicts, combine the hashes, otherwise
                     # add new conditions to top level with $and.
-                    if (v.keys & result[k].keys).empty?
-                      result[k].update(v)
+                    if (v.keys & existing.keys).empty?
+                      existing.update(v)
                     else
                       raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
                       result['$and'] ||= []
@@ -266,26 +279,39 @@ module Mongoid
                     end
                   else
                     # The new value is a simple value.
-                    # If there isn't an $eq operator already in the query,
-                    # transform the new value into an $eq operator and add it
-                    # to the existing hash. Otherwise add the new condition
-                    # with $and to the top level.
-                    if result[k].key?('$eq')
+                    # Transform the implicit equality to either $eq or $regexp
+                    # depending on the type of the argument. See
+                    # https://docs.mongodb.com/manual/reference/operator/query/eq/#std-label-eq-usage-examples
+                    # for the description of relevant server behavior.
+                    op = case v
+                    when Regexp, BSON::Regexp::Raw
+                      '$regex'
+                    else
+                      '$eq'
+                    end
+                    # If there isn't an $eq/$regex operator already in the
+                    # query, transform the new value into an operator
+                    # expression and add it to the existing hash. Otherwise
+                    # add the new condition with $and to the top level.
+                    if existing.key?(op)
                       raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
                       result['$and'] ||= []
                       result['$and'] << {k => v}
                     else
-                      result[k].update('$eq' => v)
+                      existing.update(op => v)
                     end
                   end
                 else
                   # Existing value is a simple value.
-                  # If we are adding an operator, and the operator is not $eq,
-                  # convert existing value into $eq and add the new operator
-                  # to the same hash. Otherwise add the new condition with $and
-                  # to the top level.
-                  if v.is_a?(Hash) && !v.key?('$eq')
-                    result[k] = {'$eq' => result[k]}.update(v)
+                  # See the notes above about transformations to $eq/$regex.
+                  op = case existing
+                  when Regexp, BSON::Regexp::Raw
+                    '$regex'
+                  else
+                    '$eq'
+                  end
+                  if v.is_a?(Hash) && !v.key?(op)
+                    result[k] = {op => existing}.update(v)
                   else
                     raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
                     result['$and'] ||= []

data/lib/mongoid/criteria/queryable/selectable.rb

@@ -195,11 +195,11 @@ module Mongoid
           end
 
           typed_override(criterion, "$exists") do |value|
-            ::Boolean.evolve(value)
+            Mongoid::Boolean.evolve(value)
           end
         end
         key :exists, :override, "$exists" do |value|
-          ::Boolean.evolve(value)
+          Mongoid::Boolean.evolve(value)
         end
 
         # Add a $geoIntersects or $geoWithin selection. Symbol operators must
@@ -882,19 +882,19 @@ module Mongoid
           if criterion.nil?
             raise ArgumentError, 'Criterion cannot be nil here'
           end
+          unless Hash === criterion
+            raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
+          end
 
+          normalized = _mongoid_expand_keys(criterion)
           clone.tap do |query|
-            unless Hash === criterion
-              raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
-            end
-            criterion.each do |field, value|
+            normalized.each do |field, value|
               field_s = field.to_s
               if field_s[0] == ?$
                 # Query expression-level operator, like $and or $where
                 query.add_operator_expression(field_s, value)
               else
-                exp_field, exp_value = expand_one_condition(field, value)
-                query.add_field_expression(exp_field, exp_value)
+                query.add_field_expression(field, value)
               end
             end
             query.reset_strategies!

data/lib/mongoid/criteria/queryable/selector.rb

@@ -123,10 +123,6 @@ module Mongoid
               # {'foo' => {'$lt' => 5}}. This step should be done after all
               # value-based processing is complete.
               if key.is_a?(Key)
-                if serializer && evolved_value != value
-                  raise NotImplementedError, "This method is not prepared to handle key being a Key and serializer being not nil"
-                end
-
                 evolved_value = key.transform_value(evolved_value)
               end
 

data/lib/mongoid/criteria.rb

@@ -336,16 +336,15 @@ module Mongoid
     #
     # @since 1.0.0
     def only(*args)
-      return clone if args.flatten.empty?
       args = args.flatten
+      return clone if args.empty?
       if (args & Fields::IDS).empty?
         args.unshift(:_id)
       end
       if klass.hereditary?
-        super(*args.push(klass.discriminator_key.to_sym))
-      else
-        super(*args)
+        args.push(klass.discriminator_key.to_sym)
       end
+      super(*args)
     end
 
     # Set the read preference for the criteria.
@@ -375,7 +374,7 @@ module Mongoid
     #
     # @since 4.0.3
     def without(*args)
-      args -= Fields::IDS
+      args -= id_fields
       super(*args)
     end