activerecord 7.0.2.4 → 7.0.4

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -139,7 +139,7 @@ module ActiveRecord
       end
 
       def field_ordered_value(column, values) # :nodoc:
-        field = Arel::Nodes::NamedFunction.new("FIELD", [column, values.reverse])
+        field = Arel::Nodes::NamedFunction.new("FIELD", [column, values.reverse.map { |value| Arel::Nodes.build_quoted(value) }])
         Arel::Nodes::Descending.new(field)
       end
 
@@ -711,6 +711,14 @@ module ActiveRecord
             options[:comment] = column.comment
           end
 
+          unless options.key?(:collation)
+            options[:collation] = column.collation
+          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/oid/hstore.rb

@@ -26,7 +26,7 @@ module ActiveRecord
                 raise(ArgumentError, ERROR % scanner.string.inspect)
               end
 
-              unless key = scanner.scan_until(/(?<!\\)(?=")/)
+              unless key = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
                 raise(ArgumentError, ERROR % scanner.string.inspect)
               end
 
@@ -41,7 +41,7 @@ module ActiveRecord
                   raise(ArgumentError, ERROR % scanner.string.inspect)
                 end
 
-                unless value = scanner.scan_until(/(?<!\\)(?=")/)
+                unless value = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
                   raise(ArgumentError, ERROR % scanner.string.inspect)
                 end
 

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/referential_integrity.rb

@@ -45,8 +45,10 @@ Rails needs superuser privileges to disable referential integrity.
             BEGIN
             FOR r IN (
               SELECT FORMAT(
-                'UPDATE pg_constraint SET convalidated=false WHERE conname = ''%I''; ALTER TABLE %I VALIDATE CONSTRAINT %I;',
+                'UPDATE pg_constraint SET convalidated=false WHERE conname = ''%I'' AND connamespace::regnamespace = ''%I''::regnamespace; ALTER TABLE %I.%I VALIDATE CONSTRAINT %I;',
                 constraint_name,
+                table_schema,
+                table_schema,
                 table_name,
                 constraint_name
               ) AS constraint_check

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 = {
@@ -1063,5 +1063,6 @@ module ActiveRecord
         ActiveRecord::Type.register(:vector, OID::Vector, adapter: :postgresql)
         ActiveRecord::Type.register(:xml, OID::Xml, adapter: :postgresql)
     end
+    ActiveSupport.run_load_hooks(:active_record_postgresqladapter, PostgreSQLAdapter)
   end
 end

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

@@ -21,7 +21,7 @@ module ActiveRecord
               WHERE name = #{quote(row['name'])} AND type = 'index'
             SQL
 
-            /\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+))?\z/i =~ index_sql
+            /\bON\b\s*"?(\w+?)"?\s*\((?<expressions>.+?)\)(?:\s*WHERE\b\s*(?<where>.+))?(?:\s*\/\*.*\*\/)?\z/i =~ index_sql
 
             columns = exec_query("PRAGMA index_info(#{quote(row['name'])})", "SCHEMA").map do |col|
               col["name"]
@@ -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_adapters/sqlite3_adapter.rb

@@ -341,7 +341,7 @@ module ActiveRecord
       end
 
       def get_database_version # :nodoc:
-        SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
+        SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)", "SCHEMA"))
       end
 
       def check_version # :nodoc:
@@ -477,8 +477,13 @@ module ActiveRecord
                  options[:rename][column.name.to_sym] ||
                  column.name) : column.name
 
+              if column.has_default?
+                type = lookup_cast_type_from_column(column)
+                default = type.deserialize(column.default)
+              end
+
               @definition.column(column_name, column.type,
-                limit: column.limit, default: column.default,
+                limit: column.limit, default: default,
                 precision: column.precision, scale: column.scale,
                 null: column.null, collation: column.collation,
                 primary_key: column_name == from_primary_key

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/delegated_type.rb

@@ -136,7 +136,7 @@ module ActiveRecord
   #     end
   #   end
   #
-  # Now you can list a bunch of entries, call +Entry#title+, and polymorphism will provide you with the answer.
+  # Now you can list a bunch of entries, call <tt>Entry#title</tt>, and polymorphism will provide you with the answer.
   #
   # == Nested Attributes
   #

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
 

data/lib/active_record/encryption/derived_secret_key_provider.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Encryption
-    # A +KeyProvider+ that derives keys from passwords.
+    # A KeyProvider that derives keys from passwords.
     class DerivedSecretKeyProvider < KeyProvider
       def initialize(passwords)
         super(Array(passwords).collect { |password| Key.derive_from(password) })

data/lib/active_record/encryption/deterministic_key_provider.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Encryption
-    # A +KeyProvider+ that derives keys from passwords.
+    # A KeyProvider that derives keys from passwords.
     class DeterministicKeyProvider < DerivedSecretKeyProvider
       def initialize(password)
         passwords = Array(password)

data/lib/active_record/encryption/encryptable_record.rb

@@ -18,12 +18,10 @@ module ActiveRecord
         #
         # === Options
         #
-        # * <tt>:key_provider</tt> - Configure a +KeyProvider+ for serving the keys to encrypt and
-        #   decrypt this attribute. If not provided, it will default to +ActiveRecord::Encryption.key_provider+.
+        # * <tt>:key_provider</tt> - A key provider to provide encryption and decryption keys. Defaults to
+        #   +ActiveRecord::Encryption.key_provider+.
         # * <tt>:key</tt> - A password to derive the key from. It's a shorthand for a +:key_provider+ that
         #   serves derivated keys. Both options can't be used at the same time.
-        # * <tt>:key_provider</tt> - Set a +:key_provider+ to provide encryption and decryption keys. If not
-        #   provided, it will default to the key provider set with `config.key_provider`.
         # * <tt>:deterministic</tt> - By default, encryption is not deterministic. It will use a random
         #   initialization vector for each encryption operation. This means that encrypting the same content
         #   with the same key twice will generate different ciphertexts. When set to +true+, it will generate the

data/lib/active_record/encryption/encrypted_attribute_type.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Encryption
-    # An +ActiveModel::Type+ that encrypts/decrypts strings of text.
+    # An ActiveModel::Type::Value that encrypts/decrypts strings of text.
     #
     # This is the central piece that connects the encryption system with +encrypts+ declarations in the
     # model classes. Whenever you declare an attribute as encrypted, it configures an +EncryptedAttributeType+
@@ -19,7 +19,7 @@ module ActiveRecord
       #
       # * <tt>:scheme</tt> - A +Scheme+ with the encryption properties for this attribute.
       # * <tt>:cast_type</tt> - A type that will be used to serialize (before encrypting) and deserialize
-      #   (after decrypting). +ActiveModel::Type::String+ by default.
+      #   (after decrypting). ActiveModel::Type::String by default.
       def initialize(scheme:, cast_type: ActiveModel::Type::String.new, previous_type: false)
         super()
         @scheme = scheme

data/lib/active_record/encryption/encryptor.rb

@@ -6,17 +6,17 @@ require "active_support/core_ext/numeric"
 
 module ActiveRecord
   module Encryption
-    # An encryptor exposes the encryption API that +ActiveRecord::Encryption::EncryptedAttributeType+
+    # An encryptor exposes the encryption API that ActiveRecord::Encryption::EncryptedAttributeType
     # uses for encrypting and decrypting attribute values.
     #
-    # It interacts with a +KeyProvider+ for getting the keys, and delegate to
-    # +ActiveRecord::Encryption::Cipher+ the actual encryption algorithm.
+    # It interacts with a KeyProvider for getting the keys, and delegate to
+    # ActiveRecord::Encryption::Cipher the actual encryption algorithm.
     class Encryptor
       # Encrypts +clean_text+ and returns the encrypted result
       #
       # Internally, it will:
       #
-      # 1. Create a new +ActiveRecord::Encryption::Message+
+      # 1. Create a new ActiveRecord::Encryption::Message
       # 2. Compress and encrypt +clean_text+ as the message payload
       # 3. Serialize it with +ActiveRecord::Encryption.message_serializer+ (+ActiveRecord::Encryption::SafeMarshal+
       #    by default)
@@ -26,10 +26,10 @@ module ActiveRecord
       #
       # [:key_provider]
       #   Key provider to use for the encryption operation. It will default to
-      #   +ActiveRecord::Encryption.key_provider+ when not provided
+      #   +ActiveRecord::Encryption.key_provider+ when not provided.
       #
       # [:cipher_options]
-      #   +Cipher+-specific options that will be passed to the Cipher configured in
+      #   Cipher-specific options that will be passed to the Cipher configured in
       #   +ActiveRecord::Encryption.cipher+
       def encrypt(clear_text, key_provider: default_key_provider, cipher_options: {})
         clear_text = force_encoding_if_needed(clear_text) if cipher_options[:deterministic]
@@ -47,7 +47,7 @@ module ActiveRecord
       #   +ActiveRecord::Encryption.key_provider+ when not provided
       #
       # [:cipher_options]
-      #   +Cipher+-specific options that will be passed to the Cipher configured in
+      #   Cipher-specific options that will be passed to the Cipher configured in
       #   +ActiveRecord::Encryption.cipher+
       def decrypt(encrypted_text, key_provider: default_key_provider, cipher_options: {})
         message = deserialize_message(encrypted_text)

data/lib/active_record/encryption/envelope_encryption_key_provider.rb

@@ -4,13 +4,13 @@ module ActiveRecord
   module Encryption
     # Implements a simple envelope encryption approach where:
     #
-    # * It generates a random data-encryption key for each encryption operation
+    # * It generates a random data-encryption key for each encryption operation.
     # * It stores the generated key along with the encrypted payload. It encrypts this key
-    #   with the master key provided in the credential +active_record.encryption.master key+
+    #   with the master key provided in the +active_record_encryption.primary_key+ credential.
     #
     # This provider can work with multiple master keys. It will use the last one for encrypting.
     #
-    # When `config.store_key_references` is true, it will also store a reference to
+    # When +config.active_record.encryption.store_key_references+ is true, it will also store a reference to
     # the specific master key that was used to encrypt the data-encryption key. When not set,
     # it will try all the configured master keys looking for the right one, in order to
     # return the right decryption key.

data/lib/active_record/encryption/extended_deterministic_queries.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module Encryption
     # Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
     #
-    # Active Record Encryption supports querying the db using deterministic attributes. For example:
+    # Active Record \Encryption supports querying the db using deterministic attributes. For example:
     #
     #   Contact.find_by(email_address: "jorge@hey.com")
     #
@@ -16,10 +16,10 @@ module ActiveRecord
     #
     # This patches ActiveRecord to support this automatically. It addresses both:
     #
-    # * ActiveRecord::Base: Used in +Contact.find_by_email_address(...)+
-    # * ActiveRecord::Relation: Used in +Contact.internal.find_by_email_address(...)+
+    # * ActiveRecord::Base - Used in <tt>Contact.find_by_email_address(...)</tt>
+    # * ActiveRecord::Relation - Used in <tt>Contact.internal.find_by_email_address(...)</tt>
     #
-    # +ActiveRecord::Base+ relies on +ActiveRecord::Relation+ (+ActiveRecord::QueryMethods+) but it does
+    # ActiveRecord::Base relies on ActiveRecord::Relation (ActiveRecord::QueryMethods) but it does
     # some prepared statements caching. That's why we need to intercept +ActiveRecord::Base+ as soon
     # as it's invoked (so that the proper prepared statement is cached).
     #

data/lib/active_record/encryption/message.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     # * An encrypted payload
     # * A list of unencrypted headers
     #
-    # See +Encryptor#encrypt+
+    # See Encryptor#encrypt
     class Message
       attr_accessor :payload, :headers
 

data/lib/active_record/encryption/properties.rb

@@ -12,7 +12,7 @@ module ActiveRecord
     #
     #   message.headers.encrypted_data_key # instead of message.headers[:k]
     #
-    # See +Properties#DEFAULT_PROPERTIES+, +Key+, +Message+
+    # See +Properties::DEFAULT_PROPERTIES+, Key, Message
     class Properties
       ALLOWED_VALUE_CLASSES = [String, ActiveRecord::Encryption::Message, Numeric, TrueClass, FalseClass, Symbol, NilClass]
 

data/lib/active_record/encryption/scheme.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     #
     # It validates and serves attribute encryption options.
     #
-    # See +EncryptedAttributeType+, +Context+
+    # See EncryptedAttributeType, Context
     class Scheme
       attr_accessor :previous_schemes
 

data/lib/active_record/enum.rb

@@ -83,7 +83,7 @@ module ActiveRecord
   #
   # In rare circumstances you might need to access the mapping directly.
   # The mappings are exposed through a class method with the pluralized attribute
-  # name, which return the mapping in a +HashWithIndifferentAccess+:
+  # name, which return the mapping in a ActiveSupport::HashWithIndifferentAccess :
   #
   #   Conversation.statuses[:active]    # => 0
   #   Conversation.statuses["archived"] # => 1

data/lib/active_record/fixtures.rb

@@ -241,13 +241,13 @@ module ActiveRecord
   # The generated ID for a given label is constant, so we can discover
   # any fixture's ID without loading anything, as long as we know the label.
   #
-  # == Label references for associations (belongs_to, has_one, has_many)
+  # == Label references for associations (+belongs_to+, +has_one+, +has_many+)
   #
   # Specifying foreign keys in fixtures can be very fragile, not to
   # mention difficult to read. Since Active Record can figure out the ID of
   # any fixture from its label, you can specify FK's by label instead of ID.
   #
-  # === belongs_to
+  # === +belongs_to+
   #
   # Let's break out some more monkeys and pirates.
   #
@@ -286,7 +286,7 @@ module ActiveRecord
   # a target *label* for the *association* (monkey: george) rather than
   # a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
   #
-  # ==== Polymorphic belongs_to
+  # ==== Polymorphic +belongs_to+
   #
   # Supporting polymorphic relationships is a little bit more complicated, since
   # Active Record needs to know what type your association is pointing at. Something
@@ -311,7 +311,7 @@ module ActiveRecord
   #
   # Just provide the polymorphic target type and Active Record will take care of the rest.
   #
-  # === has_and_belongs_to_many or has_many :through
+  # === +has_and_belongs_to_many+ or <tt>has_many :through</tt>
   #
   # Time to give our monkey some fruit.
   #

data/lib/active_record/gem_version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Record as a <tt>Gem::Version</tt>.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 7
     MINOR = 0
-    TINY  = 2
-    PRE   = "4"
+    TINY  = 4
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/locking/pessimistic.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Chain <tt>ActiveRecord::Base#find</tt> to <tt>ActiveRecord::QueryMethods#lock</tt> to obtain an exclusive
+    # Chain <tt>ActiveRecord::Base#find</tt> to ActiveRecord::QueryMethods#lock to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
     #   Account.lock.find(1)
@@ -81,11 +81,11 @@ module ActiveRecord
 
       # Wraps the passed block in a transaction, locking the object
       # before yielding. You can pass the SQL locking clause
-      # as an optional argument (see <tt>#lock!</tt>).
+      # as an optional argument (see #lock!).
       #
       # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
       # and <tt>joinable:</tt> to the wrapping transaction (see
-      # <tt>ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction</tt>).
+      # ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction).
       def with_lock(*args)
         transaction_opts = args.extract_options!
         lock = args.present? ? args.first : true

data/lib/active_record/log_subscriber.rb

@@ -22,10 +22,8 @@ module ActiveRecord
     def strict_loading_violation(event)
       debug do
         owner = event.payload[:owner]
-        association = event.payload[:reflection].klass
-        name = event.payload[:reflection].name
-
-        color("Strict loading violation: #{owner} is marked for strict loading. The #{association} association named :#{name} cannot be lazily loaded.", RED)
+        reflection = event.payload[:reflection]
+        color(reflection.strict_loading_violation_message(owner), RED)
       end
     end
 
@@ -51,7 +49,14 @@ module ActiveRecord
 
         binds = []
         payload[:binds].each_with_index do |attr, i|
-          attribute_name = attr.respond_to?(:name) ? attr.name : attr[i].name
+          attribute_name = if attr.respond_to?(:name)
+            attr.name
+          elsif attr.respond_to?(:[]) && attr[i].respond_to?(:name)
+            attr[i].name
+          else
+            nil
+          end
+
           filtered_params = filter(attribute_name, casted_params[i])
 
           binds << render_bind(attr, filtered_params)

data/lib/active_record/middleware/database_selector.rb

@@ -19,19 +19,22 @@ module ActiveRecord
     # that informs the application when to read from a primary or read from a
     # replica.
     #
-    # To use the DatabaseSelector in your application with default settings add
-    # the following options to your environment config:
+    # To use the DatabaseSelector in your application with default settings,
+    # run the provided generator.
     #
-    #   # This require is only necessary when using `rails new app --minimal`
-    #   require "active_support/core_ext/integer/time"
+    #   bin/rails g active_record:multi_db
     #
-    #   class Application < Rails::Application
+    # This will create a file named +config/initializers/multi_db.rb+ with the
+    # following contents:
+    #
+    #   Rails.application.configure do
     #     config.active_record.database_selector = { delay: 2.seconds }
     #     config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
     #     config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
     #   end
     #
-    # New applications will include these lines commented out in the production.rb.
+    # Alternatively you can set the options in your environment config or
+    # any other config file loaded on boot.
     #
     # The default behavior can be changed by setting the config options to a
     # custom class:
@@ -39,6 +42,10 @@ module ActiveRecord
     #   config.active_record.database_selector = { delay: 2.seconds }
     #   config.active_record.database_resolver = MyResolver
     #   config.active_record.database_resolver_context = MyResolver::MySession
+    #
+    # Note: If you are using `rails new my_app --minimal` you will need to call
+    # `require "active_support/core_ext/integer/time"` to load the libraries
+    # for +Time+.
     class DatabaseSelector
       def initialize(app, resolver_klass = nil, context_klass = nil, options = {})
         @app = app