mongoid 7.0.5 → 8.1.5

data/lib/mongoid/attributes/projector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # This module defines projection helpers.
+    #
+    # Projection rules are rather non-trivial. See
+    # https://www.mongodb.com/docs/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/readonly.rb

@@ -1,8 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Attributes
 
-    # This module defines behaviour for readonly attributes.
+    # This module defines behavior for readonly attributes.
     module Readonly
       extend ActiveSupport::Concern
 
@@ -16,12 +17,10 @@ module Mongoid
       # @example Can we write the attribute?
       #   model.attribute_writable?(:title)
       #
-      # @param [ String, Symbol ] name The name of the field.
+      # @param [ String | Symbol ] name The name of the field.
       #
-      # @return [ true, false ] If the document is new, or if the field is not
+      # @return [ true | false ] If the document is new, or if the field is not
       #   readonly.
-      #
-      # @since 3.0.0
       def attribute_writable?(name)
         new_record? || (!readonly_attributes.include?(name) && _loaded?(name))
       end
@@ -62,9 +61,7 @@ module Mongoid
         #     attr_readonly :name, :genre
         #   end
         #
-        # @param [ Array<Symbol> ] names The names of the fields.
-        #
-        # @since 3.0.0
+        # @param [ Symbol... ] *names The names of the fields.
         def attr_readonly(*names)
           names.each do |name|
             readonly_attributes << database_field_name(name)

data/lib/mongoid/attributes.rb

@@ -1,8 +1,10 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 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
@@ -23,11 +25,9 @@ module Mongoid
     # @example Is the attribute present?
     #   person.attribute_present?("title")
     #
-    # @param [ String, Symbol ] name The name of the attribute.
-    #
-    # @return [ true, false ] True if present, false if not.
+    # @param [ String | Symbol ] name The name of the attribute.
     #
-    # @since 1.0.0
+    # @return [ true | false ] True if present, false if not.
     def attribute_present?(name)
       attribute = read_raw_attribute(name)
       !attribute.blank? || attribute == false
@@ -41,8 +41,6 @@ module Mongoid
     #   document.attributes_before_type_cast
     #
     # @return [ Hash ] The uncast attributes.
-    #
-    # @since 3.1.0
     def attributes_before_type_cast
       @attributes_before_type_cast ||= {}
     end
@@ -52,11 +50,9 @@ module Mongoid
     # @example Does the document have the attribute?
     #   model.has_attribute?(:name)
     #
-    # @param [ String, Symbol ] name The name of the attribute.
+    # @param [ String | Symbol ] name The name of the attribute.
     #
-    # @return [ true, false ] If the key is present in the attributes.
-    #
-    # @since 3.0.0
+    # @return [ true | false ] If the key is present in the attributes.
     def has_attribute?(name)
       attributes.key?(name.to_s)
     end
@@ -67,12 +63,10 @@ module Mongoid
     # @example Does the document have the attribute before it was assigned?
     #   model.has_attribute_before_type_cast?(:name)
     #
-    # @param [ String, Symbol ] name The name of the attribute.
+    # @param [ String | Symbol ] name The name of the attribute.
     #
-    # @return [ true, false ] If the key is present in the
+    # @return [ true | false ] If the key is present in the
     #   attributes_before_type_cast.
-    #
-    # @since 3.1.0
     def has_attribute_before_type_cast?(name)
       attributes_before_type_cast.key?(name.to_s)
     end
@@ -86,18 +80,32 @@ module Mongoid
     # @example Read an attribute (alternate syntax.)
     #   person[:title]
     #
-    # @param [ String, Symbol ] name The name of the attribute to get.
+    # @param [ String | Symbol ] name The name of the attribute to get.
     #
     # @return [ Object ] The value of the attribute.
-    #
-    # @since 1.0.0
     def read_attribute(name)
       field = fields[name.to_s]
       raw = read_raw_attribute(name)
-      field ? field.demongoize(raw) : raw
+      process_raw_attribute(name.to_s, raw, field)
     end
     alias :[] :read_attribute
 
+
+    # Process the raw attribute values just read from the documents attributes.
+    #
+    # @param [ String ] name The name of the attribute to get.
+    # @param [ Object ] raw The raw attribute value.
+    # @param [ Field | nil ] field The field to use for demongoization or nil.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @api private
+    def process_raw_attribute(name, raw, field)
+      value = field ? field.demongoize(raw) : raw
+      attribute_will_change!(name) if value.resizable?
+      value
+    end
+
     # Read a value from the attributes before type cast. If the value has not
     # yet been assigned then this will return the attribute's existing value
     # using read_raw_attribute.
@@ -105,12 +113,10 @@ module Mongoid
     # @example Read an attribute before type cast.
     #   person.read_attribute_before_type_cast(:price)
     #
-    # @param [ String, Symbol ] name The name of the attribute to get.
+    # @param [ String | Symbol ] name The name of the attribute to get.
     #
     # @return [ Object ] The value of the attribute before type cast, if
     #   available. Otherwise, the value of the attribute.
-    #
-    # @since 3.1.0
     def read_attribute_before_type_cast(name)
       attr = name.to_s
       if attributes_before_type_cast.key?(attr)
@@ -126,13 +132,12 @@ module Mongoid
     # @example Remove the attribute.
     #   person.remove_attribute(:title)
     #
-    # @param [ String, Symbol ] name The name of the attribute to remove.
+    # @param [ String | Symbol ] name The name of the attribute to remove.
     #
     # @raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
     #   to being flagged as reaodnly.
-    #
-    # @since 1.0.0
     def remove_attribute(name)
+      validate_writable_field_name!(name.to_s)
       as_writable_attribute!(name) do |access|
         _assigning do
           attribute_will_change!(access)
@@ -152,29 +157,46 @@ module Mongoid
     # @example Write the attribute (alternate syntax.)
     #   person[:title] = "Mr."
     #
-    # @param [ String, Symbol ] name The name of the attribute to update.
+    # @param [ String | Symbol ] name The name of the attribute to update.
     # @param [ Object ] value The value to set for the attribute.
-    #
-    # @since 1.0.0
     def write_attribute(name, value)
-      access = database_field_name(name)
-      if attribute_writable?(access)
+      validate_writable_field_name!(name.to_s)
+
+      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(access, value)
-          localized = fields[access].try(:localized?)
+          localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
-          typed_value = typed_value_for(access, value)
-          unless attributes[access] == typed_value || attribute_changed?(access)
-            attribute_will_change!(access)
+          typed_value = typed_value_for(field_name, value)
+          unless attributes[field_name] == typed_value || attribute_changed?(field_name)
+            attribute_will_change!(field_name)
           end
           if localized
-            attributes[access] ||= {}
-            attributes[access].merge!(typed_value)
+            present = fields[field_name].try(:localize_present?)
+            loc_key, loc_val = typed_value.first
+            if present && loc_val.blank?
+              attributes[field_name]&.delete(loc_key)
+            else
+              attributes[field_name] ||= {}
+              attributes[field_name].merge!(typed_value)
+            end
           else
-            attributes[access] = typed_value
+            attributes[field_name] = typed_value
           end
+
+          # when writing an attribute, also remove it from the unsets,
+          # so that removing then writing doesn't result in a removal.
+          delayed_atomic_unsets.delete(field_name)
+
           typed_value
         end
+      else
+        # TODO: MONGOID-5072
       end
     end
     alias :[]= :write_attribute
@@ -191,8 +213,6 @@ module Mongoid
     #   person.assign_attributes({ :title => "Mr." }, :as => :admin)
     #
     # @param [ Hash ] attrs The new attributes to set.
-    #
-    # @since 2.2.1
     def assign_attributes(attrs = nil)
       _assigning do
         process_attributes(attrs)
@@ -210,8 +230,6 @@ module Mongoid
     #   person.attributes = { :title => "Mr." }
     #
     # @param [ Hash ] attrs The new attributes to set.
-    #
-    # @since 1.0.0
     def write_attributes(attrs = nil)
       assign_attributes(attrs)
     end
@@ -225,15 +243,9 @@ module Mongoid
     #
     # @param [ String ] name The name of the attribute.
     #
-    # @return [ true, false ] If the attribute is missing.
-    #
-    # @since 4.0.0
+    # @return [ true | false ] If the attribute is missing.
     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.
@@ -242,22 +254,12 @@ module Mongoid
     #   document.typed_attributes
     #
     # @return [ Object ] The hash with keys and values of the type-casted attributes.
-    #
-    # @since 6.1.0
     def typed_attributes
       attribute_names.map { |name| [name, send(name)] }.to_h
     end
 
     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
@@ -265,11 +267,9 @@ module Mongoid
     # @example Is the string in dot syntax.
     #   model.hash_dot_syntax?
     #
-    # @return [ true, false ] If the string contains a "."
-    #
-    # @since 3.0.15
+    # @return [ true | false ] If the string contains a "."
     def hash_dot_syntax?(string)
-      string.include?(".".freeze)
+      string.include?(".")
     end
 
     # Return the typecasted value for a field.
@@ -277,12 +277,10 @@ module Mongoid
     # @example Get the value typecasted.
     #   person.typed_value_for(:title, :sir)
     #
-    # @param [ String, Symbol ] key The field name.
+    # @param [ String | Symbol ] key The field name.
     # @param [ Object ] value The uncast value.
     #
     # @return [ Object ] The cast value.
-    #
-    # @since 1.0.0
     def typed_value_for(key, value)
       fields.key?(key) ? fields[key].mongoize(value) : value.mongoize
     end
@@ -291,11 +289,17 @@ 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)
+        if fields.key?(normalized)
+          attributes[normalized]
+        else
+          attributes.__nested__(normalized)
+        end
       else
         attributes[normalized]
       end
@@ -316,45 +320,44 @@ module Mongoid
       #
       # @param [ Symbol ] name The new name.
       # @param [ Symbol ] original The original name.
-      #
-      # @since 2.3.0
       def alias_attribute(name, original)
         aliased_fields[name.to_s] = original.to_s
-        class_eval <<-RUBY
-          alias #{name}  #{original}
-          alias #{name}= #{original}=
-          alias #{name}? #{original}?
-          alias #{name}_change   #{original}_change
-          alias #{name}_changed? #{original}_changed?
-          alias reset_#{name}!   reset_#{original}!
-          alias reset_#{name}_to_default!   reset_#{original}_to_default!
-          alias #{name}_was      #{original}_was
-          alias #{name}_will_change! #{original}_will_change!
-          alias #{name}_before_type_cast #{original}_before_type_cast
-        RUBY
-      end
-    end
 
-    private
+        alias_method name, original
+        alias_method "#{name}=", "#{original}="
+        alias_method "#{name}?", "#{original}?"
+        alias_method "#{name}_change", "#{original}_change"
+        alias_method "#{name}_changed?", "#{original}_changed?"
+        alias_method "reset_#{name}!", "reset_#{original}!"
+        alias_method "reset_#{name}_to_default!", "reset_#{original}_to_default!"
+        alias_method "#{name}_was", "#{original}_was"
+        alias_method "#{name}_will_change!", "#{original}_will_change!"
+        alias_method "#{name}_before_type_cast", "#{original}_before_type_cast"
+      end
 
-    # Validates an attribute value. This provides validation checking if
-    # the value is valid for given a field.
-    # For now, only Hash and Array fields are validated.
-    #
-    # @param [ String, Symbol ] access The name of the attribute to validate.
-    # @param [ Object ] value The to be validated.
-    #
-    # @since 3.0.10
-    def validate_attribute_value(access, value)
-      return unless fields[access] && value
-      validatable_types = [ Hash, Array ]
-      if validatable_types.include? fields[access].type
-        unless value.is_a? fields[access].type
-          raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
+      # 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
+
     def lookup_attribute_presence(name, value)
       if localized_fields.has_key?(name) && value
         value = localized_fields[name].send(:lookup, value)

data/lib/mongoid/cacheable.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
 
-  # Encapsulates behaviour around caching.
-  #
-  # @since 6.0.0
+  # Encapsulates behavior around caching.
   module Cacheable
     extend ActiveSupport::Concern
 
@@ -16,21 +15,19 @@ module Mongoid
     # plural model name.
     #
     # If new_record?     - will append /new
-    # If not             - will append /id-updated_at.to_s(cache_timestamp_format)
+    # If not             - will append /id-updated_at.to_formatted_s(cache_timestamp_format)
     # Without updated_at - will append /id
     #
-    # This is usually called insode a cache() block
+    # This is usually called inside a cache() block
     #
     # @example Returns the cache key
     #   document.cache_key
     #
     # @return [ String ] the string with or without updated_at
-    #
-    # @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_formatted_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
+      "#{model_key}/#{_id}"
     end
   end
 end