activerecord 7.0.2.4 → 7.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e29d479c2e518da1d71d9d4af8fd0a29f3d525c76b8b6da432bf92b4f3fc5937
-  data.tar.gz: 6ae42cea0de42d900282043d6f8b46d32063afc1e7b07c62e709bdb4790b9098
+  metadata.gz: 18986b8f256d988204ff7b48287980a88e138a4280d637cf28310e551082987d
+  data.tar.gz: 8054f80c87f48a264d08f006b789e2c3680155e0ed7fb5a5698d962f7ff0d8bb
 SHA512:
-  metadata.gz: 68b23c7d23af6259f29df0bcdde5c3cd16d2a9912c6984cfdc490eedf7b607925282d99e26291d4685e13962a33d358d2044dce7fd13dbed25cb4ae988cb371b
-  data.tar.gz: 28bddb773ff8bdafb4f0663f2a56598f4450cdcf00372a779ca7e3c46a6c1348350c38a07b40f91ff8f6256297415d8c71b8d3f56ac1fba31b1e72edcd6c91b5
+  metadata.gz: 8a01f7c0f730da3cfc0bfcda6f7c9a2e3f4d2747137f87175671d79021643f09f34fcf373cb400f247159d6551589f51de73241f10ac3373159865db6e04f0fc
+  data.tar.gz: a4aa9659e71f1e8c11914727eacd07061128f8d68b0f609c08b272025c9923419a3a58f6d789da6a467258cad69795e3e0aa265f34ffcce4b39d8bd0cb5d8386

data/CHANGELOG.md

@@ -1,3 +1,175 @@
+## Rails 7.0.4 (September 09, 2022) ##
+
+*   Symbol is allowed by default for YAML columns
+
+    *Étienne Barrié*
+
+*   Fix `ActiveRecord::Store` to serialize as a regular Hash
+
+    Previously it would serialize as an `ActiveSupport::HashWithIndifferentAccess`
+    which is wasteful and cause problem with YAML safe_load.
+
+    *Jean Boussier*
+
+*   Add `timestamptz` as a time zone aware type for PostgreSQL
+
+    This is required for correctly parsing `timestamp with time zone` values in your database.
+
+    If you don't want this, you can opt out by adding this initializer:
+
+    ```ruby
+    ActiveRecord::Base.time_zone_aware_types -= [:timestamptz]
+    ```
+
+    *Alex Ghiculescu*
+
+*   Fix supporting timezone awareness for `tsrange` and `tstzrange` array columns.
+
+    ```ruby
+    # In database migrations
+    add_column :shops, :open_hours, :tsrange, array: true
+    # In app config
+    ActiveRecord::Base.time_zone_aware_types += [:tsrange]
+    # In the code times are properly converted to app time zone
+    Shop.create!(open_hours: [Time.current..8.hour.from_now])
+    ```
+
+    *Wojciech Wnętrzak*
+
+*   Resolve issue where a relation cache_version could be left stale.
+
+    Previously, when `reset` was called on a relation object it did not reset the cache_versions
+    ivar. This led to a confusing situation where despite having the correct data the relation
+    still reported a stale cache_version.
+
+    Usage:
+
+    ```ruby
+    developers = Developer.all
+    developers.cache_version
+
+    Developer.update_all(updated_at: Time.now.utc + 1.second)
+
+    developers.cache_version # Stale cache_version
+    developers.reset
+    developers.cache_version # Returns the current correct cache_version
+    ```
+
+    Fixes #45341.
+
+    *Austen Madden*
+
+*   Fix `load_async` when called on an association proxy.
+
+    Calling `load_async` directly an association would schedule
+    a query but never use it.
+
+    ```ruby
+    comments = post.comments.load_async # schedule a query
+    comments.to_a # perform an entirely new sync query
+    ```
+
+    Now it does use the async query, however note that it doesn't
+    cause the association to be loaded.
+
+    *Jean Boussier*
+
+*   Fix eager loading for models without primary keys.
+
+    *Anmol Chopra*, *Matt Lawrence*, and *Jonathan Hefner*
+
+*   `rails db:schema:{dump,load}` now checks `ENV["SCHEMA_FORMAT"]` before config
+
+    Since `rails db:structure:{dump,load}` was deprecated there wasn't a simple
+    way to dump a schema to both SQL and Ruby formats. You can now do this with
+    an environment variable. For example:
+
+    ```
+    SCHEMA_FORMAT=sql rake db:schema:dump
+    ```
+
+    *Alex Ghiculescu*
+
+*   Fix Hstore deserialize regression.
+
+    *edsharp*
+
+
+## Rails 7.0.3.1 (July 12, 2022) ##
+
+*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+
+    This adds two new configuration options The configuration options are as
+    follows:
+    
+    * `config.active_storage.use_yaml_unsafe_load`
+    
+    When set to true, this configuration option tells Rails to use the old
+    "unsafe" YAML loading strategy, maintaining the existing behavior but leaving
+    the possible escalation vulnerability in place.  Setting this option to true
+    is *not* recommended, but can aid in upgrading.
+    
+    * `config.active_record.yaml_column_permitted_classes`
+    
+    The "safe YAML" loading method does not allow all classes to be deserialized
+    by default.  This option allows you to specify classes deemed "safe" in your
+    application.  For example, if your application uses Symbol and Time in
+    serialized data, you can add Symbol and Time to the allowed list as follows:
+    
+    ```
+    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
+    ```
+
+    [CVE-2022-32224]
+
+
+## Rails 7.0.3 (May 09, 2022) ##
+
+*   Some internal housekeeping on reloads could break custom `respond_to?`
+    methods in class objects that referenced reloadable constants. See
+    [#44125](https://github.com/rails/rails/issues/44125) for details.
+
+    *Xavier Noria*
+
+*   Fixed MariaDB default function support.
+
+    Defaults would be written wrong in "db/schema.rb" and not work correctly
+    if using `db:schema:load`. Further more the function name would be
+    added as string content when saving new records.
+
+    *kaspernj*
+
+*   Fix `remove_foreign_key` with `:if_exists` option when foreign key actually exists.
+
+    *fatkodima*
+
+*   Remove `--no-comments` flag in structure dumps for PostgreSQL
+
+    This broke some apps that used custom schema comments. If you don't want
+    comments in your structure dump, you can use:
+
+    ```ruby
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = ['--no-comments']
+    ```
+
+    *Alex Ghiculescu*
+
+*   Use the model name as a prefix when filtering encrypted attributes from logs.
+
+    For example, when encrypting `Person#name` it will add `person.name` as a filter
+    parameter, instead of just `name`. This prevents unintended filtering of parameters
+    with a matching name in other models.
+
+    *Jorge Manrubia*
+
+*   Fix quoting of `ActiveSupport::Duration` and `Rational` numbers in the MySQL adapter.
+
+    *Kevin McPhillips*
+
+*   Fix `change_column_comment` to preserve column's AUTO_INCREMENT in the MySQL adapter
+
+    *fatkodima*
+
 ## Rails 7.0.2.4 (April 26, 2022) ##
 
 *   No changes.

data/lib/active_record/associations/collection_association.rb

@@ -180,7 +180,7 @@ module ActiveRecord
       end
 
       # Deletes the +records+ and removes them from this association calling
-      # +before_remove+ , +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
+      # +before_remove+, +after_remove+, +before_destroy+ and +after_destroy+ callbacks.
       #
       # Note that this method removes records from the database ignoring the
       # +:dependent+ option.
@@ -320,7 +320,6 @@ module ActiveRecord
         #   * Otherwise, attributes should have the value found in the database
         def merge_target_lists(persisted, memory)
           return persisted if memory.empty?
-          return memory    if persisted.empty?
 
           persisted.map! do |record|
             if mem_record = memory.delete(record)

data/lib/active_record/associations/collection_proxy.rb

@@ -475,7 +475,7 @@ module ActiveRecord
 
       # Deletes the records of the collection directly from the database
       # ignoring the +:dependent+ option. Records are instantiated and it
-      # invokes +before_remove+, +after_remove+ , +before_destroy+ and
+      # invokes +before_remove+, +after_remove+, +before_destroy+, and
       # +after_destroy+ callbacks.
       #
       #   class Person < ActiveRecord::Base
@@ -1108,7 +1108,7 @@ module ActiveRecord
       ].flat_map { |klass|
         klass.public_instance_methods(false)
       } - self.public_instance_methods(false) - [:select] + [
-        :scoping, :values, :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
+        :scoping, :values, :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all, :load_async
       ]
 
       delegate(*delegate_methods, to: :scope)

data/lib/active_record/associations/has_many_association.rb

@@ -79,10 +79,13 @@ module ActiveRecord
             scope.count(:all)
           end
 
-          # If there's nothing in the database and @target has no new records
-          # we are certain the current target is an empty array. This is a
-          # documented side-effect of the method that may avoid an extra SELECT.
-          loaded! if count == 0
+          # If there's nothing in the database, @target should only contain new
+          # records or be an empty array. This is a documented side-effect of
+          # the method that may avoid an extra SELECT.
+          if count == 0
+            target.select!(&:new_record?)
+            loaded!
+          end
 
           [association_scope.limit_value, count].compact.min
         end

data/lib/active_record/associations/join_dependency.rb

@@ -252,35 +252,39 @@ module ActiveRecord
               next
             end
 
-            key = aliases.column_alias(node, node.primary_key)
-            id = row[key]
-            if id.nil?
+            if node.primary_key
+              key = aliases.column_alias(node, node.primary_key)
+              id = row[key]
+            else
+              key = aliases.column_alias(node, node.reflection.join_primary_key.to_s)
+              id = nil # Avoid id-based model caching.
+            end
+
+            if row[key].nil?
               nil_association = ar_parent.association(node.reflection.name)
               nil_association.loaded!
               next
             end
 
-            model = seen[ar_parent][node][id]
-
-            if model
-              construct(model, node, row, seen, model_cache, strict_loading_value)
-            else
+            unless model = seen[ar_parent][node][id]
               model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
-
-              seen[ar_parent][node][id] = model
-              construct(model, node, row, seen, model_cache, strict_loading_value)
+              seen[ar_parent][node][id] = model if id
             end
+
+            construct(model, node, row, seen, model_cache, strict_loading_value)
           end
         end
 
         def construct_model(record, node, row, model_cache, id, strict_loading_value)
           other = record.association(node.reflection.name)
 
-          model = model_cache[node][id] ||=
-            node.instantiate(row, aliases.column_aliases(node)) do |m|
+          unless model = model_cache[node][id]
+            model = node.instantiate(row, aliases.column_aliases(node)) do |m|
               m.strict_loading! if strict_loading_value
               other.set_inverse_instance(m)
             end
+            model_cache[node][id] = model if id
+          end
 
           if node.reflection.collection?
             other.target.push(model)

data/lib/active_record/associations.rb

@@ -432,7 +432,7 @@ module ActiveRecord
       #
       # == Cardinality and associations
       #
-      # Active Record associations can be used to describe one-to-one, one-to-many and many-to-many
+      # Active Record associations can be used to describe one-to-one, one-to-many, and many-to-many
       # relationships between models. Each model uses an association to describe its role in
       # the relation. The #belongs_to association is always used in the model that has
       # the foreign key.
@@ -586,7 +586,7 @@ module ActiveRecord
       #     has_many :birthday_events, ->(user) { where(starts_on: user.birthday) }, class_name: 'Event'
       #   end
       #
-      # Note: Joining, eager loading and preloading of these associations is not possible.
+      # Note: Joining, eager loading, and preloading of these associations is not possible.
       # These operations happen before instance creation and the scope will be called with a +nil+ argument.
       #
       # == Association callbacks
@@ -618,7 +618,7 @@ module ActiveRecord
       #              after_remove: :log_after_remove
       #   end
       #
-      # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
+      # Possible callbacks are: +before_add+, +after_add+, +before_remove+, and +after_remove+.
       #
       # If any of the +before_add+ callbacks throw an exception, the object will not be
       # added to the collection.
@@ -628,15 +628,15 @@ module ActiveRecord
       #
       # Note: To trigger remove callbacks, you must use +destroy+ / +destroy_all+ methods. For example:
       #
-      #   * <tt>firm.clients.destroy(client)</tt>
-      #   * <tt>firm.clients.destroy(*clients)</tt>
-      #   * <tt>firm.clients.destroy_all</tt>
+      # * <tt>firm.clients.destroy(client)</tt>
+      # * <tt>firm.clients.destroy(*clients)</tt>
+      # * <tt>firm.clients.destroy_all</tt>
       #
       # +delete+ / +delete_all+ methods like the following do *not* trigger remove callbacks:
       #
-      #   * <tt>firm.clients.delete(client)</tt>
-      #   * <tt>firm.clients.delete(*clients)</tt>
-      #   * <tt>firm.clients.delete_all</tt>
+      # * <tt>firm.clients.delete(client)</tt>
+      # * <tt>firm.clients.delete(*clients)</tt>
+      # * <tt>firm.clients.delete_all</tt>
       #
       # == Association extensions
       #
@@ -1332,7 +1332,7 @@ module ActiveRecord
         # === Extensions
         #
         # The +extension+ argument allows you to pass a block into a has_many
-        # association. This is useful for adding new finders, creators and other
+        # association. This is useful for adding new finders, creators, and other
         # factory-type methods to be used as part of the association.
         #
         # Extension examples:
@@ -1415,8 +1415,8 @@ module ActiveRecord
         # [:disable_joins]
         #   Specifies whether joins should be skipped for an association. If set to true, two or more queries
         #   will be generated. Note that in some cases, if order or limit is applied, it will be done in-memory
-        #   due to database limitations. This option is only applicable on `has_many :through` associations as
-        #   `has_many` alone do not perform a join.
+        #   due to database limitations. This option is only applicable on <tt>has_many :through</tt> associations as
+        #   +has_many+ alone do not perform a join.
         # [:source]
         #   Specifies the source association name used by #has_many <tt>:through</tt> queries.
         #   Only use it if the name cannot be inferred from the association.
@@ -1580,8 +1580,8 @@ module ActiveRecord
         # [:disable_joins]
         #   Specifies whether joins should be skipped for an association. If set to true, two or more queries
         #   will be generated. Note that in some cases, if order or limit is applied, it will be done in-memory
-        #   due to database limitations. This option is only applicable on `has_one :through` associations as
-        #   `has_one` alone does not perform a join.
+        #   due to database limitations. This option is only applicable on <tt>has_one :through</tt> associations as
+        #   +has_one+ alone does not perform a join.
         # [:source]
         #   Specifies the source association name used by #has_one <tt>:through</tt> queries.
         #   Only use it if the name cannot be inferred from the association.
@@ -1904,7 +1904,7 @@ module ActiveRecord
         #
         # The +extension+ argument allows you to pass a block into a
         # has_and_belongs_to_many association. This is useful for adding new
-        # finders, creators and other factory-type methods to be used as part of
+        # finders, creators, and other factory-type methods to be used as part of
         # the association.
         #
         # Extension examples:

data/lib/active_record/attribute_methods/serialization.rb

@@ -24,38 +24,6 @@ module ActiveRecord
         # The serialization format may be YAML, JSON, or any custom format using a
         # custom coder class.
         #
-        # === Serialization formats
-        #
-        #   serialize attr_name [, class_name_or_coder]
-        #
-        #                        |                           |  database storage   |
-        #   class_name_or_coder  | attribute read/write type | serialized | NULL   |
-        #   ---------------------+---------------------------+------------+--------+
-        #     <not given>        | any value that supports   |    YAML    |        |
-        #                        |   .to_yaml                |            |        |
-        #                        |                           |            |        |
-        #   Array                | Array **                  |    YAML    |  []    |
-        #                        |                           |            |        |
-        #   Hash                 | Hash **                   |    YAML    |  {}    |
-        #                        |                           |            |        |
-        #   JSON                 | any value that supports   |    JSON    |        |
-        #                        |   .to_json                |            |        |
-        #                        |                           |            |        |
-        #   <custom coder class> | any value supported by    |   custom   | custom |
-        #                        | the custom coder class    |            |        |
-        #
-        # ** If +class_name_or_coder+ is +Array+ or +Hash+, values retrieved will
-        # always be of that type, and any value assigned must be of that type or
-        # +SerializationTypeMismatch+ will be raised.
-        #
-        # ==== Custom coders
-        # A custom coder class or module may be given. This must have +self.load+
-        # and +self.dump+ class/module methods. <tt>self.dump(object)</tt> will be called
-        # to serialize an object and should return the serialized value to be
-        # stored in the database (+nil+ to store as +NULL+). <tt>self.load(string)</tt>
-        # will be called to reverse the process and load (unserialize) from the
-        # database.
-        #
         # Keep in mind that database adapters handle certain serialization tasks
         # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
         # converted between JSON object/array syntax and Ruby +Hash+ or +Array+
@@ -67,55 +35,71 @@ module ActiveRecord
         #
         # ==== Parameters
         #
-        # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, may be be +Array+ or +Hash+ or
-        #   +JSON+ or a custom coder class or module which responds to +.load+
-        #   and +.dump+. See table above.
+        # * +attr_name+ - The name of the attribute to serialize.
+        # * +class_name_or_coder+ - Optional. May be one of the following:
+        #   * <em>default</em> - The attribute value will be serialized as YAML.
+        #     The attribute value must respond to +to_yaml+.
+        #   * +Array+ - The attribute value will be serialized as YAML, but an
+        #     empty +Array+ will be serialized as +NULL+. The attribute value
+        #     must be an +Array+.
+        #   * +Hash+ - The attribute value will be serialized as YAML, but an
+        #     empty +Hash+ will be serialized as +NULL+. The attribute value
+        #     must be a +Hash+.
+        #   * +JSON+ - The attribute value will be serialized as JSON. The
+        #     attribute value must respond to +to_json+.
+        #   * <em>custom coder</em> - The attribute value will be serialized
+        #     using the coder's <tt>dump(value)</tt> method, and will be
+        #     deserialized using the coder's <tt>load(string)</tt> method. The
+        #     +dump+ method may return +nil+ to serialize the value as +NULL+.
         #
         # ==== Options
         #
-        # +default+ The default value to use when no value is provided. If this option
-        # is not passed, the previous default value (if any) will be used.
-        # Otherwise, the default will be +nil+.
+        # * +:default+ - The default value to use when no value is provided. If
+        #   this option is not passed, the previous default value (if any) will
+        #   be used. Otherwise, the default will be +nil+.
+        #
+        # ==== Examples
         #
-        # ==== Example
+        # ===== Serialize the +preferences+ attribute using YAML
         #
-        #   # Serialize a preferences attribute using YAML coder.
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
         #
-        #   # Serialize preferences using JSON as coder.
+        # ===== Serialize the +preferences+ attribute using JSON
+        #
         #   class User < ActiveRecord::Base
         #     serialize :preferences, JSON
         #   end
         #
-        #   # Serialize preferences as Hash using YAML coder.
+        # ===== Serialize the +preferences+ +Hash+ using YAML
+        #
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Hash
         #   end
         #
-        #   # Serialize preferences using a custom coder.
+        # ===== Serialize the +preferences+ attribute using a custom coder
+        #
         #   class Rot13JSON
         #     def self.rot13(string)
         #       string.tr("a-zA-Z", "n-za-mN-ZA-M")
         #     end
         #
-        #     # returns serialized string that will be stored in the database
-        #     def self.dump(object)
-        #       ActiveSupport::JSON.encode(object).rot13
+        #     # Serializes an attribute value to a string that will be stored in the database.
+        #     def self.dump(value)
+        #       rot13(ActiveSupport::JSON.dump(value))
         #     end
         #
-        #     # reverses the above, turning the serialized string from the database
-        #     # back into its original value
+        #     # Deserializes a string from the database to an attribute value.
         #     def self.load(string)
-        #       ActiveSupport::JSON.decode(string.rot13)
+        #       ActiveSupport::JSON.load(rot13(string))
         #     end
         #   end
         #
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Rot13JSON
         #   end
+        #
         def serialize(attr_name, class_name_or_coder = Object, **options)
           # When ::JSON is used, force it to go through the Active Support JSON encoder
           # to ensure special objects (e.g. Active Record models) are dumped correctly

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -19,6 +19,8 @@ module ActiveRecord
 
           if value.is_a?(Hash)
             set_time_zone_without_conversion(super)
+          elsif value.is_a?(Range)
+            Range.new(user_input_in_time_zone(value.begin), user_input_in_time_zone(value.end), value.exclude_end?)
           elsif value.respond_to?(:in_time_zone)
             begin
               super(user_input_in_time_zone(value)) || super
@@ -40,6 +42,8 @@ module ActiveRecord
               value.in_time_zone
             elsif value.respond_to?(:infinite?) && value.infinite?
               value
+            elsif value.is_a?(Range)
+              Range.new(convert_time_to_time_zone(value.begin), convert_time_to_time_zone(value.end), value.exclude_end?)
             else
               map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
             end

data/lib/active_record/attribute_methods.rb

@@ -97,7 +97,7 @@ module ActiveRecord
           super
         else
           # If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
-          # defines its own attribute method, then we don't want to overwrite that.
+          # defines its own attribute method, then we don't want to override that.
           defined = method_defined_within?(method_name, superclass, Base) &&
             ! superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
           defined || super

data/lib/active_record/base.rb

@@ -137,7 +137,7 @@ module ActiveRecord # :nodoc:
   #   anonymous = User.new(name: "")
   #   anonymous.name? # => false
   #
-  # Query methods will also respect any overwrites of default accessors:
+  # Query methods will also respect any overrides of default accessors:
   #
   #   class User
   #     # Has admin boolean column
@@ -151,8 +151,8 @@ module ActiveRecord # :nodoc:
   #   user.read_attribute(:admin)  # => true, gets the column value
   #   user[:admin] # => true, also gets the column value
   #
-  #   user.admin   # => false, due to the getter overwrite
-  #   user.admin?  # => false, due to the getter overwrite
+  #   user.admin   # => false, due to the getter override
+  #   user.admin?  # => false, due to the getter override
   #
   # == Accessing attributes before they have been typecasted
   #

data/lib/active_record/coders/yaml_column.rb

@@ -47,11 +47,19 @@ module ActiveRecord
 
         if YAML.respond_to?(:unsafe_load)
           def yaml_load(payload)
-            YAML.unsafe_load(payload)
+            if ActiveRecord.use_yaml_unsafe_load
+              YAML.unsafe_load(payload)
+            else
+              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
+            end
           end
         else
           def yaml_load(payload)
-            YAML.load(payload)
+            if ActiveRecord.use_yaml_unsafe_load
+              YAML.load(payload)
+            else
+              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
+            end
           end
         end
     end

data/lib/active_record/connection_adapters/abstract/connection_handler.rb

@@ -40,7 +40,7 @@ module ActiveRecord
     # but the Book model connects to a separate database called "library_db"
     # (this can even be a database on a different machine).
     #
-    # Book, ScaryBook and GoodBook will all use the same connection pool to
+    # Book, ScaryBook, and GoodBook will all use the same connection pool to
     # "library_db" while Author, BankAccount, and any other models you create
     # will use the default connection pool to "my_application".
     #

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -202,6 +202,10 @@ module ActiveRecord
 
         def index_options(table_name)
           index_options = as_options(index)
+
+          # legacy reference index names are used on versions 6.0 and earlier
+          return index_options if options[:_uses_legacy_reference_index_name]
+
           index_options[:name] ||= polymorphic_index_name(table_name) if polymorphic
           index_options
         end

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1071,9 +1071,9 @@ module ActiveRecord
       # [<tt>:name</tt>]
       #   The constraint name. Defaults to <tt>fk_rails_<identifier></tt>.
       # [<tt>:on_delete</tt>]
-      #   Action that happens <tt>ON DELETE</tt>. Valid values are +:nullify+, +:cascade+ and +:restrict+
+      #   Action that happens <tt>ON DELETE</tt>. Valid values are +:nullify+, +:cascade+, and +:restrict+
       # [<tt>:on_update</tt>]
-      #   Action that happens <tt>ON UPDATE</tt>. Valid values are +:nullify+, +:cascade+ and +:restrict+
+      #   Action that happens <tt>ON UPDATE</tt>. Valid values are +:nullify+, +:cascade+, and +:restrict+
       # [<tt>:if_not_exists</tt>]
       #   Specifies if the foreign key already exists to not try to re-add it. This will avoid
       #   duplicate column errors.
@@ -1125,7 +1125,7 @@ module ActiveRecord
       #   The name of the table that contains the referenced primary key.
       def remove_foreign_key(from_table, to_table = nil, **options)
         return unless supports_foreign_keys?
-        return if options[:if_exists] == true && !foreign_key_exists?(from_table, to_table)
+        return if options.delete(:if_exists) == true && !foreign_key_exists?(from_table, to_table)
 
         fk_name_to_delete = foreign_key_for!(from_table, to_table: to_table, **options).name
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -36,7 +36,7 @@ module ActiveRecord
       include Savepoints
 
       SIMPLE_INT = /\A\d+\z/
-      COMMENT_REGEX = %r{(?:--.*\n)*|/\*(?:[^*]|\*[^/])*\*/}m
+      COMMENT_REGEX = %r{(?:--.*\n)|/\*(?:[^*]|\*[^/])*\*/}m
 
       attr_accessor :pool
       attr_reader :visitor, :owner, :logger, :lock
@@ -224,14 +224,14 @@ module ActiveRecord
         @pool.connection_class
       end
 
-      # The role (ie :writing) for the current connection. In a
-      # non-multi role application, `:writing` is returned.
+      # The role (e.g. +:writing+) for the current connection. In a
+      # non-multi role application, +:writing+ is returned.
       def role
         @pool.role
       end
 
-      # The shard (ie :default) for the current connection. In
-      # a non-sharded application, `:default` is returned.
+      # The shard (e.g. +:default+) for the current connection. In
+      # a non-sharded application, +:default+ is returned.
       def shard
         @pool.shard
       end