activerecord 7.0.0 → 7.0.4

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -75,7 +75,7 @@ module ActiveRecord
 
       class << self
         def new_client(conn_params)
-          PG.connect(conn_params)
+          PG.connect(**conn_params)
         rescue ::PG::Error => error
           if conn_params && conn_params[:dbname] && error.message.include?(conn_params[:dbname])
             raise ActiveRecord::NoDatabaseError.db_error(conn_params[:dbname])
@@ -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 = {
@@ -281,7 +281,7 @@ module ActiveRecord
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger, config)
 
-        @connection_parameters = connection_parameters
+        @connection_parameters = connection_parameters || {}
 
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil
@@ -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/quoting.rb

@@ -45,6 +45,19 @@ module ActiveRecord
           0
         end
 
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value = value.call
+            if value.match?(/\A\w+\(.*\)\z/)
+              "(#{value})"
+            else
+              value
+            end
+          else
+            super
+          end
+        end
+
         def type_cast(value) # :nodoc:
           case value
           when BigDecimal

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)
@@ -127,20 +127,20 @@ module ActiveRecord
           end
 
           def new_column_from_field(table_name, field)
-            default = \
-              case field["dflt_value"]
-              when /^null$/i
-                nil
-              when /^'(.*)'$/m
-                $1.gsub("''", "'")
-              when /^"(.*)"$/m
-                $1.gsub('""', '"')
-              else
-                field["dflt_value"]
-              end
+            default = field["dflt_value"]
 
             type_metadata = fetch_type_metadata(field["type"])
-            Column.new(field["name"], default, type_metadata, field["notnull"].to_i == 0, collation: field["collation"])
+            default_value = extract_value_from_default(default)
+            default_function = extract_default_function(default_value, default)
+
+            Column.new(
+              field["name"],
+              default_value,
+              type_metadata,
+              field["notnull"].to_i == 0,
+              default_function,
+              collation: field["collation"]
+            )
           end
 
           def data_source_sql(name = nil, type: nil)

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:
@@ -389,6 +389,34 @@ module ActiveRecord
         end
         alias column_definitions table_structure
 
+        def extract_value_from_default(default)
+          case default
+          when /^null$/i
+            nil
+          # Quoted types
+          when /^'(.*)'$/m
+            $1.gsub("''", "'")
+          # Quoted types
+          when /^"(.*)"$/m
+            $1.gsub('""', '"')
+          # Numeric types
+          when /\A-?\d+(\.\d*)?\z/
+            $&
+          else
+            # Anything else is blank or some function
+            # and we can't know the value of that, so return nil.
+            nil
+          end
+        end
+
+        def extract_default_function(default_value, default)
+          default if has_default_function?(default_value, default)
+        end
+
+        def has_default_function?(default_value, default)
+          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        end
+
         # See: https://www.sqlite.org/lang_altertable.html
         # SQLite has an additional restriction on the ALTER TABLE statement
         def invalid_alter_table_type?(type, options)
@@ -449,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/database_configurations/connection_url_resolver.rb

@@ -2,6 +2,7 @@
 
 require "uri"
 require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/reverse_merge"
 
 module ActiveRecord
   class DatabaseConfigurations

data/lib/active_record/database_configurations.rb

@@ -38,7 +38,7 @@ module ActiveRecord
     #   the returned list. Most of the time we're only iterating over the write
     #   connection (i.e. migrations don't need to run for the write and read connection).
     #   Defaults to +false+.
-    # * <tt>include_hidden:</tte Determines whether to include replicas and configurations
+    # * <tt>include_hidden:</tt> Determines whether to include replicas and configurations
     #   hidden by +database_tasks: false+ in the returned list. Most of the time we're only
     #   iterating over the primary connections (i.e. migrations don't need to run for the
     #   write and read connection). Defaults to +false+.

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
 
@@ -50,11 +50,17 @@ module ActiveRecord
           end
         end
 
-        def install_auto_filtered_parameters(application) # :nodoc:
+        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?(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

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-# Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
-#
-# Active Record Encryption supports querying the db using deterministic attributes. For example:
-#
-#   Contact.find_by(email_address: "jorge@hey.com")
-#
-# The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
-# a problem while the data is being encrypted. This won't work. During that time, you need these
-# queries to be:
-#
-#   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
-#
-# 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+ 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).
-#
-# When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
-#   make sure performance overhead is acceptable.
-#
-# We will extend this to support previous "encryption context" versions in future iterations
-#
-# @TODO Experimental. Support for every kind of query is pending
-# @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
 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:
+    #
+    #   Contact.find_by(email_address: "jorge@hey.com")
+    #
+    # The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
+    # a problem while the data is being encrypted. This won't work. During that time, you need these
+    # queries to be:
+    #
+    #   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
+    #
+    # This patches ActiveRecord to support this automatically. It addresses both:
+    #
+    # * 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
+    # 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).
+    #
+    # When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
+    #   make sure performance overhead is acceptable.
+    #
+    # We will extend this to support previous "encryption context" versions in future iterations
+    #
+    # @TODO Experimental. Support for every kind of query is pending
+    # @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
     module ExtendedDeterministicQueries
       def self.install_support
         ActiveRecord::Relation.prepend(RelationQueries)

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.
   #
@@ -407,7 +407,7 @@ module ActiveRecord
   # defaults:
   #
   #   DEFAULTS: &DEFAULTS
-  #     created_on: <%= 3.weeks.ago.to_formatted_s(:db) %>
+  #     created_on: <%= 3.weeks.ago.to_fs(:db) %>
   #
   #   first:
   #     name: Smurf

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,7 +9,7 @@ module ActiveRecord
   module VERSION
     MAJOR = 7
     MINOR = 0
-    TINY  = 0
+    TINY  = 4
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_record/integration.rb

@@ -79,7 +79,7 @@ module ActiveRecord
           timestamp = max_updated_column_timestamp
 
           if timestamp
-            timestamp = timestamp.utc.to_formatted_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -103,7 +103,7 @@ module ActiveRecord
           raw_timestamp_to_cache_version(timestamp)
 
         elsif timestamp = updated_at
-          timestamp.utc.to_formatted_s(cache_timestamp_format)
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
         raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"

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