activerecord 7.0.2.3 → 7.0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0de91ed76122013d066d4709e0ccfdc1ee9c96012a559e9477a189bc2e12a6
-  data.tar.gz: 280656f19da0efe48331c440f692fdc64f07fa5ec4877bb56a97c25d29f0b3f0
+  metadata.gz: 3f2f45fa92947b78ba64cfc800a729cfcab5b893255efef679b686a37c50cd00
+  data.tar.gz: 2bcca713bf8426cf4ffd22e1b832cde62a6cd6caad0f1f9b19996916e88922d5
 SHA512:
-  metadata.gz: 9b5f7757313355a73e4132c0b03fa8126d0e2ae0e6b9e5d83810930cc9fa0c49d5650f5ed2f9f17e4bdaf14ff57e6dc8093698ecf377215f3d81173ff2bcbcd8
-  data.tar.gz: 3fb3c6f7b1f7bebd2adaa2046ada5d4e58528f546870400741abc9e0eda613c1cfc0fafe5477ecf6126b417a82e3bc8e73641037fbd6af8281d76b4254116217
+  metadata.gz: 17fdc443b9f36e8dcba05e56b6c07e88e97266f7c12accb8ac084b37dbf2c134a696fc57b71171fc488ed10fc72fba952672960b7507d14762a1a41f25623df1
+  data.tar.gz: 4dc59bd725e08e3cdf63d5145f2038f6e5c65b5eb40e611a18ef422c516543aa2acfbc893b68f25f39d304111bafd70a131928c4c1e0692e4274e5fdb1567e53

data/CHANGELOG.md

@@ -1,3 +1,83 @@
+## 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.
+
+
 ## Rails 7.0.2.3 (March 08, 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.

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

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.
@@ -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.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

@@ -45,13 +45,15 @@ module ActiveRecord
           raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
         end
 
-        if YAML.respond_to?(:unsafe_load)
-          def yaml_load(payload)
-            YAML.unsafe_load(payload)
-          end
-        else
-          def yaml_load(payload)
-            YAML.load(payload)
+        def yaml_load(payload)
+          if !ActiveRecord.use_yaml_unsafe_load
+            YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
+          else
+            if YAML.respond_to?(:unsafe_load)
+              YAML.unsafe_load(payload)
+            else
+              YAML.load(payload)
+            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

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -711,6 +711,10 @@ module ActiveRecord
             options[:comment] = column.comment
           end
 
+          unless options.key?(:auto_increment)
+            options[:auto_increment] = column.auto_increment?
+          end
+
           td = create_table_definition(table_name)
           cd = td.new_column_definition(column.name, type, **options)
           schema_creation.accept(ChangeColumnDefinition.new(cd, column.name))

data/lib/active_record/connection_adapters/mysql/quoting.rb

@@ -8,7 +8,9 @@ module ActiveRecord
       module Quoting # :nodoc:
         def quote_bound_value(value)
           case value
-          when Numeric
+          when Rational
+            quote(value.to_f.to_s)
+          when Numeric, ActiveSupport::Duration
             quote(value.to_s)
           when BigDecimal
             quote(value.to_s("F"))

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

@@ -158,7 +158,21 @@ module ActiveRecord
             MySQL::TableDefinition.new(self, name, **options)
           end
 
+          def default_type(table_name, field_name)
+            match = create_table_info(table_name).match(/`#{field_name}` (.+) DEFAULT ('|\d+|[A-z]+)/)
+            default_pre = match[2] if match
+
+            if default_pre == "'"
+              :string
+            elsif default_pre&.match?(/^\d+$/)
+              :integer
+            elsif default_pre&.match?(/^[A-z]+$/)
+              :function
+            end
+          end
+
           def new_column_from_field(table_name, field)
+            field_name = field.fetch(:Field)
             type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
             default, default_function = field[:Default], nil
 
@@ -168,9 +182,13 @@ module ActiveRecord
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")
               default, default_function = nil, default
-            elsif type_metadata.type == :text && default
+            elsif type_metadata.type == :text && default&.start_with?("'")
               # strip and unescape quotes
               default = default[1...-1].gsub("\\'", "'")
+            elsif default&.match?(/\A\d/)
+              # Its a number so we can skip the query to check if it is a function
+            elsif default && default_type(table_name, field_name) == :function
+              default, default_function = nil, default
             end
 
             MySQL::Column.new(

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -43,7 +43,7 @@ module ActiveRecord
 
         # Quotes strings for use in SQL input.
         def quote_string(s) # :nodoc:
-          PG::Connection.escape(s)
+          @connection.escape(s)
         end
 
         # Checks the following cases:

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

@@ -528,8 +528,10 @@ module ActiveRecord
             SELECT conname, pg_get_constraintdef(c.oid, true) AS constraintdef, c.convalidated AS valid
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
+            JOIN pg_namespace n ON n.oid = c.connamespace
             WHERE c.contype = 'c'
               AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
           SQL
 
           check_info.map do |row|

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -104,7 +104,7 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # PostgreSQL supports multiple types for DateTimes. By default if you use `datetime`
+      # PostgreSQL supports multiple types for DateTimes. By default, if you use +datetime+
       # in migrations, Rails will translate this to a PostgreSQL "timestamp without time zone".
       # Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to
       # store DateTimes as "timestamp with time zone":
@@ -116,8 +116,8 @@ module ActiveRecord
       #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
       #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type
       #
-      # If you're using :ruby as your config.active_record.schema_format and you change this
-      # setting, you should immediately run bin/rails db:migrate to update the types in your schema.rb.
+      # If you're using +:ruby+ as your +config.active_record.schema_format+ and you change this
+      # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
       class_attribute :datetime_type, default: :timestamp
 
       NATIVE_DATABASE_TYPES = {

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

@@ -60,7 +60,7 @@ module ActiveRecord
         end
 
         def remove_foreign_key(from_table, to_table = nil, **options)
-          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)
 
           to_table ||= options[:to_table]
           options = options.except(:name, :to_table, :validate)

data/lib/active_record/connection_handling.rb

@@ -44,7 +44,7 @@ module ActiveRecord
     #
     #   ActiveRecord::Base.establish_connection(:production)
     #
-    # The exceptions AdapterNotSpecified, AdapterNotFound and +ArgumentError+
+    # The exceptions AdapterNotSpecified, AdapterNotFound, and +ArgumentError+
     # may be returned on an error.
     def establish_connection(config_or_env = nil)
       config_or_env ||= DEFAULT_ENV.call.to_sym
@@ -108,7 +108,7 @@ module ActiveRecord
       connections
     end
 
-    # Connects to a role (ex writing, reading or a custom role) and/or
+    # Connects to a role (e.g. writing, reading, or a custom role) and/or
     # shard for the duration of the block. At the end of the block the
     # connection will be returned to the original role / shard.
     #

data/lib/active_record/core.rb

@@ -60,7 +60,7 @@ module ActiveRecord
       ##
       # :singleton-method:
       # Force enumeration of all columns in SELECT statements.
-      # e.g. `SELECT first_name, last_name FROM ...` instead of `SELECT * FROM ...`
+      # e.g. <tt>SELECT first_name, last_name FROM ...</tt> instead of <tt>SELECT * FROM ...</tt>
       # This avoids +PreparedStatementCacheExpired+ errors when a column is added
       # to the database while the app is running.
       class_attribute :enumerate_columns_in_select_statements, instance_accessor: false, default: false
@@ -238,7 +238,7 @@ module ActiveRecord
       def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
         case ActiveRecord.action_on_strict_loading_violation
         when :raise
-          message = "`#{owner}` is marked for strict_loading. The `#{reflection.klass}` association named `:#{reflection.name}` cannot be lazily loaded."
+          message = reflection.strict_loading_violation_message(owner)
           raise ActiveRecord::StrictLoadingViolationError.new(message)
         when :log
           name = "strict_loading_violation.active_record"
@@ -411,7 +411,7 @@ module ActiveRecord
         end
       end
 
-      # Overwrite the default class equality method to provide support for decorated models.
+      # Override the default class equality method to provide support for decorated models.
       def ===(object) # :nodoc:
         object.is_a?(self)
       end

data/lib/active_record/encryption/configurable.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Encryption
-    # Configuration API for +ActiveRecord::Encryption+
+    # Configuration API for ActiveRecord::Encryption
     module Configurable
       extend ActiveSupport::Concern
 
@@ -52,9 +52,15 @@ module ActiveRecord
 
         def install_auto_filtered_parameters_hook(application) # :nodoc:
           ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, encrypted_attribute_name|
-            application.config.filter_parameters << encrypted_attribute_name unless ActiveRecord::Encryption.config.excluded_from_filter_parameters.include?(encrypted_attribute_name)
+            filter_parameter = [("#{klass.model_name.element}" if klass.name), encrypted_attribute_name.to_s].compact.join(".")
+            application.config.filter_parameters << filter_parameter unless excluded_from_filter_parameters?(filter_parameter)
           end
         end
+
+        private
+          def excluded_from_filter_parameters?(filter_parameter)
+            ActiveRecord::Encryption.config.excluded_from_filter_parameters.find { |excluded_filter| excluded_filter.to_s == filter_parameter }
+          end
       end
     end
   end

data/lib/active_record/encryption/contexts.rb

@@ -2,14 +2,14 @@
 
 module ActiveRecord
   module Encryption
-    # +ActiveRecord::Encryption+ uses encryption contexts to configure the different entities used to
+    # ActiveRecord::Encryption uses encryption contexts to configure the different entities used to
     # encrypt/decrypt at a given moment in time.
     #
-    # By default, the library uses a default encryption context. This is the +Context+ that gets configured
+    # By default, the library uses a default encryption context. This is the Context that gets configured
     # initially via +config.active_record.encryption+ options. Library users can define nested encryption contexts
     # when running blocks of code.
     #
-    # See +Context+.
+    # See Context.
     module Contexts
       extend ActiveSupport::Concern