mongoid 9.0.11 → 9.1.1

data/lib/mongoid/factory.rb

@@ -5,7 +5,7 @@ module Mongoid
   module Factory
     extend self
 
-    # A helper class for instantiating a model using either it's type
+    # A helper class for instantiating a model using either its type
     # class directly, or via a type class specified via a discriminator
     # key.
     #
@@ -79,7 +79,7 @@ module Mongoid
       # @return [ Document ] The instantiated document.
       def instantiate_without_type(execute_callbacks)
         klass.instantiate_document(attributes, selected_fields, execute_callbacks: execute_callbacks).tap do |obj|
-          if criteria&.association && criteria&.parent_document
+          if criteria&.association && criteria.parent_document
             obj.set_relation(criteria.association.inverse, criteria.parent_document)
           end
         end
@@ -99,7 +99,7 @@ module Mongoid
         )
       end
 
-      # Retreive the `Class` instance of the requested type, either by finding it
+      # Retrieve the `Class` instance of the requested type, either by finding it
       # in the `klass` discriminator mapping, or by otherwise finding a
       # Document model with the given name.
       #
@@ -175,12 +175,8 @@ module Mongoid
     def execute_build(klass, attributes = nil, options = {})
       attributes ||= {}
       dvalue = attributes[klass.discriminator_key] || attributes[klass.discriminator_key.to_sym]
-      type = klass.get_discriminator_mapping(dvalue)
-      if type
-        type.construct_document(attributes, options)
-      else
-        klass.construct_document(attributes, options)
-      end
+      type = klass.get_discriminator_mapping(dvalue) || klass
+      type.construct_document(attributes, options)
     end
 
     # Builds a new +Document+ from the supplied attributes loaded from the

data/lib/mongoid/field_readable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mongoid
+  # Reads the value of a field name from a document without dispatching the
+  # name as an arbitrary method.
+  #
+  # Field names may come from application input, where a name like +destroy+
+  # or +attributes+ would delete the document or disclose its contents.
+  # Declared field and association names are validated when they are declared
+  # (see Mongoid.destructive_fields), so a name that resolves to one of them
+  # is safe to send to a document. Any other name is read from the attributes
+  # hash, which is what the database-backed query contexts do.
+  #
+  # @api private
+  module FieldReadable
+    private
+
+    # Read the value of the given field name from the given document.
+    #
+    # @param [ Document ] document The document to read from.
+    # @param [ String | Symbol ] name The name of the field.
+    #
+    # @return [ Object | nil ] The value of the field, or nil when the name
+    #   is neither a declared field nor present in the attributes.
+    def read_field_value(document, name)
+      name = name.to_s
+      # A blank name cannot name a field. Return nil, which is what reading
+      # one has always done.
+      return nil if name.blank?
+
+      if (meth = readable_method_for(document.class, name))
+        document.public_send(meth)
+      else
+        document.attributes[document.class.database_field_name(name)]
+      end
+    end
+
+    # Resolve the given name to a method that is declared by the given class,
+    # and therefore safe to send to one of its instances.
+    #
+    # @param [ Class ] klass The document class.
+    # @param [ String ] name The name of the field.
+    #
+    # @return [ String | nil ] The method to send, or nil when the name is
+    #   not declared by the class.
+    def readable_method_for(klass, name)
+      # Fields, associations, and field aliases each define a reader of their
+      # own name. Note that associations must be resolved before aliases: a
+      # belongs_to aliases its own name to its foreign key, and reading
+      # `band` must give the document, not the id.
+      return name if klass.relations.key?(name) ||
+                     klass.fields.key?(name) ||
+                     klass.aliased_fields.key?(name)
+
+      # An association may also be named by its `store_as`, which has no
+      # reader of its own, or by its ids accessor, which does.
+      if (assoc = klass.relations[klass.aliased_associations[name]])
+        return (assoc.store_as == name) ? assoc.name.to_s : name
+      end
+
+      # Localized fields also get a _translations reader, which does not
+      # appear in the fields hash.
+      base = name.delete_suffix(Fields::TRANSLATIONS_SFX)
+      return nil if base == name
+
+      name if klass.fields[klass.database_field_name(base)]&.localized?
+    end
+  end
+end

data/lib/mongoid/fields/encrypted.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Fields

data/lib/mongoid/fields/foreign_key.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Fields
-
     # Represents a BSON document field definition which stores
     # a foreign key that references the ID of another document.
     # Used for association behavior.
     class ForeignKey < Standard
-
       # Adds the atomic changes for this type of resizable field.
       #
       # @example Add the atomic changes.
@@ -23,8 +20,8 @@ module Mongoid
       # @param [ Array ] new_elements The new elements to add.
       # @param [ Array ] old_elements The old elements getting removed.
       def add_atomic_changes(document, name, key, mods, new_elements, old_elements)
-        old = (old_elements || [])
-        new = (new_elements || [])
+        old = old_elements || []
+        new = new_elements || []
         if new.length > old.length
           if new.first(old.length) == old
             document.atomic_array_add_to_sets[key] = new.drop(old.length)
@@ -109,7 +106,7 @@ module Mongoid
       # @return [ true | false ] If the field is a BSON::ObjectId.
       def object_id_field?
         @object_id_field ||=
-            association.polymorphic? ? true : association.klass.using_object_ids?
+          association.polymorphic? || association.klass.using_object_ids?
       end
 
       # Returns true if an array, false if not.
@@ -133,7 +130,7 @@ module Mongoid
       #
       # @return [ Object ] The converted object.
       def mongoize_foreign_key(object)
-        if type == Array || type == Set
+        if [ Array, Set ].include?(type)
           object = object.to_a if type == Set || object.is_a?(Set)
 
           if object.resizable?
@@ -155,7 +152,7 @@ module Mongoid
       # @param [ Document ] doc The document.
       #
       # @return [ Object ] The called proc.
-      def evaluate_default_proc(doc)
+      def evaluate_default_proc(_doc)
         serialize_default(default_val[])
       end
 
@@ -168,7 +165,7 @@ module Mongoid
       #
       # @return [ Fields::Standard ] The field.
       def related_id_field
-        @related_id_field ||= association.klass.fields["_id"]
+        @related_id_field ||= association.klass.fields['_id']
       end
 
       def primary_key_field
@@ -186,7 +183,9 @@ module Mongoid
       # @param [ Object ] object The default.
       #
       # @return [ Object ] The serialized default.
-      def serialize_default(object); object; end
+      def serialize_default(object)
+        object
+      end
     end
   end
 end

data/lib/mongoid/fields/localized.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Fields
-
     # Represents a BSON document field definition which stores
     # different values for different user locale keys in a Ruby
     # hashmap (BSON "Object" type). Used for internationalization
     # (I18n) support.
     class Localized < Standard
-
       # Demongoize the object based on the current locale. Will look in the
       # hash for the current locale.
       #
@@ -21,6 +18,7 @@ module Mongoid
       # @return [ Object ] The value for the current locale.
       def demongoize(object)
         return if object.nil?
+
         case object
         when Hash
           type.demongoize(lookup(object))
@@ -71,6 +69,7 @@ module Mongoid
       # @return [ true | false ] If fallbacks should be used.
       def fallbacks?
         return true if options[:fallbacks].nil?
+
         !!options[:fallbacks]
       end
 
@@ -88,17 +87,18 @@ module Mongoid
         locale = ::I18n.locale
 
         value = if object.key?(locale.to_s)
-          object[locale.to_s]
-        elsif object.key?(locale)
-          object[locale]
-        end
+                  object[locale.to_s]
+                elsif object.key?(locale)
+                  object[locale]
+                end
         return value unless value.nil?
-        if fallbacks? && ::I18n.respond_to?(:fallbacks)
-          fallback_key = ::I18n.fallbacks[locale].find do |loc|
-            object.key?(loc.to_s) || object.key?(loc)
-          end
-          object[fallback_key.to_s] || object[fallback_key]
+
+        return unless fallbacks? && ::I18n.respond_to?(:fallbacks)
+
+        fallback_key = ::I18n.fallbacks[locale].find do |loc|
+          object.key?(loc.to_s) || object.key?(loc)
         end
+        object[fallback_key.to_s] || object[fallback_key]
       end
     end
   end

data/lib/mongoid/fields/standard.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Fields
-
     # Represents a standard field definition (name, type, etc.)
     # used to enforce consistent schema structure to the BSON
     # documents which Mongoid persists.
@@ -27,7 +25,7 @@ module Mongoid
       # @param [ Hash ] mods The current modifications.
       # @param [ Array ] new The new elements to add.
       # @param [ Array ] old The old elements getting removed.
-      def add_atomic_changes(document, name, key, mods, new, old)
+      def add_atomic_changes(_document, _name, key, mods, new, _old)
         mods[key] = new
       end
 
@@ -77,9 +75,9 @@ module Mongoid
         # @todo: Durran, change API in 4.0 to take the class as a parameter.
         # This is here temporarily to address #2529 without changing the
         # constructor signature.
-        if default_val.respond_to?(:call)
-          define_default_method(options[:klass])
-        end
+        return unless default_val.respond_to?(:call)
+
+        define_default_method(options[:klass])
       end
 
       # Does this field do lazy default evaluation?
@@ -140,7 +138,7 @@ module Mongoid
       # @return [ true | false ] If the field's default is pre-processed.
       def pre_processed?
         @pre_processed ||=
-          (options[:pre_processed] || (default_val && !default_val.is_a?(::Proc)))
+          options[:pre_processed] || (default_val && !default_val.is_a?(::Proc))
       end
 
       # Get the type of this field - inferred from the class name.

data/lib/mongoid/fields/validators/macro.rb

@@ -1,27 +1,25 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Fields
     module Validators
-
       # Validates the params passed to the field macro.
       module Macro
         extend self
 
-        OPTIONS = [
-          :as,
-          :default,
-          :identity,
-          :label,
-          :localize,
-          :fallbacks,
-          :association,
-          :pre_processed,
-          :subtype,
-          :type,
-          :overwrite,
-          :encrypt
+        OPTIONS = %i[
+          as
+          default
+          identity
+          label
+          localize
+          fallbacks
+          association
+          pre_processed
+          subtype
+          type
+          overwrite
+          encrypt
         ]
 
         # Validate the field definition.
@@ -46,11 +44,9 @@ module Mongoid
         # @param [ Class ] klass The model class.
         # @param [ Symbol ] name The field name.
         # @param [ Hash ] options The provided options.
-        def validate_relation(klass, name, options = {})
-          [name, "#{name}?".to_sym, "#{name}=".to_sym].each do |n|
-            if Mongoid.destructive_fields.include?(n)
-              raise Errors::InvalidRelation.new(klass, n)
-            end
+        def validate_relation(klass, name, _options = {})
+          [ name, :"#{name}?", :"#{name}=" ].each do |n|
+            raise Errors::InvalidRelation.new(klass, n) if Mongoid.destructive_fields.include?(n)
           end
         end
 
@@ -66,10 +62,8 @@ module Mongoid
         #
         # @api private
         def validate_field_name(klass, name)
-          [name, "#{name}?".to_sym, "#{name}=".to_sym].each do |n|
-            if Mongoid.destructive_fields.include?(n)
-              raise Errors::InvalidField.new(klass, name, n)
-            end
+          [ name, :"#{name}?", :"#{name}=" ].each do |n|
+            raise Errors::InvalidField.new(klass, name, n) if Mongoid.destructive_fields.include?(n)
           end
         end
 
@@ -88,13 +82,10 @@ module Mongoid
         #
         # @api private
         def validate_name_uniqueness(klass, name, options)
-          if !options[:overwrite] && klass.fields.keys.include?(name.to_s)
-            if Mongoid.duplicate_fields_exception
-              raise Errors::InvalidField.new(klass, name, name)
-            else
-              Mongoid.logger.warn("Overwriting existing field #{name} in class #{klass.name}.") if Mongoid.logger
-            end
-          end
+          return unless !options[:overwrite] && klass.fields.keys.include?(name.to_s)
+          raise Errors::InvalidField.new(klass, name, name) if Mongoid.duplicate_fields_exception
+
+          Mongoid.logger.warn("Overwriting existing field #{name} in class #{klass.name}.") if Mongoid.logger
         end
 
         # Validate that the field options are allowed.
@@ -115,9 +106,7 @@ module Mongoid
               raise Errors::InvalidFieldOption.new(klass, name, option, OPTIONS)
             end
 
-            if option == :type && options[option] == Symbol
-              Mongoid::Warnings.warn_symbol_type_deprecated
-            end
+            Mongoid::Warnings.warn_symbol_type_deprecated if option == :type && options[option] == Symbol
           end
         end
       end

data/lib/mongoid/fields/validators.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/fields/validators/macro"
+require 'mongoid/fields/validators/macro'